// This file is @generated by crates/typos-dict/tests/codegen.rs
#![allow(clippy::unreadable_literal)]

pub static WORD_TRIE: dictgen::DictTrie<&'static [&'static str]> = dictgen::DictTrie {
    root: &WORD_NODE,
    unicode: &WORD_UNICODE_TABLE,
    range: 2..=34,
};

pub static WORD_UNICODE_TABLE: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Unicode("clockwíse"),
        dictgen::InsensitiveStr::Unicode("paínt"),
        dictgen::InsensitiveStr::Unicode("évaluate"),
        dictgen::InsensitiveStr::Unicode("сontain"),
        dictgen::InsensitiveStr::Unicode("сontained"),
        dictgen::InsensitiveStr::Unicode("сontainer"),
        dictgen::InsensitiveStr::Unicode("сontainers"),
        dictgen::InsensitiveStr::Unicode("сontaining"),
        dictgen::InsensitiveStr::Unicode("сontainor"),
        dictgen::InsensitiveStr::Unicode("сontainors"),
        dictgen::InsensitiveStr::Unicode("сontains"),
    ],
    values: &[
        &["clockwise"],
        &["paint"],
        &["evaluate"],
        &["contain"],
        &["contained"],
        &["container"],
        &["containers"],
        &["containing"],
        &["container"],
        &["containers"],
        &["contains"],
    ],
    range: 6..=11,
};

static WORD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_CHILDREN),
    value: None,
};

static WORD_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_A_NODE),
    Some(&WORD_B_NODE),
    Some(&WORD_C_NODE),
    Some(&WORD_D_NODE),
    Some(&WORD_E_NODE),
    Some(&WORD_F_NODE),
    Some(&WORD_G_NODE),
    Some(&WORD_H_NODE),
    Some(&WORD_I_NODE),
    Some(&WORD_J_NODE),
    Some(&WORD_K_NODE),
    Some(&WORD_L_NODE),
    Some(&WORD_M_NODE),
    Some(&WORD_N_NODE),
    Some(&WORD_O_NODE),
    Some(&WORD_P_NODE),
    Some(&WORD_Q_NODE),
    Some(&WORD_R_NODE),
    Some(&WORD_S_NODE),
    Some(&WORD_T_NODE),
    Some(&WORD_U_NODE),
    Some(&WORD_V_NODE),
    Some(&WORD_W_NODE),
    Some(&WORD_X_NODE),
    Some(&WORD_Y_NODE),
    Some(&WORD_Z_NODE),
];

static WORD_Z_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_Z_CHILDREN),
    value: None,
};

static WORD_Z_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_ZA_NODE),
    None,
    None,
    None,
    Some(&WORD_ZE_NODE),
    None,
    None,
    None,
    Some(&WORD_ZI_NODE),
    None,
    None,
    Some(&WORD_ZL_NODE),
    None,
    None,
    Some(&WORD_ZO_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_ZU_NODE),
    None,
    None,
    None,
    Some(&WORD_ZY_NODE),
    None,
];

static WORD_ZY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ZY_CHILDREN),
    value: None,
};

pub static WORD_ZY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("lophone"),
        dictgen::InsensitiveStr::Ascii("lophones"),
    ],
    values: &[&["xylophone"], &["xylophone"]],
    range: 7..=8,
};

static WORD_ZU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ZU_CHILDREN),
    value: None,
};

pub static WORD_ZU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cheenei"),
        dictgen::InsensitiveStr::Ascii("cheeni"),
        dictgen::InsensitiveStr::Ascii("keenee"),
        dictgen::InsensitiveStr::Ascii("keenees"),
        dictgen::InsensitiveStr::Ascii("keenei"),
        dictgen::InsensitiveStr::Ascii("keeni"),
        dictgen::InsensitiveStr::Ascii("ser"),
    ],
    values: &[
        &["zucchinis"],
        &["zucchini"],
        &["zucchini"],
        &["zucchinis"],
        &["zucchinis"],
        &["zucchini"],
        &["user"],
    ],
    range: 3..=7,
};

static WORD_ZO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ZO_CHILDREN),
    value: None,
};

pub static WORD_ZO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("inism"),
        dictgen::InsensitiveStr::Ascii("inist"),
        dictgen::InsensitiveStr::Ascii("inists"),
        dictgen::InsensitiveStr::Ascii("mbe"),
        dictgen::InsensitiveStr::Ascii("mebie"),
        dictgen::InsensitiveStr::Ascii("ocheenei"),
        dictgen::InsensitiveStr::Ascii("ocheeni"),
        dictgen::InsensitiveStr::Ascii("ocheinei"),
        dictgen::InsensitiveStr::Ascii("ocheini"),
        dictgen::InsensitiveStr::Ascii("okeenee"),
        dictgen::InsensitiveStr::Ascii("okeenees"),
        dictgen::InsensitiveStr::Ascii("okeenei"),
        dictgen::InsensitiveStr::Ascii("okeeni"),
        dictgen::InsensitiveStr::Ascii("okeinee"),
        dictgen::InsensitiveStr::Ascii("okeinees"),
        dictgen::InsensitiveStr::Ascii("okeinei"),
        dictgen::InsensitiveStr::Ascii("okeini"),
    ],
    values: &[
        &["zionism"],
        &["zionist"],
        &["zionists"],
        &["zombie"],
        &["zombie"],
        &["zucchinis"],
        &["zucchini"],
        &["zucchinis"],
        &["zucchini"],
        &["zucchini"],
        &["zucchinis"],
        &["zucchinis"],
        &["zucchini"],
        &["zucchini"],
        &["zucchinis"],
        &["zucchinis"],
        &["zucchini"],
    ],
    range: 3..=8,
};

static WORD_ZL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ZL_CHILDREN),
    value: None,
};

pub static WORD_ZL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ot")],
    values: &[&["slot"]],
    range: 2..=2,
};

static WORD_ZI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ZI_CHILDREN),
    value: None,
};

pub static WORD_ZI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("mbabe"),
        dictgen::InsensitiveStr::Ascii("mbabew"),
        dictgen::InsensitiveStr::Ascii("mbabwae"),
        dictgen::InsensitiveStr::Ascii("mbabwaen"),
        dictgen::InsensitiveStr::Ascii("mbawbe"),
        dictgen::InsensitiveStr::Ascii("mmap"),
        dictgen::InsensitiveStr::Ascii("mpaps"),
        dictgen::InsensitiveStr::Ascii("nk"),
        dictgen::InsensitiveStr::Ascii("noists"),
        dictgen::InsensitiveStr::Ascii("onisim"),
        dictgen::InsensitiveStr::Ascii("onistas"),
        dictgen::InsensitiveStr::Ascii("onistes"),
        dictgen::InsensitiveStr::Ascii("onistisk"),
        dictgen::InsensitiveStr::Ascii("onistm"),
        dictgen::InsensitiveStr::Ascii("onsim"),
        dictgen::InsensitiveStr::Ascii("onsit"),
        dictgen::InsensitiveStr::Ascii("onsits"),
        dictgen::InsensitiveStr::Ascii("ped"),
        dictgen::InsensitiveStr::Ascii("per"),
        dictgen::InsensitiveStr::Ascii("ping"),
    ],
    values: &[
        &["zimbabwe"],
        &["zimbabwe"],
        &["zimbabwe"],
        &["zimbabwe"],
        &["zimbabwe"],
        &["zipmap"],
        &["zipmaps"],
        &["zinc"],
        &["zionists"],
        &["zionism"],
        &["zionists"],
        &["zionists"],
        &["zionists"],
        &["zionism"],
        &["zionism"],
        &["zionist"],
        &["zionists"],
        &["zipped"],
        &["zipper"],
        &["zipping"],
    ],
    range: 2..=8,
};

static WORD_ZE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ZE_CHILDREN),
    value: None,
};

pub static WORD_ZE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("alotes"),
        dictgen::InsensitiveStr::Ascii("aloths"),
        dictgen::InsensitiveStr::Ascii("alotus"),
        dictgen::InsensitiveStr::Ascii("alouts"),
        dictgen::InsensitiveStr::Ascii("altos"),
        dictgen::InsensitiveStr::Ascii("ebra"),
        dictgen::InsensitiveStr::Ascii("fer"),
        dictgen::InsensitiveStr::Ascii("fers"),
        dictgen::InsensitiveStr::Ascii("laots"),
        dictgen::InsensitiveStr::Ascii("laous"),
        dictgen::InsensitiveStr::Ascii("llot"),
        dictgen::InsensitiveStr::Ascii("llots"),
        dictgen::InsensitiveStr::Ascii("mporary"),
        dictgen::InsensitiveStr::Ascii("pplein"),
        dictgen::InsensitiveStr::Ascii("pplien"),
    ],
    values: &[
        &["zealots"],
        &["zealots"],
        &["zealots"],
        &["zealous"],
        &["zealots"],
        &["zebra"],
        &["zephyr"],
        &["zephyrs"],
        &["zealots"],
        &["zealous"],
        &["zealot"],
        &["zealots"],
        &["temporary"],
        &["zeppelin"],
        &["zeppelin"],
    ],
    range: 3..=7,
};

static WORD_ZA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ZA_CHILDREN),
    value: None,
};

pub static WORD_ZA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("elots"),
        dictgen::InsensitiveStr::Ascii("rs"),
    ],
    values: &[&["zealots"], &["czars"]],
    range: 2..=5,
};

static WORD_Y_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_Y_CHILDREN),
    value: None,
};

static WORD_Y_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_YA_NODE),
    None,
    None,
    None,
    Some(&WORD_YE_NODE),
    None,
    None,
    Some(&WORD_YH_NODE),
    Some(&WORD_YI_NODE),
    None,
    None,
    None,
    Some(&WORD_YM_NODE),
    None,
    Some(&WORD_YO_NODE),
    Some(&WORD_YP_NODE),
    None,
    Some(&WORD_YR_NODE),
    Some(&WORD_YS_NODE),
    Some(&WORD_YT_NODE),
    Some(&WORD_YU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_YU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_YU_CHILDREN),
    value: None,
};

pub static WORD_YU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("foric"),
        dictgen::InsensitiveStr::Ascii("forically"),
        dictgen::InsensitiveStr::Ascii("goslac"),
        dictgen::InsensitiveStr::Ascii("o"),
        dictgen::InsensitiveStr::Ascii("or"),
        dictgen::InsensitiveStr::Ascii("r"),
    ],
    values: &[
        &["euphoric"],
        &["euphorically"],
        &["yugoslav"],
        &["you"],
        &["your"],
        &["your"],
    ],
    range: 1..=9,
};

static WORD_YT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_YT_CHILDREN),
    value: None,
};

pub static WORD_YT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ou")],
    values: &[&["you"]],
    range: 2..=2,
};

static WORD_YS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_YS_CHILDREN),
    value: None,
};

pub static WORD_YS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("e")],
    values: &[&["yes", "use", "nyse"]],
    range: 1..=1,
};

static WORD_YR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_YR_CHILDREN),
    value: None,
};

pub static WORD_YR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ea")],
    values: &[&["year"]],
    range: 2..=2,
};

static WORD_YP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_YP_CHILDREN),
    value: None,
};

pub static WORD_YP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("es")],
    values: &[&["types"]],
    range: 2..=2,
};

static WORD_YO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_YO_CHILDREN),
    value: None,
};

pub static WORD_YO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("esmite"),
        dictgen::InsensitiveStr::Ascii("man"),
        dictgen::InsensitiveStr::Ascii("men"),
        dictgen::InsensitiveStr::Ascii("rksher"),
        dictgen::InsensitiveStr::Ascii("rkshie"),
        dictgen::InsensitiveStr::Ascii("rkshrie"),
        dictgen::InsensitiveStr::Ascii("rskhire"),
        dictgen::InsensitiveStr::Ascii("semeti"),
        dictgen::InsensitiveStr::Ascii("semitie"),
        dictgen::InsensitiveStr::Ascii("simete"),
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("tube"),
        dictgen::InsensitiveStr::Ascii("uforic"),
        dictgen::InsensitiveStr::Ascii("uforically"),
        dictgen::InsensitiveStr::Ascii("ulogy"),
        dictgen::InsensitiveStr::Ascii("un"),
        dictgen::InsensitiveStr::Ascii("ungents"),
        dictgen::InsensitiveStr::Ascii("unget"),
        dictgen::InsensitiveStr::Ascii("ure"),
        dictgen::InsensitiveStr::Ascii("urr"),
        dictgen::InsensitiveStr::Ascii("urselfe"),
        dictgen::InsensitiveStr::Ascii("urselfes"),
        dictgen::InsensitiveStr::Ascii("urselv"),
        dictgen::InsensitiveStr::Ascii("urselve"),
        dictgen::InsensitiveStr::Ascii("urselvs"),
        dictgen::InsensitiveStr::Ascii("ursleves"),
        dictgen::InsensitiveStr::Ascii("useff"),
        dictgen::InsensitiveStr::Ascii("uself"),
        dictgen::InsensitiveStr::Ascii("uthinasia"),
    ],
    values: &[
        &["yosemite"],
        &["yeoman"],
        &["yeomen"],
        &["yorkshire"],
        &["yorkshire"],
        &["yorkshire"],
        &["yorkshire"],
        &["yosemite"],
        &["yosemite"],
        &["yosemite"],
        &["yacht"],
        &["youtube"],
        &["euphoric"],
        &["euphorically"],
        &["eulogy"],
        &["your", "you", "young"],
        &["youngest"],
        &["youngest"],
        &["your"],
        &["your"],
        &["yourself", "yourselves"],
        &["yourselves"],
        &["yourself", "yourselves"],
        &["yourselves", "yourself"],
        &["yourselves"],
        &["yourselves"],
        &["yousef", "yourself"],
        &["yourself"],
        &["euthanasia"],
    ],
    range: 1..=10,
};

static WORD_YM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_YM_CHILDREN),
    value: None,
};

pub static WORD_YM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("bols")],
    values: &[&["symbols"]],
    range: 4..=4,
};

static WORD_YI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_YI_CHILDREN),
    value: None,
};

pub static WORD_YI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eldin"),
        dictgen::InsensitiveStr::Ascii("eleded"),
    ],
    values: &[&["yielding"], &["yielded"]],
    range: 5..=6,
};

static WORD_YH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_YH_CHILDREN),
    value: None,
};

pub static WORD_YH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("e")],
    values: &[&["the"]],
    range: 1..=1,
};

static WORD_YE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_YE_CHILDREN),
    value: None,
};

pub static WORD_YE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("arm"),
        dictgen::InsensitiveStr::Ascii("asr"),
        dictgen::InsensitiveStr::Ascii("ild"),
        dictgen::InsensitiveStr::Ascii("ilded"),
        dictgen::InsensitiveStr::Ascii("ilding"),
        dictgen::InsensitiveStr::Ascii("ilds"),
        dictgen::InsensitiveStr::Ascii("ld"),
        dictgen::InsensitiveStr::Ascii("lded"),
        dictgen::InsensitiveStr::Ascii("lding"),
        dictgen::InsensitiveStr::Ascii("lds"),
        dictgen::InsensitiveStr::Ascii("llo"),
        dictgen::InsensitiveStr::Ascii("mentite"),
        dictgen::InsensitiveStr::Ascii("ra"),
        dictgen::InsensitiveStr::Ascii("ras"),
        dictgen::InsensitiveStr::Ascii("rsa"),
    ],
    values: &[
        &["year"],
        &["years"],
        &["yield"],
        &["yielded"],
        &["yielding"],
        &["yields"],
        &["yield"],
        &["yielded"],
        &["yielding"],
        &["yields"],
        &["yellow"],
        &["yemenite", "yemeni"],
        &["year"],
        &["years"],
        &["years"],
    ],
    range: 2..=7,
};

static WORD_YA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_YA_CHILDREN),
    value: None,
};

pub static WORD_YA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ching"),
        dictgen::InsensitiveStr::Ascii("er"),
        dictgen::InsensitiveStr::Ascii("erly"),
        dictgen::InsensitiveStr::Ascii("ers"),
        dictgen::InsensitiveStr::Ascii("tch"),
        dictgen::InsensitiveStr::Ascii("u"),
    ],
    values: &[
        &["yachting"],
        &["year"],
        &["yearly"],
        &["years"],
        &["yacht"],
        &["you", "yaw"],
    ],
    range: 1..=5,
};

static WORD_X_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_X_CHILDREN),
    value: None,
};

pub static WORD_X_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("describe"),
        dictgen::InsensitiveStr::Ascii("dpf"),
        dictgen::InsensitiveStr::Ascii("enbolade"),
        dictgen::InsensitiveStr::Ascii("enobalde"),
        dictgen::InsensitiveStr::Ascii("enohpobic"),
        dictgen::InsensitiveStr::Ascii("enophibia"),
        dictgen::InsensitiveStr::Ascii("enophibic"),
        dictgen::InsensitiveStr::Ascii("enophobical"),
        dictgen::InsensitiveStr::Ascii("enophoblic"),
        dictgen::InsensitiveStr::Ascii("enophoby"),
        dictgen::InsensitiveStr::Ascii("enophonic"),
        dictgen::InsensitiveStr::Ascii("enophopia"),
        dictgen::InsensitiveStr::Ascii("enophopic"),
        dictgen::InsensitiveStr::Ascii("eonblade"),
        dictgen::InsensitiveStr::Ascii("eonphobia"),
        dictgen::InsensitiveStr::Ascii("eonphobic"),
        dictgen::InsensitiveStr::Ascii("epect"),
        dictgen::InsensitiveStr::Ascii("epected"),
        dictgen::InsensitiveStr::Ascii("epectedly"),
        dictgen::InsensitiveStr::Ascii("epecting"),
        dictgen::InsensitiveStr::Ascii("epects"),
        dictgen::InsensitiveStr::Ascii("getttext"),
        dictgen::InsensitiveStr::Ascii("initiazlize"),
        dictgen::InsensitiveStr::Ascii("mdoel"),
        dictgen::InsensitiveStr::Ascii("ode"),
        dictgen::InsensitiveStr::Ascii("our"),
        dictgen::InsensitiveStr::Ascii("windows"),
        dictgen::InsensitiveStr::Ascii("you"),
    ],
    values: &[
        &["describe"],
        &["xpdf"],
        &["xenoblade"],
        &["xenoblade"],
        &["xenophobic"],
        &["xenophobia"],
        &["xenophobic"],
        &["xenophobia"],
        &["xenophobic"],
        &["xenophobia"],
        &["xenophobic"],
        &["xenophobia"],
        &["xenophobic"],
        &["xenoblade"],
        &["xenophobia"],
        &["xenophobic"],
        &["expect"],
        &["expected"],
        &["expectedly"],
        &["expecting"],
        &["expects"],
        &["xgettext"],
        &["xinitialize"],
        &["xmodel"],
        &["code", "xcode"],
        &["your"],
        &["x"],
        &["you"],
    ],
    range: 3..=11,
};

static WORD_W_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_W_CHILDREN),
    value: None,
};

static WORD_W_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_WA_NODE),
    None,
    None,
    None,
    Some(&WORD_WE_NODE),
    None,
    None,
    Some(&WORD_WH_NODE),
    Some(&WORD_WI_NODE),
    Some(&WORD_WJ_NODE),
    None,
    Some(&WORD_WL_NODE),
    Some(&WORD_WM_NODE),
    Some(&WORD_WN_NODE),
    Some(&WORD_WO_NODE),
    None,
    Some(&WORD_WQ_NODE),
    Some(&WORD_WR_NODE),
    Some(&WORD_WS_NODE),
    Some(&WORD_WT_NODE),
    Some(&WORD_WU_NODE),
    None,
    None,
    None,
    Some(&WORD_WY_NODE),
    None,
];

static WORD_WY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_WY_CHILDREN),
    value: None,
};

pub static WORD_WY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("a"),
        dictgen::InsensitiveStr::Ascii("th"),
        dictgen::InsensitiveStr::Ascii("thout"),
    ],
    values: &[&["way"], &["with"], &["without"]],
    range: 1..=5,
};

static WORD_WU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_WU_CHILDREN),
    value: None,
};

pub static WORD_WU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("old"),
        dictgen::InsensitiveStr::Ascii("pport"),
        dictgen::InsensitiveStr::Ascii("th"),
        dictgen::InsensitiveStr::Ascii("thin"),
    ],
    values: &[&["would"], &["support"], &["with"], &["within"]],
    range: 2..=5,
};

static WORD_WT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_WT_CHILDREN),
    value: None,
};

pub static WORD_WT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("h"),
        dictgen::InsensitiveStr::Ascii("iches"),
        dictgen::InsensitiveStr::Ascii("ih"),
        dictgen::InsensitiveStr::Ascii("yle"),
    ],
    values: &[&["with"], &["witches"], &["with"], &["style"]],
    range: 1..=5,
};

static WORD_WS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_WS_CHILDREN),
    value: None,
};

pub static WORD_WS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ee"),
        dictgen::InsensitiveStr::Ascii("er"),
    ],
    values: &[&["see"], &["user"]],
    range: 2..=2,
};

static WORD_WR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_WR_CHILDREN),
    value: None,
};

static WORD_WR_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_WRA_NODE),
    None,
    None,
    None,
    Some(&WORD_WRE_NODE),
    None,
    None,
    None,
    Some(&WORD_WRI_NODE),
    None,
    Some(&WORD_WRK_NODE),
    None,
    None,
    Some(&WORD_WRN_NODE),
    Some(&WORD_WRO_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_WRT_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_WRY_NODE),
    None,
];

static WORD_WRY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_WRY_CHILDREN),
    value: None,
};

pub static WORD_WRY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("th"),
        dictgen::InsensitiveStr::Ascii("thed"),
        dictgen::InsensitiveStr::Ascii("thes"),
        dictgen::InsensitiveStr::Ascii("thing"),
    ],
    values: &[&["writhe"], &["writhed"], &["writhes"], &["writhing"]],
    range: 2..=5,
};

static WORD_WRT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_WRT_CHILDREN),
    value: None,
};

pub static WORD_WRT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eched"),
        dictgen::InsensitiveStr::Ascii("ie"),
        dictgen::InsensitiveStr::Ascii("ing"),
    ],
    values: &[&["wretched"], &["write"], &["writing"]],
    range: 2..=5,
};

static WORD_WRO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_WRO_CHILDREN),
    value: None,
};

pub static WORD_WRO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("d"),
        dictgen::InsensitiveStr::Ascii("et"),
        dictgen::InsensitiveStr::Ascii("g"),
        dictgen::InsensitiveStr::Ascii("k"),
        dictgen::InsensitiveStr::Ascii("ked"),
        dictgen::InsensitiveStr::Ascii("kflow"),
        dictgen::InsensitiveStr::Ascii("kflows"),
        dictgen::InsensitiveStr::Ascii("king"),
        dictgen::InsensitiveStr::Ascii("kload"),
        dictgen::InsensitiveStr::Ascii("kloads"),
        dictgen::InsensitiveStr::Ascii("ks"),
        dictgen::InsensitiveStr::Ascii("n"),
        dictgen::InsensitiveStr::Ascii("nf"),
        dictgen::InsensitiveStr::Ascii("nly"),
        dictgen::InsensitiveStr::Ascii("nt"),
        dictgen::InsensitiveStr::Ascii("rker"),
    ],
    values: &[
        &["word"],
        &["wrote"],
        &["wrong"],
        &["work"],
        &["worked"],
        &["workflow"],
        &["workflows"],
        &["working"],
        &["workload"],
        &["workloads"],
        &["works"],
        &["wrong"],
        &["wrong"],
        &["wrongly"],
        &["wrong"],
        &["worker"],
    ],
    range: 1..=6,
};

static WORD_WRN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_WRN_CHILDREN),
    value: None,
};

pub static WORD_WRN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("agler")],
    values: &[&["wrangler"]],
    range: 5..=5,
};

static WORD_WRK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_WRK_CHILDREN),
    value: None,
};

pub static WORD_WRK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("load"),
        dictgen::InsensitiveStr::Ascii("loads"),
    ],
    values: &[&["workload"], &["workloads"]],
    range: 4..=5,
};

static WORD_WRI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_WRI_CHILDREN),
    value: None,
};

pub static WORD_WRI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("et"),
        dictgen::InsensitiveStr::Ascii("tebufer"),
        dictgen::InsensitiveStr::Ascii("techetque"),
        dictgen::InsensitiveStr::Ascii("ted"),
        dictgen::InsensitiveStr::Ascii("teing"),
        dictgen::InsensitiveStr::Ascii("ten"),
        dictgen::InsensitiveStr::Ascii("tet"),
        dictgen::InsensitiveStr::Ascii("tewr"),
        dictgen::InsensitiveStr::Ascii("tingm"),
        dictgen::InsensitiveStr::Ascii("tre"),
        dictgen::InsensitiveStr::Ascii("tte"),
        dictgen::InsensitiveStr::Ascii("tter"),
        dictgen::InsensitiveStr::Ascii("tters"),
        dictgen::InsensitiveStr::Ascii("ttin"),
        dictgen::InsensitiveStr::Ascii("tting"),
        dictgen::InsensitiveStr::Ascii("ttten"),
    ],
    values: &[
        &["write"],
        &["writebuffer"],
        &["writecheque"],
        &["wrote", "written", "write", "writer"],
        &["writing"],
        &["written"],
        &["writes"],
        &["writer"],
        &["writing"],
        &["writer"],
        &["write", "written"],
        &["writer", "written"],
        &["writers"],
        &["written", "writing"],
        &["writing"],
        &["written"],
    ],
    range: 2..=9,
};

static WORD_WRE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_WRE_CHILDREN),
    value: None,
};

pub static WORD_WRE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ckign"),
        dictgen::InsensitiveStr::Ascii("cthed"),
        dictgen::InsensitiveStr::Ascii("kcing"),
        dictgen::InsensitiveStr::Ascii("slte"),
        dictgen::InsensitiveStr::Ascii("slter"),
        dictgen::InsensitiveStr::Ascii("ssel"),
        dictgen::InsensitiveStr::Ascii("sseled"),
        dictgen::InsensitiveStr::Ascii("sseler"),
        dictgen::InsensitiveStr::Ascii("sselers"),
        dictgen::InsensitiveStr::Ascii("sseling"),
        dictgen::InsensitiveStr::Ascii("ssels"),
        dictgen::InsensitiveStr::Ascii("sters"),
        dictgen::InsensitiveStr::Ascii("stlewar"),
    ],
    values: &[
        &["wrecking"],
        &["wretched"],
        &["wrecking"],
        &["wrestle"],
        &["wrestler"],
        &["wrestle"],
        &["wrestled"],
        &["wrestler"],
        &["wrestlers"],
        &["wrestling"],
        &["wrestles"],
        &["wrestlers"],
        &["wrestler"],
    ],
    range: 4..=7,
};

static WORD_WRA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_WRA_CHILDREN),
    value: None,
};

pub static WORD_WRA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("app"),
        dictgen::InsensitiveStr::Ascii("apped"),
        dictgen::InsensitiveStr::Ascii("apper"),
        dictgen::InsensitiveStr::Ascii("appers"),
        dictgen::InsensitiveStr::Ascii("apping"),
        dictgen::InsensitiveStr::Ascii("apps"),
        dictgen::InsensitiveStr::Ascii("ning"),
        dictgen::InsensitiveStr::Ascii("nings"),
        dictgen::InsensitiveStr::Ascii("nlger"),
        dictgen::InsensitiveStr::Ascii("ped"),
        dictgen::InsensitiveStr::Ascii("pepd"),
        dictgen::InsensitiveStr::Ascii("per"),
        dictgen::InsensitiveStr::Ascii("ping"),
        dictgen::InsensitiveStr::Ascii("pp"),
        dictgen::InsensitiveStr::Ascii("ppered"),
        dictgen::InsensitiveStr::Ascii("ppng"),
        dictgen::InsensitiveStr::Ascii("ppning"),
        dictgen::InsensitiveStr::Ascii("pps"),
    ],
    values: &[
        &["wrap"],
        &["wrapped"],
        &["wrapper"],
        &["wrappers"],
        &["wrapping"],
        &["wraps"],
        &["warning"],
        &["warnings"],
        &["wrangler"],
        &["wrapped", "warped"],
        &["wrapped"],
        &["wrapper"],
        &["wrapping", "warping"],
        &["wrap"],
        &["wrapped"],
        &["wrapping"],
        &["wrapping"],
        &["wraps"],
    ],
    range: 2..=6,
};

static WORD_WQ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_WQ_CHILDREN),
    value: None,
};

pub static WORD_WQ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("s")],
    values: &[&["was"]],
    range: 1..=1,
};

static WORD_WO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_WO_CHILDREN),
    value: None,
};

static WORD_WO_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_WOA_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_WOH_NODE),
    Some(&WORD_WOI_NODE),
    None,
    Some(&WORD_WOK_NODE),
    Some(&WORD_WOL_NODE),
    Some(&WORD_WOM_NODE),
    Some(&WORD_WON_NODE),
    Some(&WORD_WOO_NODE),
    None,
    None,
    Some(&WORD_WOR_NODE),
    None,
    Some(&WORD_WOT_NODE),
    Some(&WORD_WOU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_WOU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_WOU_CHILDREN),
    value: None,
};

pub static WORD_WOU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("d"),
        dictgen::InsensitiveStr::Ascii("dl"),
        dictgen::InsensitiveStr::Ascii("dld"),
        dictgen::InsensitiveStr::Ascii("dlnt"),
        dictgen::InsensitiveStr::Ascii("dlve"),
        dictgen::InsensitiveStr::Ascii("ldnot"),
        dictgen::InsensitiveStr::Ascii("lndt"),
        dictgen::InsensitiveStr::Ascii("nderful"),
        dictgen::InsensitiveStr::Ascii("old"),
        dictgen::InsensitiveStr::Ascii("uld"),
    ],
    values: &[
        &["would"],
        &["would"],
        &["would"],
        &["wouldnt"],
        &["wouldve"],
        &["wouldnt"],
        &["wouldnt"],
        &["wonderful"],
        &["would"],
        &["would"],
    ],
    range: 1..=7,
};

static WORD_WOT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_WOT_CHILDREN),
    value: None,
};

pub static WORD_WOT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("h"),
        dictgen::InsensitiveStr::Ascii("hout"),
        dictgen::InsensitiveStr::Ascii("k"),
        dictgen::InsensitiveStr::Ascii("ked"),
        dictgen::InsensitiveStr::Ascii("king"),
        dictgen::InsensitiveStr::Ascii("ks"),
    ],
    values: &[
        &["worth"],
        &["without"],
        &["work"],
        &["worked"],
        &["working"],
        &["works"],
    ],
    range: 1..=4,
};

static WORD_WOR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_WOR_CHILDREN),
    value: None,
};

static WORD_WOR_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_WORA_NODE),
    Some(&WORD_WORB_NODE),
    Some(&WORD_WORC_NODE),
    Some(&WORD_WORD_NODE),
    None,
    Some(&WORD_WORF_NODE),
    None,
    Some(&WORD_WORH_NODE),
    None,
    None,
    Some(&WORD_WORK_NODE),
    Some(&WORD_WORL_NODE),
    None,
    Some(&WORD_WORN_NODE),
    None,
    None,
    None,
    Some(&WORD_WORR_NODE),
    Some(&WORD_WORS_NODE),
    Some(&WORD_WORT_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_WORT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_WORT_CHILDREN),
    value: None,
};

pub static WORD_WORT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("helss"),
        dictgen::InsensitiveStr::Ascii("hing"),
        dictgen::InsensitiveStr::Ascii("hwile"),
    ],
    values: &[&["worthless"], &["worth", "meriting"], &["worthwhile"]],
    range: 4..=5,
};

static WORD_WORS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_WORS_CHILDREN),
    value: Some(&["wars", "was", "works", "worse", "worst"]),
};

pub static WORD_WORS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("er"),
        dictgen::InsensitiveStr::Ascii("hippig"),
        dictgen::InsensitiveStr::Ascii("hippping"),
        dictgen::InsensitiveStr::Ascii("hoping"),
        dictgen::InsensitiveStr::Ascii("hopping"),
        dictgen::InsensitiveStr::Ascii("tened"),
    ],
    values: &[
        &["worse"],
        &["worshipping"],
        &["worshipping"],
        &["worshiping"],
        &["worshipping"],
        &["worsened"],
    ],
    range: 2..=8,
};

static WORD_WORR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_WORR_CHILDREN),
    value: None,
};

pub static WORD_WORR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("ry"),
    ],
    values: &[&["working"], &["worry"]],
    range: 2..=3,
};

static WORD_WORN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_WORN_CHILDREN),
    value: None,
};

pub static WORD_WORN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("g"),
        dictgen::InsensitiveStr::Ascii("ged"),
        dictgen::InsensitiveStr::Ascii("gs"),
    ],
    values: &[&["wrong", "worn"], &["wronged"], &["wrongs"]],
    range: 1..=3,
};

static WORD_WORL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_WORL_CHILDREN),
    value: Some(&["world"]),
};

pub static WORD_WORL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("divew"),
        dictgen::InsensitiveStr::Ascii("dveiw"),
        dictgen::InsensitiveStr::Ascii("oad"),
        dictgen::InsensitiveStr::Ascii("oads"),
        dictgen::InsensitiveStr::Ascii("s"),
    ],
    values: &[
        &["worldview"],
        &["worldview"],
        &["workload"],
        &["workloads"],
        &["world"],
    ],
    range: 1..=5,
};

static WORD_WORK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_WORK_CHILDREN),
    value: None,
};

pub static WORD_WORK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aorund"),
        dictgen::InsensitiveStr::Ascii("aorunds"),
        dictgen::InsensitiveStr::Ascii("aound"),
        dictgen::InsensitiveStr::Ascii("aounds"),
        dictgen::InsensitiveStr::Ascii("araound"),
        dictgen::InsensitiveStr::Ascii("araounds"),
        dictgen::InsensitiveStr::Ascii("arbound"),
        dictgen::InsensitiveStr::Ascii("aronud"),
        dictgen::InsensitiveStr::Ascii("aronuds"),
        dictgen::InsensitiveStr::Ascii("aroud"),
        dictgen::InsensitiveStr::Ascii("aroudn"),
        dictgen::InsensitiveStr::Ascii("aroudns"),
        dictgen::InsensitiveStr::Ascii("arouds"),
        dictgen::InsensitiveStr::Ascii("arould"),
        dictgen::InsensitiveStr::Ascii("aroung"),
        dictgen::InsensitiveStr::Ascii("aroungs"),
        dictgen::InsensitiveStr::Ascii("arround"),
        dictgen::InsensitiveStr::Ascii("arrounds"),
        dictgen::InsensitiveStr::Ascii("arund"),
        dictgen::InsensitiveStr::Ascii("arunds"),
        dictgen::InsensitiveStr::Ascii("banch"),
        dictgen::InsensitiveStr::Ascii("banches"),
        dictgen::InsensitiveStr::Ascii("banchs"),
        dictgen::InsensitiveStr::Ascii("benchs"),
        dictgen::InsensitiveStr::Ascii("bennch"),
        dictgen::InsensitiveStr::Ascii("bennches"),
        dictgen::InsensitiveStr::Ascii("bnech"),
        dictgen::InsensitiveStr::Ascii("bneches"),
        dictgen::InsensitiveStr::Ascii("boos"),
        dictgen::InsensitiveStr::Ascii("d"),
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("faround"),
        dictgen::InsensitiveStr::Ascii("fore"),
        dictgen::InsensitiveStr::Ascii("fow"),
        dictgen::InsensitiveStr::Ascii("fows"),
        dictgen::InsensitiveStr::Ascii("froce"),
        dictgen::InsensitiveStr::Ascii("ign"),
        dictgen::InsensitiveStr::Ascii("ingest"),
        dictgen::InsensitiveStr::Ascii("ins"),
        dictgen::InsensitiveStr::Ascii("lfow"),
        dictgen::InsensitiveStr::Ascii("lfows"),
        dictgen::InsensitiveStr::Ascii("psace"),
        dictgen::InsensitiveStr::Ascii("psaces"),
        dictgen::InsensitiveStr::Ascii("round"),
        dictgen::InsensitiveStr::Ascii("rounds"),
        dictgen::InsensitiveStr::Ascii("spce"),
        dictgen::InsensitiveStr::Ascii("spsace"),
        dictgen::InsensitiveStr::Ascii("spsaces"),
        dictgen::InsensitiveStr::Ascii("staion"),
        dictgen::InsensitiveStr::Ascii("staions"),
        dictgen::InsensitiveStr::Ascii("staition"),
        dictgen::InsensitiveStr::Ascii("staitions"),
        dictgen::InsensitiveStr::Ascii("staiton"),
        dictgen::InsensitiveStr::Ascii("staitons"),
        dictgen::InsensitiveStr::Ascii("staton"),
        dictgen::InsensitiveStr::Ascii("ststion"),
        dictgen::InsensitiveStr::Ascii("ststions"),
        dictgen::InsensitiveStr::Ascii("wround"),
    ],
    values: &[
        &["workaround"],
        &["workarounds"],
        &["workaround"],
        &["workarounds"],
        &["workaround"],
        &["workarounds"],
        &["workaround"],
        &["workaround"],
        &["workarounds"],
        &["workaround"],
        &["workaround"],
        &["workarounds"],
        &["workarounds"],
        &["workaround"],
        &["workaround"],
        &["workarounds"],
        &["workaround"],
        &["workarounds"],
        &["workaround"],
        &["workarounds"],
        &["workbench"],
        &["workbenches"],
        &["workbenches"],
        &["workbenches"],
        &["workbench"],
        &["workbenches"],
        &["workbench"],
        &["workbenches"],
        &["workbooks"],
        &["worked", "works"],
        &["work", "worked", "works"],
        &["works", "workers"],
        &["workaround"],
        &["workforce"],
        &["workflow"],
        &["workflows"],
        &["workforce"],
        &["working"],
        &["workings"],
        &["workings"],
        &["workflow"],
        &["workflows"],
        &["workspace"],
        &["workspaces"],
        &["workaround"],
        &["workarounds"],
        &["workspace"],
        &["workspace"],
        &["workspaces"],
        &["workstation"],
        &["workstations"],
        &["workstation"],
        &["workstations"],
        &["workstation"],
        &["workstations"],
        &["workstation"],
        &["workstation"],
        &["workstations"],
        &["workaround"],
    ],
    range: 1..=9,
};

static WORD_WORH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_WORH_CHILDREN),
    value: None,
};

pub static WORD_WORH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("siping"),
        dictgen::InsensitiveStr::Ascii("sipping"),
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("tless"),
    ],
    values: &[
        &["worshiping"],
        &["worshipping"],
        &["worth"],
        &["worthless"],
    ],
    range: 1..=7,
};

static WORD_WORF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_WORF_CHILDREN),
    value: None,
};

pub static WORD_WORF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("klow"),
        dictgen::InsensitiveStr::Ascii("klows"),
        dictgen::InsensitiveStr::Ascii("low"),
        dictgen::InsensitiveStr::Ascii("lows"),
    ],
    values: &[&["workflow"], &["workflows"], &["workflow"], &["workflows"]],
    range: 3..=5,
};

static WORD_WORD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_WORD_CHILDREN),
    value: None,
};

pub static WORD_WORD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("l"),
        dictgen::InsensitiveStr::Ascii("lview"),
        dictgen::InsensitiveStr::Ascii("lwide"),
        dictgen::InsensitiveStr::Ascii("pres"),
        dictgen::InsensitiveStr::Ascii("presss"),
    ],
    values: &[
        &["world"],
        &["worldview"],
        &["worldwide"],
        &["wordpress"],
        &["wordpress"],
    ],
    range: 1..=6,
};

static WORD_WORC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_WORC_CHILDREN),
    value: None,
};

pub static WORD_WORC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("hester")],
    values: &[&["worcester"]],
    range: 6..=6,
};

static WORD_WORB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_WORB_CHILDREN),
    value: None,
};

pub static WORD_WORB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ench"),
        dictgen::InsensitiveStr::Ascii("enches"),
    ],
    values: &[&["workbench"], &["workbenches"]],
    range: 4..=6,
};

static WORD_WORA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_WORA_CHILDREN),
    value: None,
};

pub static WORD_WORA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("round"),
        dictgen::InsensitiveStr::Ascii("rounds"),
    ],
    values: &[&["workaround"], &["workarounds"]],
    range: 5..=6,
};

static WORD_WOO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_WOO_CHILDREN),
    value: None,
};

pub static WORD_WOO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("dowrking"),
        dictgen::InsensitiveStr::Ascii("dworkign"),
    ],
    values: &[&["woodworking"], &["woodworking"]],
    range: 8..=8,
};

static WORD_WON_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_WON_CHILDREN),
    value: None,
};

pub static WORD_WON_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ce"),
        dictgen::InsensitiveStr::Ascii("deres"),
        dictgen::InsensitiveStr::Ascii("derfull"),
        dictgen::InsensitiveStr::Ascii("derfullly"),
        dictgen::InsensitiveStr::Ascii("derfuly"),
        dictgen::InsensitiveStr::Ascii("derig"),
        dictgen::InsensitiveStr::Ascii("derlad"),
        dictgen::InsensitiveStr::Ascii("derous"),
        dictgen::InsensitiveStr::Ascii("derously"),
        dictgen::InsensitiveStr::Ascii("derus"),
        dictgen::InsensitiveStr::Ascii("derwand"),
    ],
    values: &[
        &["nonce", "once", "ponce", "wince"],
        &["wonders"],
        &["wonderful"],
        &["wonderfully"],
        &["wonderfully"],
        &["wondering"],
        &["wonderland"],
        &["wondrous"],
        &["wondrously"],
        &["wonders"],
        &["wonderland"],
    ],
    range: 2..=9,
};

static WORD_WOM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_WOM_CHILDREN),
    value: None,
};

pub static WORD_WOM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ens")],
    values: &[&["women"]],
    range: 3..=3,
};

static WORD_WOL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_WOL_CHILDREN),
    value: None,
};

pub static WORD_WOL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("low"),
        dictgen::InsensitiveStr::Ascii("lowing"),
        dictgen::InsensitiveStr::Ascii("rd"),
        dictgen::InsensitiveStr::Ascii("rdly"),
        dictgen::InsensitiveStr::Ascii("rdview"),
        dictgen::InsensitiveStr::Ascii("rdwide"),
        dictgen::InsensitiveStr::Ascii("wide"),
    ],
    values: &[
        &["follow", "wallow"],
        &["following", "wallowing"],
        &["world"],
        &["worldly"],
        &["worldview"],
        &["worldwide"],
        &["worldwide"],
    ],
    range: 2..=6,
};

static WORD_WOK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_WOK_CHILDREN),
    value: None,
};

pub static WORD_WOK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("r"),
        dictgen::InsensitiveStr::Ascii("ring"),
    ],
    values: &[&["work"], &["working"]],
    range: 1..=4,
};

static WORD_WOI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_WOI_CHILDREN),
    value: None,
};

pub static WORD_WOI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ll"),
        dictgen::InsensitiveStr::Ascii("thout"),
    ],
    values: &[&["will"], &["without"]],
    range: 2..=5,
};

static WORD_WOH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_WOH_CHILDREN),
    value: Some(&["who"]),
};

pub static WORD_WOH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("le")],
    values: &[&["whole"]],
    range: 2..=2,
};

static WORD_WOA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_WOA_CHILDREN),
    value: None,
};

pub static WORD_WOA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("rkaround")],
    values: &[&["workaround"]],
    range: 8..=8,
};

static WORD_WN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_WN_CHILDREN),
    value: None,
};

pub static WORD_WN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("at"),
        dictgen::InsensitiveStr::Ascii("ated"),
        dictgen::InsensitiveStr::Ascii("ating"),
        dictgen::InsensitiveStr::Ascii("ats"),
        dictgen::InsensitiveStr::Ascii("en"),
        dictgen::InsensitiveStr::Ascii("idow"),
        dictgen::InsensitiveStr::Ascii("idows"),
    ],
    values: &[
        &["want", "what"],
        &["wanted"],
        &["wanting"],
        &["wants"],
        &["when", "wen"],
        &["window", "widow"],
        &["windows", "widows"],
    ],
    range: 2..=5,
};

static WORD_WM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_WM_CHILDREN),
    value: None,
};

pub static WORD_WM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("pty")],
    values: &[&["empty"]],
    range: 3..=3,
};

static WORD_WL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_WL_CHILDREN),
    value: None,
};

pub static WORD_WL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("acott"),
        dictgen::InsensitiveStr::Ascii("l"),
        dictgen::InsensitiveStr::Ascii("ll"),
    ],
    values: &[&["walcott"], &["will"], &["will"]],
    range: 1..=5,
};

static WORD_WJ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_WJ_CHILDREN),
    value: None,
};

pub static WORD_WJ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("at")],
    values: &[&["what"]],
    range: 2..=2,
};

static WORD_WI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_WI_CHILDREN),
    value: None,
};

static WORD_WI_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_WIA_NODE),
    None,
    Some(&WORD_WIC_NODE),
    Some(&WORD_WID_NODE),
    Some(&WORD_WIE_NODE),
    None,
    Some(&WORD_WIG_NODE),
    Some(&WORD_WIH_NODE),
    Some(&WORD_WII_NODE),
    None,
    Some(&WORD_WIK_NODE),
    Some(&WORD_WIL_NODE),
    Some(&WORD_WIM_NODE),
    Some(&WORD_WIN_NODE),
    None,
    Some(&WORD_WIP_NODE),
    None,
    Some(&WORD_WIR_NODE),
    Some(&WORD_WIS_NODE),
    Some(&WORD_WIT_NODE),
    Some(&WORD_WIU_NODE),
    None,
    None,
    None,
    Some(&WORD_WIY_NODE),
    Some(&WORD_WIZ_NODE),
];

static WORD_WIZ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_WIZ_CHILDREN),
    value: None,
};

pub static WORD_WIZ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("zard")],
    values: &[&["wizard"]],
    range: 4..=4,
};

static WORD_WIY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_WIY_CHILDREN),
    value: None,
};

pub static WORD_WIY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("h"),
        dictgen::InsensitiveStr::Ascii("hout"),
        dictgen::InsensitiveStr::Ascii("th"),
    ],
    values: &[&["with"], &["without"], &["with"]],
    range: 1..=4,
};

static WORD_WIU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_WIU_CHILDREN),
    value: None,
};

pub static WORD_WIU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ll")],
    values: &[&["will"]],
    range: 2..=2,
};

static WORD_WIT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_WIT_CHILDREN),
    value: None,
};

static WORD_WIT_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_WITA_NODE),
    None,
    None,
    Some(&WORD_WITD_NODE),
    Some(&WORD_WITE_NODE),
    None,
    None,
    Some(&WORD_WITH_NODE),
    Some(&WORD_WITI_NODE),
    None,
    Some(&WORD_WITK_NODE),
    None,
    None,
    Some(&WORD_WITN_NODE),
    Some(&WORD_WITO_NODE),
    None,
    None,
    Some(&WORD_WITR_NODE),
    None,
    Some(&WORD_WITT_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_WITT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_WITT_CHILDREN),
    value: None,
};

pub static WORD_WITT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("h")],
    values: &[&["with"]],
    range: 1..=1,
};

static WORD_WITR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_WITR_CHILDREN),
    value: None,
};

pub static WORD_WITR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("h")],
    values: &[&["with"]],
    range: 1..=1,
};

static WORD_WITO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_WITO_CHILDREN),
    value: None,
};

pub static WORD_WITO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ut")],
    values: &[&["without"]],
    range: 2..=2,
};

static WORD_WITN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_WITN_CHILDREN),
    value: Some(&["with"]),
};

pub static WORD_WITN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("esess"),
        dictgen::InsensitiveStr::Ascii("esss"),
        dictgen::InsensitiveStr::Ascii("esssing"),
        dictgen::InsensitiveStr::Ascii("issing"),
    ],
    values: &[
        &["witnesses"],
        &["witnesses"],
        &["witnessing"],
        &["witnessing"],
    ],
    range: 4..=7,
};

static WORD_WITK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_WITK_CHILDREN),
    value: Some(&["with"]),
};

pub static WORD_WITK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[],
    values: &[],
    range: 0..=0,
};

static WORD_WITI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_WITI_CHILDREN),
    value: None,
};

pub static WORD_WITI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("n")],
    values: &[&["within"]],
    range: 1..=1,
};

static WORD_WITH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_WITH_CHILDREN),
    value: None,
};

pub static WORD_WITH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("a"),
        dictgen::InsensitiveStr::Ascii("ces"),
        dictgen::InsensitiveStr::Ascii("dral"),
        dictgen::InsensitiveStr::Ascii("drawalls"),
        dictgen::InsensitiveStr::Ascii("drawan"),
        dictgen::InsensitiveStr::Ascii("drawel"),
        dictgen::InsensitiveStr::Ascii("drawels"),
        dictgen::InsensitiveStr::Ascii("drawin"),
        dictgen::InsensitiveStr::Ascii("drawl"),
        dictgen::InsensitiveStr::Ascii("drawles"),
        dictgen::InsensitiveStr::Ascii("drawling"),
        dictgen::InsensitiveStr::Ascii("drawning"),
        dictgen::InsensitiveStr::Ascii("eld"),
        dictgen::InsensitiveStr::Ascii("elist"),
        dictgen::InsensitiveStr::Ascii("h"),
        dictgen::InsensitiveStr::Ascii("helding"),
        dictgen::InsensitiveStr::Ascii("holdng"),
        dictgen::InsensitiveStr::Ascii("ih"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("inn"),
        dictgen::InsensitiveStr::Ascii("ion"),
        dictgen::InsensitiveStr::Ascii("o"),
        dictgen::InsensitiveStr::Ascii("oit"),
        dictgen::InsensitiveStr::Ascii("old"),
        dictgen::InsensitiveStr::Ascii("olding"),
        dictgen::InsensitiveStr::Ascii("on"),
        dictgen::InsensitiveStr::Ascii("oout"),
        dictgen::InsensitiveStr::Ascii("ot"),
        dictgen::InsensitiveStr::Ascii("otu"),
        dictgen::InsensitiveStr::Ascii("ou"),
        dictgen::InsensitiveStr::Ascii("oud"),
        dictgen::InsensitiveStr::Ascii("oug"),
        dictgen::InsensitiveStr::Ascii("ough"),
        dictgen::InsensitiveStr::Ascii("ought"),
        dictgen::InsensitiveStr::Ascii("ouht"),
        dictgen::InsensitiveStr::Ascii("ount"),
        dictgen::InsensitiveStr::Ascii("our"),
        dictgen::InsensitiveStr::Ascii("ourt"),
        dictgen::InsensitiveStr::Ascii("ous"),
        dictgen::InsensitiveStr::Ascii("outh"),
        dictgen::InsensitiveStr::Ascii("ouyt"),
        dictgen::InsensitiveStr::Ascii("put"),
        dictgen::InsensitiveStr::Ascii("rawal"),
        dictgen::InsensitiveStr::Ascii("rdawal"),
        dictgen::InsensitiveStr::Ascii("rdawing"),
        dictgen::InsensitiveStr::Ascii("s"),
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("tin"),
        dictgen::InsensitiveStr::Ascii("un"),
        dictgen::InsensitiveStr::Ascii("uout"),
    ],
    values: &[
        &["with"],
        &["witches"],
        &["withdrawal"],
        &["withdrawals"],
        &["withdrawn"],
        &["withdrawal"],
        &["withdrawals"],
        &["withdrawn"],
        &["withdrawal", "withdraw"],
        &["withdrawals"],
        &["withdrawing"],
        &["withdrawing"],
        &["withheld"],
        &["whitelist"],
        &["with"],
        &["withholding"],
        &["withholding"],
        &["within"],
        &["within"],
        &["within"],
        &["within"],
        &["with"],
        &["without"],
        &["withhold"],
        &["withholding"],
        &["within"],
        &["without"],
        &["without"],
        &["without"],
        &["without"],
        &["without"],
        &["without"],
        &["without"],
        &["without"],
        &["without"],
        &["without"],
        &["without"],
        &["without"],
        &["without"],
        &["without"],
        &["without"],
        &["without"],
        &["withdrawal"],
        &["withdrawals"],
        &["withdrawing"],
        &["with", "widths"],
        &["with"],
        &["within"],
        &["within"],
        &["without"],
    ],
    range: 1..=8,
};

static WORD_WITE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_WITE_CHILDREN),
    value: Some(&["write", "white"]),
};

pub static WORD_WITE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[],
    values: &[],
    range: 0..=0,
};

static WORD_WITD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_WITD_CHILDREN),
    value: None,
};

pub static WORD_WITD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("h"),
        dictgen::InsensitiveStr::Ascii("hs"),
        dictgen::InsensitiveStr::Ascii("th"),
        dictgen::InsensitiveStr::Ascii("ths"),
    ],
    values: &[&["width"], &["widths"], &["width"], &["widths"]],
    range: 1..=3,
};

static WORD_WITA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_WITA_CHILDREN),
    value: None,
};

pub static WORD_WITA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ble")],
    values: &[&["writeable"]],
    range: 3..=3,
};

static WORD_WIS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_WIS_CHILDREN),
    value: None,
};

pub static WORD_WIS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cle"),
        dictgen::InsensitiveStr::Ascii("cled"),
        dictgen::InsensitiveStr::Ascii("cles"),
        dictgen::InsensitiveStr::Ascii("cling"),
        dictgen::InsensitiveStr::Ascii("conisn"),
        dictgen::InsensitiveStr::Ascii("consion"),
        dictgen::InsensitiveStr::Ascii("hlisht"),
        dictgen::InsensitiveStr::Ascii("hlsit"),
        dictgen::InsensitiveStr::Ascii("hpered"),
        dictgen::InsensitiveStr::Ascii("hpering"),
        dictgen::InsensitiveStr::Ascii("hpers"),
        dictgen::InsensitiveStr::Ascii("nton"),
        dictgen::InsensitiveStr::Ascii("per"),
        dictgen::InsensitiveStr::Ascii("pered"),
        dictgen::InsensitiveStr::Ascii("pering"),
        dictgen::InsensitiveStr::Ascii("pers"),
        dictgen::InsensitiveStr::Ascii("sle"),
        dictgen::InsensitiveStr::Ascii("sled"),
        dictgen::InsensitiveStr::Ascii("sles"),
        dictgen::InsensitiveStr::Ascii("sling"),
    ],
    values: &[
        &["whistle"],
        &["whistled"],
        &["whistles"],
        &["whistling"],
        &["wisconsin"],
        &["wisconsin"],
        &["wishlist"],
        &["wishlist"],
        &["whispered"],
        &["whispering"],
        &["whispers"],
        &["winston"],
        &["whisper"],
        &["whispered"],
        &["whispering"],
        &["whispers"],
        &["whistle"],
        &["whistled"],
        &["whistles"],
        &["whistling"],
    ],
    range: 3..=7,
};

static WORD_WIR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_WIR_CHILDREN),
    value: None,
};

pub static WORD_WIR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ded"),
        dictgen::InsensitiveStr::Ascii("edest"),
        dictgen::InsensitiveStr::Ascii("eframw"),
        dictgen::InsensitiveStr::Ascii("eframws"),
        dictgen::InsensitiveStr::Ascii("h"),
        dictgen::InsensitiveStr::Ascii("table"),
        dictgen::InsensitiveStr::Ascii("te"),
        dictgen::InsensitiveStr::Ascii("ter"),
        dictgen::InsensitiveStr::Ascii("ters"),
        dictgen::InsensitiveStr::Ascii("tes"),
        dictgen::InsensitiveStr::Ascii("th"),
        dictgen::InsensitiveStr::Ascii("ting"),
        dictgen::InsensitiveStr::Ascii("tten"),
        dictgen::InsensitiveStr::Ascii("tual"),
    ],
    values: &[
        &["wired", "weird"],
        &["weirdest"],
        &["wireframe"],
        &["wireframes"],
        &["with"],
        &["writable", "writeable"],
        &["write"],
        &["writer"],
        &["writers"],
        &["writes"],
        &["with", "worth"],
        &["writing"],
        &["written"],
        &["virtual"],
    ],
    range: 1..=7,
};

static WORD_WIP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_WIP_CHILDREN),
    value: None,
};

pub static WORD_WIP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("oing")],
    values: &[&["wiping"]],
    range: 4..=4,
};

static WORD_WIN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_WIN_CHILDREN),
    value: None,
};

pub static WORD_WIN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cheseter"),
        dictgen::InsensitiveStr::Ascii("chestor"),
        dictgen::InsensitiveStr::Ascii("dhsield"),
        dictgen::InsensitiveStr::Ascii("do"),
        dictgen::InsensitiveStr::Ascii("does"),
        dictgen::InsensitiveStr::Ascii("doow"),
        dictgen::InsensitiveStr::Ascii("doows"),
        dictgen::InsensitiveStr::Ascii("dos"),
        dictgen::InsensitiveStr::Ascii("dosr"),
        dictgen::InsensitiveStr::Ascii("dowz"),
        dictgen::InsensitiveStr::Ascii("dsheild"),
        dictgen::InsensitiveStr::Ascii("dsheilds"),
        dictgen::InsensitiveStr::Ascii("dshied"),
        dictgen::InsensitiveStr::Ascii("dshiled"),
        dictgen::InsensitiveStr::Ascii("dsoar"),
        dictgen::InsensitiveStr::Ascii("dwo"),
        dictgen::InsensitiveStr::Ascii("dwos"),
        dictgen::InsensitiveStr::Ascii("inpeg"),
        dictgen::InsensitiveStr::Ascii("n"),
        dictgen::InsensitiveStr::Ascii("ndow"),
        dictgen::InsensitiveStr::Ascii("ndows"),
        dictgen::InsensitiveStr::Ascii("nigns"),
        dictgen::InsensitiveStr::Ascii("nins"),
        dictgen::InsensitiveStr::Ascii("npieg"),
        dictgen::InsensitiveStr::Ascii("odw"),
        dictgen::InsensitiveStr::Ascii("sdor"),
        dictgen::InsensitiveStr::Ascii("tesses"),
        dictgen::InsensitiveStr::Ascii("tson"),
    ],
    values: &[
        &["winchester"],
        &["winchester"],
        &["windshield"],
        &["window"],
        &["windows"],
        &["window"],
        &["windows"],
        &["windows"],
        &["windsor"],
        &["windows"],
        &["windshield"],
        &["windshield"],
        &["windshield"],
        &["windshield"],
        &["windsor"],
        &["window"],
        &["windows"],
        &["winnipeg"],
        &["win"],
        &["window"],
        &["windows"],
        &["winnings"],
        &["winnings"],
        &["winnipeg"],
        &["window"],
        &["windsor"],
        &["witnesses"],
        &["winston"],
    ],
    range: 1..=8,
};

static WORD_WIM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_WIM_CHILDREN),
    value: None,
};

pub static WORD_WIM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("men"),
        dictgen::InsensitiveStr::Ascii("menly"),
        dictgen::InsensitiveStr::Ascii("mens"),
    ],
    values: &[&["women"], &["womanly"], &["women"]],
    range: 3..=5,
};

static WORD_WIL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_WIL_CHILDREN),
    value: Some(&["will", "well"]),
};

pub static WORD_WIL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("card"),
        dictgen::InsensitiveStr::Ascii("cards"),
        dictgen::InsensitiveStr::Ascii("debeast"),
        dictgen::InsensitiveStr::Ascii("debeasts"),
        dictgen::InsensitiveStr::Ascii("derniss"),
        dictgen::InsensitiveStr::Ascii("dreness"),
        dictgen::InsensitiveStr::Ascii("h"),
        dictgen::InsensitiveStr::Ascii("laims"),
        dictgen::InsensitiveStr::Ascii("le"),
        dictgen::InsensitiveStr::Ascii("lfullly"),
        dictgen::InsensitiveStr::Ascii("lfuly"),
        dictgen::InsensitiveStr::Ascii("limas"),
        dictgen::InsensitiveStr::Ascii("lingless"),
        dictgen::InsensitiveStr::Ascii("lk"),
        dictgen::InsensitiveStr::Ascii("ll"),
    ],
    values: &[
        &["wildcard"],
        &["wildcards"],
        &["wildebeest"],
        &["wildebeests"],
        &["wilderness"],
        &["wilderness"],
        &["will"],
        &["williams"],
        &["will"],
        &["willfully"],
        &["willfully"],
        &["williams"],
        &["willingness"],
        &["will"],
        &["will"],
    ],
    range: 1..=8,
};

static WORD_WIK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_WIK_CHILDREN),
    value: None,
};

pub static WORD_WIK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ileakers"),
        dictgen::InsensitiveStr::Ascii("ileakes"),
        dictgen::InsensitiveStr::Ascii("pedia"),
    ],
    values: &[&["wikileaks"], &["wikileaks"], &["wikipedia"]],
    range: 5..=8,
};

static WORD_WII_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_WII_CHILDREN),
    value: None,
};

pub static WORD_WII_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("l")],
    values: &[&["will"]],
    range: 1..=1,
};

static WORD_WIH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_WIH_CHILDREN),
    value: Some(&["with"]),
};

pub static WORD_WIH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ch"),
        dictgen::InsensitiveStr::Ascii("ich"),
        dictgen::InsensitiveStr::Ascii("ite"),
        dictgen::InsensitiveStr::Ascii("le"),
        dictgen::InsensitiveStr::Ascii("out"),
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("tin"),
        dictgen::InsensitiveStr::Ascii("tout"),
    ],
    values: &[
        &["which"],
        &["which"],
        &["white"],
        &["while"],
        &["without"],
        &["with"],
        &["within"],
        &["without"],
    ],
    range: 1..=4,
};

static WORD_WIG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_WIG_CHILDREN),
    value: None,
};

pub static WORD_WIG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("det"),
        dictgen::InsensitiveStr::Ascii("dets"),
        dictgen::InsensitiveStr::Ascii("hed"),
        dictgen::InsensitiveStr::Ascii("hted"),
    ],
    values: &[
        &["widget"],
        &["widgets"],
        &["weighed", "wicked"],
        &["weighted", "weighed"],
    ],
    range: 3..=4,
};

static WORD_WIE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_WIE_CHILDREN),
    value: None,
};

pub static WORD_WIE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("f"),
        dictgen::InsensitiveStr::Ascii("ghed"),
        dictgen::InsensitiveStr::Ascii("ght"),
        dictgen::InsensitiveStr::Ascii("ghted"),
        dictgen::InsensitiveStr::Ascii("ghtlifting"),
        dictgen::InsensitiveStr::Ascii("ghts"),
        dictgen::InsensitiveStr::Ascii("h"),
        dictgen::InsensitiveStr::Ascii("rd"),
        dictgen::InsensitiveStr::Ascii("rdly"),
        dictgen::InsensitiveStr::Ascii("rdness"),
        dictgen::InsensitiveStr::Ascii("th"),
        dictgen::InsensitiveStr::Ascii("w"),
    ],
    values: &[
        &["wife"],
        &["weighed"],
        &["weight"],
        &["weighted", "weighed"],
        &["weightlifting"],
        &["weights"],
        &["view"],
        &["weird"],
        &["weirdly"],
        &["weirdness"],
        &["width"],
        &["view"],
    ],
    range: 1..=10,
};

static WORD_WID_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_WID_CHILDREN),
    value: None,
};

pub static WORD_WID_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("der"),
        dictgen::InsensitiveStr::Ascii("epsread"),
        dictgen::InsensitiveStr::Ascii("espred"),
        dictgen::InsensitiveStr::Ascii("esread"),
        dictgen::InsensitiveStr::Ascii("gect"),
        dictgen::InsensitiveStr::Ascii("ged"),
        dictgen::InsensitiveStr::Ascii("gest"),
        dictgen::InsensitiveStr::Ascii("getas"),
        dictgen::InsensitiveStr::Ascii("ghet"),
        dictgen::InsensitiveStr::Ascii("ghets"),
        dictgen::InsensitiveStr::Ascii("git"),
        dictgen::InsensitiveStr::Ascii("gtes"),
        dictgen::InsensitiveStr::Ascii("ht"),
        dictgen::InsensitiveStr::Ascii("htpoint"),
        dictgen::InsensitiveStr::Ascii("htpoints"),
        dictgen::InsensitiveStr::Ascii("now"),
        dictgen::InsensitiveStr::Ascii("nows"),
        dictgen::InsensitiveStr::Ascii("thn"),
        dictgen::InsensitiveStr::Ascii("thout"),
    ],
    values: &[
        &["wider"],
        &["widespread"],
        &["widespread"],
        &["widespread"],
        &["widget"],
        &["widget"],
        &["widgets"],
        &["widgets"],
        &["widget"],
        &["widgets"],
        &["widget"],
        &["widgets"],
        &["width"],
        &["widthpoint"],
        &["widthpoints"],
        &["widow", "window"],
        &["windows", "widows"],
        &["width"],
        &["without"],
    ],
    range: 2..=8,
};

static WORD_WIC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_WIC_CHILDREN),
    value: None,
};

pub static WORD_WIC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("h"),
    ],
    values: &[&["vice"], &["which"]],
    range: 1..=1,
};

static WORD_WIA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_WIA_CHILDREN),
    value: None,
};

pub static WORD_WIA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("ters"),
        dictgen::InsensitiveStr::Ascii("vers"),
    ],
    values: &[&["wait"], &["waiters"], &["waivers"]],
    range: 1..=4,
};

static WORD_WH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_WH_CHILDREN),
    value: None,
};

static WORD_WH_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_WHA_NODE),
    None,
    Some(&WORD_WHC_NODE),
    None,
    Some(&WORD_WHE_NODE),
    None,
    None,
    Some(&WORD_WHH_NODE),
    Some(&WORD_WHI_NODE),
    None,
    None,
    Some(&WORD_WHL_NODE),
    None,
    Some(&WORD_WHN_NODE),
    Some(&WORD_WHO_NODE),
    None,
    None,
    Some(&WORD_WHR_NODE),
    Some(&WORD_WHS_NODE),
    Some(&WORD_WHT_NODE),
    Some(&WORD_WHU_NODE),
    None,
    None,
    None,
    Some(&WORD_WHY_NODE),
    None,
];

static WORD_WHY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_WHY_CHILDREN),
    value: None,
};

pub static WORD_WHY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("th"),
        dictgen::InsensitiveStr::Ascii("thout"),
    ],
    values: &[&["what", "why"], &["with"], &["without"]],
    range: 1..=5,
};

static WORD_WHU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_WHU_CHILDREN),
    value: None,
};

pub static WORD_WHU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("le")],
    values: &[&["while", "whole"]],
    range: 2..=2,
};

static WORD_WHT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_WHT_CHILDREN),
    value: None,
};

pub static WORD_WHT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("a"),
        dictgen::InsensitiveStr::Ascii("her"),
        dictgen::InsensitiveStr::Ascii("ielist"),
        dictgen::InsensitiveStr::Ascii("ihin"),
    ],
    values: &[&["what"], &["whether"], &["whitelist"], &["within"]],
    range: 1..=6,
};

static WORD_WHS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_WHS_CHILDREN),
    value: None,
};

pub static WORD_WHS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("iper"),
        dictgen::InsensitiveStr::Ascii("ipered"),
        dictgen::InsensitiveStr::Ascii("ipering"),
        dictgen::InsensitiveStr::Ascii("ipers"),
    ],
    values: &[&["whisper"], &["whispered"], &["whispering"], &["whispers"]],
    range: 4..=7,
};

static WORD_WHR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_WHR_CHILDREN),
    value: None,
};

pub static WORD_WHR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("ilwind"),
    ],
    values: &[&["where"], &["whirlwind"]],
    range: 1..=6,
};

static WORD_WHO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_WHO_CHILDREN),
    value: None,
};

pub static WORD_WHO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("leheartadly"),
        dictgen::InsensitiveStr::Ascii("leheartdly"),
        dictgen::InsensitiveStr::Ascii("leheartedy"),
        dictgen::InsensitiveStr::Ascii("leheartely"),
        dictgen::InsensitiveStr::Ascii("leheartidly"),
        dictgen::InsensitiveStr::Ascii("lely"),
        dictgen::InsensitiveStr::Ascii("ley"),
        dictgen::InsensitiveStr::Ascii("ly"),
        dictgen::InsensitiveStr::Ascii("ms"),
        dictgen::InsensitiveStr::Ascii("ose"),
        dictgen::InsensitiveStr::Ascii("s"),
        dictgen::InsensitiveStr::Ascii("uld"),
    ],
    values: &[
        &["whose"],
        &["wholeheartedly"],
        &["wholeheartedly"],
        &["wholeheartedly"],
        &["wholeheartedly"],
        &["wholeheartedly"],
        &["wholly"],
        &["wholly"],
        &["wholly", "holy"],
        &["whom", "whose"],
        &["whose"],
        &["whose"],
        &["would"],
    ],
    range: 1..=11,
};

static WORD_WHN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_WHN_CHILDREN),
    value: Some(&["when"]),
};

pub static WORD_WHN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("e")],
    values: &[&["when"]],
    range: 1..=1,
};

static WORD_WHL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_WHL_CHILDREN),
    value: None,
};

pub static WORD_WHL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ch"),
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("ie"),
    ],
    values: &[&["which"], &["while"], &["while"]],
    range: 1..=2,
};

static WORD_WHI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_WHI_CHILDREN),
    value: None,
};

pub static WORD_WHI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("c"),
        dictgen::InsensitiveStr::Ascii("cg"),
        dictgen::InsensitiveStr::Ascii("cht"),
        dictgen::InsensitiveStr::Ascii("etlist"),
        dictgen::InsensitiveStr::Ascii("h"),
        dictgen::InsensitiveStr::Ascii("hc"),
        dictgen::InsensitiveStr::Ascii("hch"),
        dictgen::InsensitiveStr::Ascii("ke"),
        dictgen::InsensitiveStr::Ascii("lest"),
        dictgen::InsensitiveStr::Ascii("ll"),
        dictgen::InsensitiveStr::Ascii("lrwind"),
        dictgen::InsensitiveStr::Ascii("lsting"),
        dictgen::InsensitiveStr::Ascii("ltelist"),
        dictgen::InsensitiveStr::Ascii("ltelisted"),
        dictgen::InsensitiveStr::Ascii("ltelisting"),
        dictgen::InsensitiveStr::Ascii("ltelists"),
        dictgen::InsensitiveStr::Ascii("lw"),
        dictgen::InsensitiveStr::Ascii("och"),
        dictgen::InsensitiveStr::Ascii("ped"),
        dictgen::InsensitiveStr::Ascii("pser"),
        dictgen::InsensitiveStr::Ascii("psered"),
        dictgen::InsensitiveStr::Ascii("psering"),
        dictgen::InsensitiveStr::Ascii("psers"),
        dictgen::InsensitiveStr::Ascii("s"),
        dictgen::InsensitiveStr::Ascii("sh"),
        dictgen::InsensitiveStr::Ascii("shlist"),
        dictgen::InsensitiveStr::Ascii("slist"),
        dictgen::InsensitiveStr::Ascii("slte"),
        dictgen::InsensitiveStr::Ascii("sltes"),
        dictgen::InsensitiveStr::Ascii("slting"),
        dictgen::InsensitiveStr::Ascii("sperd"),
        dictgen::InsensitiveStr::Ascii("sperered"),
        dictgen::InsensitiveStr::Ascii("speres"),
        dictgen::InsensitiveStr::Ascii("stel"),
        dictgen::InsensitiveStr::Ascii("stels"),
        dictgen::InsensitiveStr::Ascii("tch"),
        dictgen::InsensitiveStr::Ascii("tchever"),
        dictgen::InsensitiveStr::Ascii("telsit"),
        dictgen::InsensitiveStr::Ascii("tepsace"),
        dictgen::InsensitiveStr::Ascii("tepsaces"),
        dictgen::InsensitiveStr::Ascii("th"),
        dictgen::InsensitiveStr::Ascii("the"),
        dictgen::InsensitiveStr::Ascii("thin"),
        dictgen::InsensitiveStr::Ascii("tholding"),
        dictgen::InsensitiveStr::Ascii("thout"),
        dictgen::InsensitiveStr::Ascii("tleist"),
        dictgen::InsensitiveStr::Ascii("tout"),
        dictgen::InsensitiveStr::Ascii("tre"),
        dictgen::InsensitiveStr::Ascii("tsle"),
        dictgen::InsensitiveStr::Ascii("tsles"),
        dictgen::InsensitiveStr::Ascii("tsling"),
        dictgen::InsensitiveStr::Ascii("tspace"),
        dictgen::InsensitiveStr::Ascii("tspaces"),
    ],
    values: &[
        &["which"],
        &["which"],
        &["which"],
        &["whitelist"],
        &["which"],
        &["which"],
        &["which"],
        &["while"],
        &["whilst"],
        &["while", "will"],
        &["whirlwind"],
        &["whistling"],
        &["whitelist"],
        &["whitelisted"],
        &["whitelisting"],
        &["whitelists"],
        &["while"],
        &["which"],
        &["whipped", "wiped"],
        &["whisper"],
        &["whispered"],
        &["whispering"],
        &["whispers"],
        &["this", "whisk"],
        &["wish", "whisk"],
        &["wishlist"],
        &["wishlist"],
        &["whistle"],
        &["whistles"],
        &["whistling"],
        &["whispered"],
        &["whispered"],
        &["whispers"],
        &["whistle"],
        &["whistles"],
        &["which"],
        &["whichever"],
        &["whitelist"],
        &["whitespace"],
        &["whitespaces"],
        &["with", "which"],
        &["with", "white"],
        &["within"],
        &["withholding"],
        &["without"],
        &["whitelist"],
        &["without", "whiteout"],
        &["white"],
        &["whistle"],
        &["whistles"],
        &["whistling"],
        &["whitespace"],
        &["whitespace"],
    ],
    range: 1..=10,
};

static WORD_WHH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_WHH_CHILDREN),
    value: None,
};

pub static WORD_WHH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eel"),
        dictgen::InsensitiveStr::Ascii("en"),
    ],
    values: &[&["wheel"], &["when"]],
    range: 2..=3,
};

static WORD_WHE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_WHE_CHILDREN),
    value: Some(&["when", "we"]),
};

pub static WORD_WHE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ather"),
        dictgen::InsensitiveStr::Ascii("h"),
        dictgen::InsensitiveStr::Ascii("hter"),
        dictgen::InsensitiveStr::Ascii("igh"),
        dictgen::InsensitiveStr::Ascii("ll"),
        dictgen::InsensitiveStr::Ascii("m"),
        dictgen::InsensitiveStr::Ascii("nevery"),
        dictgen::InsensitiveStr::Ascii("nn"),
        dictgen::InsensitiveStr::Ascii("nver"),
        dictgen::InsensitiveStr::Ascii("r"),
        dictgen::InsensitiveStr::Ascii("ras"),
        dictgen::InsensitiveStr::Ascii("rease"),
        dictgen::InsensitiveStr::Ascii("reever"),
        dictgen::InsensitiveStr::Ascii("rether"),
        dictgen::InsensitiveStr::Ascii("ry"),
        dictgen::InsensitiveStr::Ascii("teher"),
        dictgen::InsensitiveStr::Ascii("tehr"),
        dictgen::InsensitiveStr::Ascii("ter"),
        dictgen::InsensitiveStr::Ascii("the"),
        dictgen::InsensitiveStr::Ascii("thter"),
        dictgen::InsensitiveStr::Ascii("ver"),
    ],
    values: &[
        &["weather", "whether"],
        &["when"],
        &["whether"],
        &["weigh"],
        &["wheel", "well"],
        &["when"],
        &["whenever"],
        &["when"],
        &["whenever"],
        &["where", "were"],
        &["whereas"],
        &["whereas"],
        &["wherever"],
        &["whether"],
        &["where"],
        &["whether"],
        &["whether"],
        &["whether"],
        &["whether"],
        &["whether"],
        &["wherever"],
    ],
    range: 1..=6,
};

static WORD_WHC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_WHC_CHILDREN),
    value: None,
};

pub static WORD_WHC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("h"),
        dictgen::InsensitiveStr::Ascii("ich"),
        dictgen::InsensitiveStr::Ascii("ih"),
    ],
    values: &[&["which"], &["which"], &["which"]],
    range: 1..=3,
};

static WORD_WHA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_WHA_CHILDREN),
    value: None,
};

pub static WORD_WHA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("at"),
        dictgen::InsensitiveStr::Ascii("eton"),
        dictgen::InsensitiveStr::Ascii("n"),
        dictgen::InsensitiveStr::Ascii("nt"),
        dictgen::InsensitiveStr::Ascii("nts"),
        dictgen::InsensitiveStr::Ascii("taver"),
        dictgen::InsensitiveStr::Ascii("tepsace"),
        dictgen::InsensitiveStr::Ascii("tepsaces"),
        dictgen::InsensitiveStr::Ascii("ther"),
        dictgen::InsensitiveStr::Ascii("thever"),
        dictgen::InsensitiveStr::Ascii("tosever"),
        dictgen::InsensitiveStr::Ascii("tseover"),
    ],
    values: &[
        &["what"],
        &["wheaton"],
        &["want", "when"],
        &["want"],
        &["wants"],
        &["whatever"],
        &["whitespace"],
        &["whitespaces"],
        &["whether", "weather"],
        &["whatever"],
        &["whatsoever"],
        &["whatsoever"],
    ],
    range: 1..=8,
};

static WORD_WE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_WE_CHILDREN),
    value: None,
};

static WORD_WE_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_WEA_NODE),
    Some(&WORD_WEB_NODE),
    None,
    Some(&WORD_WED_NODE),
    Some(&WORD_WEE_NODE),
    None,
    Some(&WORD_WEG_NODE),
    Some(&WORD_WEH_NODE),
    Some(&WORD_WEI_NODE),
    None,
    None,
    Some(&WORD_WEL_NODE),
    None,
    Some(&WORD_WEN_NODE),
    None,
    Some(&WORD_WEP_NODE),
    None,
    Some(&WORD_WER_NODE),
    Some(&WORD_WES_NODE),
    Some(&WORD_WET_NODE),
    None,
    None,
    Some(&WORD_WEW_NODE),
    None,
    None,
    Some(&WORD_WEZ_NODE),
];

static WORD_WEZ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_WEZ_CHILDREN),
    value: None,
};

pub static WORD_WEZ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("zal"),
        dictgen::InsensitiveStr::Ascii("zals"),
    ],
    values: &[&["weasel"], &["weasels"]],
    range: 3..=4,
};

static WORD_WEW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_WEW_CHILDREN),
    value: Some(&["we"]),
};

pub static WORD_WEW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[],
    values: &[],
    range: 0..=0,
};

static WORD_WET_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_WET_CHILDREN),
    value: None,
};

pub static WORD_WET_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("her")],
    values: &[&["weather", "whether"]],
    range: 3..=3,
};

static WORD_WES_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_WES_CHILDREN),
    value: None,
};

pub static WORD_WES_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("bite"),
        dictgen::InsensitiveStr::Ascii("bites"),
        dictgen::InsensitiveStr::Ascii("btrook"),
        dictgen::InsensitiveStr::Ascii("ite"),
        dictgen::InsensitiveStr::Ascii("tbrok"),
        dictgen::InsensitiveStr::Ascii("tbroook"),
        dictgen::InsensitiveStr::Ascii("ternerns"),
        dictgen::InsensitiveStr::Ascii("ternes"),
        dictgen::InsensitiveStr::Ascii("ternese"),
        dictgen::InsensitiveStr::Ascii("terness"),
        dictgen::InsensitiveStr::Ascii("terse"),
        dictgen::InsensitiveStr::Ascii("tminser"),
        dictgen::InsensitiveStr::Ascii("tminter"),
        dictgen::InsensitiveStr::Ascii("tmisnter"),
        dictgen::InsensitiveStr::Ascii("tmnister"),
        dictgen::InsensitiveStr::Ascii("tmonster"),
        dictgen::InsensitiveStr::Ascii("trbook"),
    ],
    values: &[
        &["website"],
        &["websites"],
        &["westbrook"],
        &["website"],
        &["westbrook"],
        &["westbrook"],
        &["westerners"],
        &["westerners"],
        &["westerners"],
        &["westerners"],
        &["westerners"],
        &["westminster"],
        &["westminster"],
        &["westminster"],
        &["westminster"],
        &["westminster"],
        &["westbrook"],
    ],
    range: 3..=8,
};

static WORD_WER_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_WER_CHILDREN),
    value: None,
};

pub static WORD_WER_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eabouts"),
        dictgen::InsensitiveStr::Ascii("eas"),
        dictgen::InsensitiveStr::Ascii("ee"),
        dictgen::InsensitiveStr::Ascii("ever"),
        dictgen::InsensitiveStr::Ascii("idest"),
        dictgen::InsensitiveStr::Ascii("idly"),
        dictgen::InsensitiveStr::Ascii("idos"),
        dictgen::InsensitiveStr::Ascii("stle"),
        dictgen::InsensitiveStr::Ascii("stler"),
        dictgen::InsensitiveStr::Ascii("y"),
    ],
    values: &[
        &["whereabouts"],
        &["whereas"],
        &["were"],
        &["wherever"],
        &["weirdest"],
        &["weirdly"],
        &["weirdos"],
        &["wrestle"],
        &["wrestler"],
        &["very", "wary", "weary"],
    ],
    range: 1..=7,
};

static WORD_WEP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_WEP_CHILDREN),
    value: None,
};

pub static WORD_WEP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("bage"),
        dictgen::InsensitiveStr::Ascii("on"),
        dictgen::InsensitiveStr::Ascii("ons"),
        dictgen::InsensitiveStr::Ascii("pon"),
        dictgen::InsensitiveStr::Ascii("pons"),
    ],
    values: &[
        &["webpage"],
        &["weapon"],
        &["weapons"],
        &["weapon"],
        &["weapons"],
    ],
    range: 2..=4,
};

static WORD_WEN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_WEN_CHILDREN),
    value: None,
};

pub static WORD_WEN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("desday"),
        dictgen::InsensitiveStr::Ascii("desdays"),
        dictgen::InsensitiveStr::Ascii("dsay"),
        dictgen::InsensitiveStr::Ascii("dsday"),
        dictgen::InsensitiveStr::Ascii("sday"),
    ],
    values: &[
        &["wednesday"],
        &["wednesdays"],
        &["wednesday"],
        &["wednesday"],
        &["wednesday"],
    ],
    range: 4..=7,
};

static WORD_WEL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_WEL_CHILDREN),
    value: Some(&["well"]),
};

pub static WORD_WEL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("athier"),
        dictgen::InsensitiveStr::Ascii("athiest"),
        dictgen::InsensitiveStr::Ascii("athy"),
        dictgen::InsensitiveStr::Ascii("lignton"),
        dictgen::InsensitiveStr::Ascii("lingotn"),
        dictgen::InsensitiveStr::Ascii("lingston"),
        dictgen::InsensitiveStr::Ascii("lingtion"),
        dictgen::InsensitiveStr::Ascii("p"),
    ],
    values: &[
        &["wealthier"],
        &["wealthiest"],
        &["wealthy"],
        &["wellington"],
        &["wellington"],
        &["wellington"],
        &["wellington"],
        &["whelp"],
    ],
    range: 1..=8,
};

static WORD_WEI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_WEI_CHILDREN),
    value: None,
};

pub static WORD_WEI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ghtened"),
        dictgen::InsensitiveStr::Ascii("ghtlfiting"),
        dictgen::InsensitiveStr::Ascii("ghtlifing"),
        dictgen::InsensitiveStr::Ascii("ghtlifitng"),
        dictgen::InsensitiveStr::Ascii("ghtligting"),
        dictgen::InsensitiveStr::Ascii("gth"),
        dictgen::InsensitiveStr::Ascii("gthed"),
        dictgen::InsensitiveStr::Ascii("gthlifting"),
        dictgen::InsensitiveStr::Ascii("gths"),
        dictgen::InsensitiveStr::Ascii("ld"),
        dictgen::InsensitiveStr::Ascii("lded"),
        dictgen::InsensitiveStr::Ascii("ll"),
        dictgen::InsensitiveStr::Ascii("red"),
        dictgen::InsensitiveStr::Ascii("rldy"),
        dictgen::InsensitiveStr::Ascii("rods"),
        dictgen::InsensitiveStr::Ascii("tght"),
        dictgen::InsensitiveStr::Ascii("ther"),
    ],
    values: &[
        &["weighted"],
        &["weightlifting"],
        &["weightlifting"],
        &["weightlifting"],
        &["weightlifting"],
        &["weight"],
        &["weighted"],
        &["weightlifting"],
        &["weights"],
        &["wield", "wild"],
        &["wielded"],
        &["will"],
        &["weird"],
        &["weirdly"],
        &["weirdos"],
        &["weight"],
        &["whether"],
    ],
    range: 2..=10,
};

static WORD_WEH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_WEH_CHILDREN),
    value: None,
};

pub static WORD_WEH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ere"),
        dictgen::InsensitiveStr::Ascii("n"),
        dictgen::InsensitiveStr::Ascii("ther"),
    ],
    values: &[&["where"], &["when"], &["whether"]],
    range: 1..=4,
};

static WORD_WEG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_WEG_CHILDREN),
    value: None,
};

pub static WORD_WEG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("e")],
    values: &[&["wedge"]],
    range: 1..=1,
};

static WORD_WEE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_WEE_CHILDREN),
    value: None,
};

pub static WORD_WEE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("rd"),
        dictgen::InsensitiveStr::Ascii("rdly"),
        dictgen::InsensitiveStr::Ascii("v"),
        dictgen::InsensitiveStr::Ascii("ved"),
        dictgen::InsensitiveStr::Ascii("ves"),
        dictgen::InsensitiveStr::Ascii("ving"),
    ],
    values: &[
        &["weird"],
        &["weirdly"],
        &["weave"],
        &["weaved", "wove"],
        &["weaves"],
        &["weaving"],
    ],
    range: 1..=4,
};

static WORD_WED_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_WED_CHILDREN),
    value: None,
};

pub static WORD_WED_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ensday"),
        dictgen::InsensitiveStr::Ascii("ensdays"),
        dictgen::InsensitiveStr::Ascii("nesay"),
        dictgen::InsensitiveStr::Ascii("nesdaay"),
        dictgen::InsensitiveStr::Ascii("nesdey"),
        dictgen::InsensitiveStr::Ascii("nesdsay"),
        dictgen::InsensitiveStr::Ascii("nesdsy"),
        dictgen::InsensitiveStr::Ascii("nesdy"),
        dictgen::InsensitiveStr::Ascii("nessay"),
        dictgen::InsensitiveStr::Ascii("nessday"),
        dictgen::InsensitiveStr::Ascii("nsday"),
        dictgen::InsensitiveStr::Ascii("nseday"),
        dictgen::InsensitiveStr::Ascii("nsedays"),
    ],
    values: &[
        &["wednesday"],
        &["wednesdays"],
        &["wednesday"],
        &["wednesday"],
        &["wednesday"],
        &["wednesdays"],
        &["wednesdays"],
        &["wednesdays"],
        &["wednesdays"],
        &["wednesdays", "wednesday"],
        &["wednesday"],
        &["wednesday"],
        &["wednesdays"],
    ],
    range: 5..=7,
};

static WORD_WEB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_WEB_CHILDREN),
    value: None,
};

pub static WORD_WEB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("age"),
        dictgen::InsensitiveStr::Ascii("apge"),
        dictgen::InsensitiveStr::Ascii("assemby"),
        dictgen::InsensitiveStr::Ascii("books"),
        dictgen::InsensitiveStr::Ascii("hools"),
        dictgen::InsensitiveStr::Ascii("iste"),
        dictgen::InsensitiveStr::Ascii("istes"),
        dictgen::InsensitiveStr::Ascii("stie"),
        dictgen::InsensitiveStr::Ascii("sties"),
    ],
    values: &[
        &["webpage"],
        &["webpage"],
        &["webassembly"],
        &["webhooks"],
        &["webhooks"],
        &["website"],
        &["websites"],
        &["website"],
        &["websites"],
    ],
    range: 3..=7,
};

static WORD_WEA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_WEA_CHILDREN),
    value: None,
};

pub static WORD_WEA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("hter"),
        dictgen::InsensitiveStr::Ascii("hters"),
        dictgen::InsensitiveStr::Ascii("kenend"),
        dictgen::InsensitiveStr::Ascii("kensses"),
        dictgen::InsensitiveStr::Ascii("kneses"),
        dictgen::InsensitiveStr::Ascii("knesess"),
        dictgen::InsensitiveStr::Ascii("knesss"),
        dictgen::InsensitiveStr::Ascii("knessses"),
        dictgen::InsensitiveStr::Ascii("ltheir"),
        dictgen::InsensitiveStr::Ascii("lthly"),
        dictgen::InsensitiveStr::Ascii("nt"),
        dictgen::InsensitiveStr::Ascii("ponary"),
        dictgen::InsensitiveStr::Ascii("ppon"),
        dictgen::InsensitiveStr::Ascii("ppons"),
        dictgen::InsensitiveStr::Ascii("s"),
        dictgen::InsensitiveStr::Ascii("thliest"),
    ],
    values: &[
        &["weather"],
        &["weathers"],
        &["weakened"],
        &["weaknesses"],
        &["weakness"],
        &["weaknesses"],
        &["weaknesses"],
        &["weaknesses"],
        &["wealthier"],
        &["wealthy"],
        &["want", "wean"],
        &["weaponry"],
        &["weapon"],
        &["weapons"],
        &["was"],
        &["wealthiest"],
    ],
    range: 1..=8,
};

static WORD_WA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_WA_CHILDREN),
    value: None,
};

static WORD_WA_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    Some(&WORD_WAC_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_WAH_NODE),
    Some(&WORD_WAI_NODE),
    None,
    Some(&WORD_WAK_NODE),
    Some(&WORD_WAL_NODE),
    None,
    None,
    None,
    Some(&WORD_WAP_NODE),
    None,
    Some(&WORD_WAR_NODE),
    Some(&WORD_WAS_NODE),
    Some(&WORD_WAT_NODE),
    None,
    Some(&WORD_WAV_NODE),
    Some(&WORD_WAW_NODE),
    None,
    Some(&WORD_WAY_NODE),
    None,
];

static WORD_WAY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_WAY_CHILDREN),
    value: None,
};

pub static WORD_WAY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ferer"),
        dictgen::InsensitiveStr::Ascii("oint"),
        dictgen::InsensitiveStr::Ascii("oints"),
        dictgen::InsensitiveStr::Ascii("word"),
    ],
    values: &[&["wayfarer"], &["waypoint"], &["waypoints"], &["wayward"]],
    range: 4..=5,
};

static WORD_WAW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_WAW_CHILDREN),
    value: None,
};

pub static WORD_WAW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("rick"),
    ],
    values: &[&["wave"], &["waves"], &["warwick"]],
    range: 1..=4,
};

static WORD_WAV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_WAV_CHILDREN),
    value: None,
};

pub static WORD_WAV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("elegnth"),
        dictgen::InsensitiveStr::Ascii("elegnths"),
        dictgen::InsensitiveStr::Ascii("elengh"),
        dictgen::InsensitiveStr::Ascii("elenghs"),
        dictgen::InsensitiveStr::Ascii("elenght"),
        dictgen::InsensitiveStr::Ascii("elenghth"),
        dictgen::InsensitiveStr::Ascii("elenghts"),
        dictgen::InsensitiveStr::Ascii("elnes"),
        dictgen::InsensitiveStr::Ascii("esfront"),
        dictgen::InsensitiveStr::Ascii("iers"),
    ],
    values: &[
        &["wavelength"],
        &["wavelength"],
        &["wavelength"],
        &["wavelength", "wavelengths"],
        &["wavelength"],
        &["wavelength"],
        &["wavelength", "wavelengths"],
        &["wavelines"],
        &["wavefront"],
        &["waivers"],
    ],
    range: 4..=8,
};

static WORD_WAT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_WAT_CHILDREN),
    value: None,
};

pub static WORD_WAT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("chdong"),
        dictgen::InsensitiveStr::Ascii("chemn"),
        dictgen::InsensitiveStr::Ascii("chign"),
        dictgen::InsensitiveStr::Ascii("chog"),
        dictgen::InsensitiveStr::Ascii("erlemon"),
        dictgen::InsensitiveStr::Ascii("ermalon"),
        dictgen::InsensitiveStr::Ascii("ermask"),
        dictgen::InsensitiveStr::Ascii("ermeleon"),
        dictgen::InsensitiveStr::Ascii("erproff"),
        dictgen::InsensitiveStr::Ascii("erprooof"),
        dictgen::InsensitiveStr::Ascii("h"),
        dictgen::InsensitiveStr::Ascii("hc"),
        dictgen::InsensitiveStr::Ascii("hcer"),
        dictgen::InsensitiveStr::Ascii("hcing"),
        dictgen::InsensitiveStr::Ascii("hcmen"),
        dictgen::InsensitiveStr::Ascii("hdog"),
        dictgen::InsensitiveStr::Ascii("hever"),
        dictgen::InsensitiveStr::Ascii("hs"),
        dictgen::InsensitiveStr::Ascii("iers"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("kings"),
        dictgen::InsensitiveStr::Ascii("n"),
    ],
    values: &[
        &["watchdog"],
        &["watchmen"],
        &["watching"],
        &["watchdog"],
        &["watermelon"],
        &["watermelon"],
        &["watermark"],
        &["watermelon"],
        &["waterproof"],
        &["waterproof"],
        &["watch", "wrath", "what"],
        &["watch"],
        &["watcher"],
        &["watching"],
        &["watchmen"],
        &["watchdog"],
        &["whatever"],
        &["whats", "watches"],
        &["waiters"],
        &["waiting"],
        &["watkins"],
        &["want"],
    ],
    range: 1..=8,
};

static WORD_WAS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_WAS_CHILDREN),
    value: None,
};

pub static WORD_WAS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("hignton"),
        dictgen::InsensitiveStr::Ascii("hingtion"),
        dictgen::InsensitiveStr::Ascii("s"),
        dictgen::InsensitiveStr::Ascii("tefull"),
        dictgen::InsensitiveStr::Ascii("tefullness"),
    ],
    values: &[
        &["washington"],
        &["washington"],
        &["was"],
        &["wasteful", "wastefully"],
        &["wastefulness"],
    ],
    range: 1..=10,
};

static WORD_WAR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_WAR_CHILDREN),
    value: None,
};

static WORD_WAR_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_WARA_NODE),
    None,
    Some(&WORD_WARC_NODE),
    Some(&WORD_WARD_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_WARI_NODE),
    None,
    Some(&WORD_WARK_NODE),
    Some(&WORD_WARL_NODE),
    None,
    Some(&WORD_WARN_NODE),
    None,
    Some(&WORD_WARP_NODE),
    None,
    Some(&WORD_WARR_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_WARW_NODE),
    None,
    None,
    None,
];

static WORD_WARW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_WARW_CHILDREN),
    value: None,
};

pub static WORD_WARW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("cik")],
    values: &[&["warwick"]],
    range: 3..=3,
};

static WORD_WARR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_WARR_CHILDREN),
    value: None,
};

pub static WORD_WARR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("andyte"),
        dictgen::InsensitiveStr::Ascii("ante"),
        dictgen::InsensitiveStr::Ascii("antles"),
        dictgen::InsensitiveStr::Ascii("antly"),
        dictgen::InsensitiveStr::Ascii("any"),
        dictgen::InsensitiveStr::Ascii("ent"),
        dictgen::InsensitiveStr::Ascii("enties"),
        dictgen::InsensitiveStr::Ascii("ents"),
        dictgen::InsensitiveStr::Ascii("ios"),
        dictgen::InsensitiveStr::Ascii("iros"),
        dictgen::InsensitiveStr::Ascii("n"),
        dictgen::InsensitiveStr::Ascii("ned"),
        dictgen::InsensitiveStr::Ascii("ning"),
        dictgen::InsensitiveStr::Ascii("nings"),
        dictgen::InsensitiveStr::Ascii("riors"),
    ],
    values: &[
        &["warranty"],
        &["warranties"],
        &["warranties"],
        &["warranty"],
        &["warranty"],
        &["warrant"],
        &["warranties"],
        &["warrants"],
        &["warriors"],
        &["warriors"],
        &["warn"],
        &["warned"],
        &["warning"],
        &["warnings"],
        &["warriors"],
    ],
    range: 1..=6,
};

static WORD_WARP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_WARP_CHILDREN),
    value: None,
};

pub static WORD_WARP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ped"),
        dictgen::InsensitiveStr::Ascii("per"),
        dictgen::InsensitiveStr::Ascii("ping"),
        dictgen::InsensitiveStr::Ascii("pred"),
        dictgen::InsensitiveStr::Ascii("prer"),
        dictgen::InsensitiveStr::Ascii("pring"),
        dictgen::InsensitiveStr::Ascii("prs"),
        dictgen::InsensitiveStr::Ascii("ps"),
    ],
    values: &[
        &["warped", "wrapped"],
        &["warper", "wrapper"],
        &["warping", "wrapping"],
        &["warped", "wrapped"],
        &["warper", "wrapper"],
        &["warping", "wrapping"],
        &["warps", "wraps"],
        &["warps", "wraps"],
    ],
    range: 2..=5,
};

static WORD_WARN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_WARN_CHILDREN),
    value: None,
};

pub static WORD_WARN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ibg"),
        dictgen::InsensitiveStr::Ascii("ibgs"),
        dictgen::InsensitiveStr::Ascii("ig"),
        dictgen::InsensitiveStr::Ascii("ign"),
        dictgen::InsensitiveStr::Ascii("igns"),
        dictgen::InsensitiveStr::Ascii("igs"),
        dictgen::InsensitiveStr::Ascii("iing"),
        dictgen::InsensitiveStr::Ascii("iings"),
        dictgen::InsensitiveStr::Ascii("in"),
        dictgen::InsensitiveStr::Ascii("ind"),
        dictgen::InsensitiveStr::Ascii("inds"),
        dictgen::InsensitiveStr::Ascii("inf"),
        dictgen::InsensitiveStr::Ascii("infs"),
        dictgen::InsensitiveStr::Ascii("ingss"),
        dictgen::InsensitiveStr::Ascii("inig"),
        dictgen::InsensitiveStr::Ascii("inigs"),
        dictgen::InsensitiveStr::Ascii("ining"),
        dictgen::InsensitiveStr::Ascii("inings"),
        dictgen::InsensitiveStr::Ascii("inng"),
        dictgen::InsensitiveStr::Ascii("inngs"),
        dictgen::InsensitiveStr::Ascii("ins"),
        dictgen::InsensitiveStr::Ascii("insg"),
        dictgen::InsensitiveStr::Ascii("insgs"),
        dictgen::InsensitiveStr::Ascii("iong"),
        dictgen::InsensitiveStr::Ascii("iongs"),
        dictgen::InsensitiveStr::Ascii("kng"),
        dictgen::InsensitiveStr::Ascii("kngs"),
    ],
    values: &[
        &["warning"],
        &["warnings"],
        &["warning"],
        &["warning"],
        &["warnings"],
        &["warnings"],
        &["warning"],
        &["warnings"],
        &["warning"],
        &["warning"],
        &["warnings"],
        &["warning"],
        &["warnings"],
        &["warnings"],
        &["warning"],
        &["warnings"],
        &["warning"],
        &["warnings"],
        &["warning"],
        &["warnings"],
        &["warnings"],
        &["warnings"],
        &["warnings"],
        &["warning"],
        &["warnings"],
        &["warning"],
        &["warnings"],
    ],
    range: 2..=6,
};

static WORD_WARL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_WARL_CHILDREN),
    value: None,
};

pub static WORD_WARL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("king")],
    values: &[&["walking"]],
    range: 4..=4,
};

static WORD_WARK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_WARK_CHILDREN),
    value: None,
};

pub static WORD_WARK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("s")],
    values: &[&["works"]],
    range: 1..=1,
};

static WORD_WARI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_WARI_CHILDREN),
    value: None,
};

pub static WORD_WARI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ng"),
        dictgen::InsensitiveStr::Ascii("ngs"),
        dictgen::InsensitiveStr::Ascii("nigs"),
        dictgen::InsensitiveStr::Ascii("ning"),
        dictgen::InsensitiveStr::Ascii("nings"),
        dictgen::InsensitiveStr::Ascii("table"),
        dictgen::InsensitiveStr::Ascii("wck"),
    ],
    values: &[
        &["warning"],
        &["warnings"],
        &["warnings"],
        &["warning"],
        &["warnings"],
        &["writable"],
        &["warwick"],
    ],
    range: 2..=5,
};

static WORD_WARD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_WARD_CHILDREN),
    value: None,
};

pub static WORD_WARD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("obe")],
    values: &[&["wardrobe"]],
    range: 3..=3,
};

static WORD_WARC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_WARC_CHILDREN),
    value: None,
};

pub static WORD_WARC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("arft"),
        dictgen::InsensitiveStr::Ascii("rat"),
    ],
    values: &[&["warcraft"], &["warcraft"]],
    range: 3..=4,
};

static WORD_WARA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_WARA_CHILDREN),
    value: None,
};

pub static WORD_WARA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ntee"),
        dictgen::InsensitiveStr::Ascii("nties"),
        dictgen::InsensitiveStr::Ascii("nty"),
    ],
    values: &[&["warranty"], &["warranties"], &["warranty"]],
    range: 3..=5,
};

static WORD_WAP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_WAP_CHILDREN),
    value: None,
};

pub static WORD_WAP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("pers")],
    values: &[&["wrappers"]],
    range: 4..=4,
};

static WORD_WAL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_WAL_CHILDREN),
    value: None,
};

pub static WORD_WAL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("lpapaers"),
        dictgen::InsensitiveStr::Ascii("lpapes"),
        dictgen::InsensitiveStr::Ascii("lpappers"),
        dictgen::InsensitiveStr::Ascii("lpapr"),
    ],
    values: &[
        &["wallpapers"],
        &["wallpapers"],
        &["wallpapers"],
        &["wallpapers"],
    ],
    range: 5..=8,
};

static WORD_WAK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_WAK_CHILDREN),
    value: None,
};

pub static WORD_WAK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eus"),
        dictgen::InsensitiveStr::Ascii("tins"),
        dictgen::InsensitiveStr::Ascii("up"),
    ],
    values: &[&["wakeups", "walrus"], &["watkins"], &["wakeup"]],
    range: 2..=4,
};

static WORD_WAI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_WAI_CHILDREN),
    value: None,
};

pub static WORD_WAI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("nting"),
        dictgen::InsensitiveStr::Ascii("sline"),
        dictgen::InsensitiveStr::Ascii("slines"),
        dictgen::InsensitiveStr::Ascii("tres"),
        dictgen::InsensitiveStr::Ascii("tting"),
    ],
    values: &[
        &["waiting"],
        &["waistline"],
        &["waistlines"],
        &["waiters"],
        &["waiting"],
    ],
    range: 4..=6,
};

static WORD_WAH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_WAH_CHILDREN),
    value: None,
};

pub static WORD_WAH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("tever"),
    ],
    values: &[&["what"], &["whatever"]],
    range: 1..=5,
};

static WORD_WAC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_WAC_CHILDREN),
    value: None,
};

pub static WORD_WAC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("lott"),
        dictgen::InsensitiveStr::Ascii("ther"),
    ],
    values: &[&["walcott"], &["watcher"]],
    range: 4..=4,
};

static WORD_V_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_V_CHILDREN),
    value: None,
};

static WORD_V_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_VA_NODE),
    Some(&WORD_VB_NODE),
    None,
    None,
    Some(&WORD_VE_NODE),
    None,
    None,
    Some(&WORD_VH_NODE),
    Some(&WORD_VI_NODE),
    None,
    None,
    Some(&WORD_VL_NODE),
    None,
    None,
    Some(&WORD_VO_NODE),
    None,
    None,
    Some(&WORD_VR_NODE),
    None,
    None,
    Some(&WORD_VU_NODE),
    None,
    None,
    None,
    Some(&WORD_VY_NODE),
    None,
];

static WORD_VY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_VY_CHILDREN),
    value: None,
};

pub static WORD_VY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("er"),
        dictgen::InsensitiveStr::Ascii("re"),
    ],
    values: &[&["very"], &["very"]],
    range: 2..=2,
};

static WORD_VU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_VU_CHILDREN),
    value: None,
};

static WORD_VU_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_VUL_NODE),
    None,
    Some(&WORD_VUN_NODE),
    None,
    None,
    None,
    Some(&WORD_VUR_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_VUR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_VUR_CHILDREN),
    value: None,
};

pub static WORD_VUR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("nerabilities"),
        dictgen::InsensitiveStr::Ascii("nerability"),
    ],
    values: &[&["vulnerabilities"], &["vulnerability"]],
    range: 10..=12,
};

static WORD_VUN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_VUN_CHILDREN),
    value: None,
};

pub static WORD_VUN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("erabilities"),
        dictgen::InsensitiveStr::Ascii("erability"),
        dictgen::InsensitiveStr::Ascii("erable"),
        dictgen::InsensitiveStr::Ascii("lerabilities"),
        dictgen::InsensitiveStr::Ascii("lerability"),
        dictgen::InsensitiveStr::Ascii("lerable"),
        dictgen::InsensitiveStr::Ascii("rabilities"),
        dictgen::InsensitiveStr::Ascii("rability"),
        dictgen::InsensitiveStr::Ascii("rable"),
    ],
    values: &[
        &["vulnerabilities"],
        &["vulnerability"],
        &["vulnerable"],
        &["vulnerabilities"],
        &["vulnerability"],
        &["vulnerable"],
        &["vulnerabilities"],
        &["vulnerability"],
        &["vulnerable"],
    ],
    range: 5..=12,
};

static WORD_VUL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_VUL_CHILDREN),
    value: None,
};

static WORD_VUL_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_VULA_NODE),
    Some(&WORD_VULB_NODE),
    None,
    None,
    Some(&WORD_VULE_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_VULN_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_VULN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_VULN_CHILDREN),
    value: None,
};

static WORD_VULN_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_VULNA_NODE),
    None,
    None,
    Some(&WORD_VULND_NODE),
    Some(&WORD_VULNE_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_VULNR_NODE),
    None,
    None,
    Some(&WORD_VULNU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_VULNU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_VULNU_CHILDREN),
    value: None,
};

pub static WORD_VULNU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("rabilities"),
        dictgen::InsensitiveStr::Ascii("rability"),
        dictgen::InsensitiveStr::Ascii("rable"),
    ],
    values: &[&["vulnerabilities"], &["vulnerability"], &["vulnerable"]],
    range: 5..=10,
};

static WORD_VULNR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_VULNR_CHILDREN),
    value: None,
};

pub static WORD_VULNR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eabilities"),
        dictgen::InsensitiveStr::Ascii("eability"),
    ],
    values: &[&["vulnerabilities"], &["vulnerability"]],
    range: 8..=10,
};

static WORD_VULNE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_VULNE_CHILDREN),
    value: None,
};

pub static WORD_VULNE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("abilities"),
        dictgen::InsensitiveStr::Ascii("ability"),
        dictgen::InsensitiveStr::Ascii("able"),
        dictgen::InsensitiveStr::Ascii("arabilities"),
        dictgen::InsensitiveStr::Ascii("arability"),
        dictgen::InsensitiveStr::Ascii("arable"),
        dictgen::InsensitiveStr::Ascii("arabule"),
        dictgen::InsensitiveStr::Ascii("arbilities"),
        dictgen::InsensitiveStr::Ascii("arbility"),
        dictgen::InsensitiveStr::Ascii("arbuilities"),
        dictgen::InsensitiveStr::Ascii("arbuility"),
        dictgen::InsensitiveStr::Ascii("rabil"),
        dictgen::InsensitiveStr::Ascii("rabile"),
        dictgen::InsensitiveStr::Ascii("rabilies"),
        dictgen::InsensitiveStr::Ascii("rabiliies"),
        dictgen::InsensitiveStr::Ascii("rabilility"),
        dictgen::InsensitiveStr::Ascii("rabilites"),
        dictgen::InsensitiveStr::Ascii("rabiliti"),
        dictgen::InsensitiveStr::Ascii("rabilitie"),
        dictgen::InsensitiveStr::Ascii("rabilitis"),
        dictgen::InsensitiveStr::Ascii("rabilitiy"),
        dictgen::InsensitiveStr::Ascii("rabilitu"),
        dictgen::InsensitiveStr::Ascii("rabilitys"),
        dictgen::InsensitiveStr::Ascii("rabiliy"),
        dictgen::InsensitiveStr::Ascii("rabillities"),
        dictgen::InsensitiveStr::Ascii("rabillity"),
        dictgen::InsensitiveStr::Ascii("rabilties"),
        dictgen::InsensitiveStr::Ascii("rabiltiy"),
        dictgen::InsensitiveStr::Ascii("rabilty"),
        dictgen::InsensitiveStr::Ascii("rabitlies"),
        dictgen::InsensitiveStr::Ascii("rablility"),
        dictgen::InsensitiveStr::Ascii("rablities"),
        dictgen::InsensitiveStr::Ascii("rablity"),
        dictgen::InsensitiveStr::Ascii("rabuilility"),
        dictgen::InsensitiveStr::Ascii("rabuilites"),
        dictgen::InsensitiveStr::Ascii("rabuiliti"),
        dictgen::InsensitiveStr::Ascii("rabuilitie"),
        dictgen::InsensitiveStr::Ascii("rabuilities"),
        dictgen::InsensitiveStr::Ascii("rabuilitis"),
        dictgen::InsensitiveStr::Ascii("rabuilitiy"),
        dictgen::InsensitiveStr::Ascii("rabuility"),
        dictgen::InsensitiveStr::Ascii("rabuillities"),
        dictgen::InsensitiveStr::Ascii("rabuillity"),
        dictgen::InsensitiveStr::Ascii("rabuilties"),
        dictgen::InsensitiveStr::Ascii("rabuilty"),
        dictgen::InsensitiveStr::Ascii("rabule"),
        dictgen::InsensitiveStr::Ascii("rabulility"),
        dictgen::InsensitiveStr::Ascii("rarbilities"),
        dictgen::InsensitiveStr::Ascii("rarbility"),
        dictgen::InsensitiveStr::Ascii("rarble"),
        dictgen::InsensitiveStr::Ascii("rbilities"),
        dictgen::InsensitiveStr::Ascii("rbility"),
        dictgen::InsensitiveStr::Ascii("rbuilities"),
        dictgen::InsensitiveStr::Ascii("rbuility"),
    ],
    values: &[
        &["vulnerabilities"],
        &["vulnerability"],
        &["vulnerable"],
        &["vulnerabilities"],
        &["vulnerability"],
        &["vulnerable"],
        &["vulnerable"],
        &["vulnerabilities"],
        &["vulnerability"],
        &["vulnerabilities"],
        &["vulnerability"],
        &["vulnerable"],
        &["vulnerable"],
        &["vulnerabilities"],
        &["vulnerabilities"],
        &["vulnerability"],
        &["vulnerabilities"],
        &["vulnerability"],
        &["vulnerability"],
        &["vulnerabilities"],
        &["vulnerability"],
        &["vulnerability"],
        &["vulnerabilities", "vulnerability"],
        &["vulnerability"],
        &["vulnerabilities"],
        &["vulnerability"],
        &["vulnerabilities"],
        &["vulnerability"],
        &["vulnerability"],
        &["vulnerabilities"],
        &["vulnerability"],
        &["vulnerabilities"],
        &["vulnerability"],
        &["vulnerability"],
        &["vulnerabilities"],
        &["vulnerability"],
        &["vulnerability"],
        &["vulnerabilities"],
        &["vulnerabilities"],
        &["vulnerability"],
        &["vulnerability"],
        &["vulnerabilities"],
        &["vulnerability"],
        &["vulnerabilities"],
        &["vulnerability"],
        &["vulnerable"],
        &["vulnerability"],
        &["vulnerabilities"],
        &["vulnerability"],
        &["vulnerable"],
        &["vulnerabilities"],
        &["vulnerability"],
        &["vulnerabilities"],
        &["vulnerability"],
    ],
    range: 4..=12,
};

static WORD_VULND_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_VULND_CHILDREN),
    value: None,
};

pub static WORD_VULND_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("erabilities"),
        dictgen::InsensitiveStr::Ascii("erability"),
    ],
    values: &[&["vulnerabilities"], &["vulnerability"]],
    range: 9..=11,
};

static WORD_VULNA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_VULNA_CHILDREN),
    value: None,
};

pub static WORD_VULNA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("rabilities"),
        dictgen::InsensitiveStr::Ascii("rability"),
        dictgen::InsensitiveStr::Ascii("rable"),
    ],
    values: &[&["vulnerabilities"], &["vulnerability"], &["vulnerable"]],
    range: 5..=10,
};

static WORD_VULE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_VULE_CHILDREN),
    value: None,
};

pub static WORD_VULE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("rabilities"),
        dictgen::InsensitiveStr::Ascii("rability"),
        dictgen::InsensitiveStr::Ascii("rable"),
        dictgen::InsensitiveStr::Ascii("rabuilities"),
        dictgen::InsensitiveStr::Ascii("rabuility"),
        dictgen::InsensitiveStr::Ascii("rabule"),
        dictgen::InsensitiveStr::Ascii("rnabilities"),
        dictgen::InsensitiveStr::Ascii("rnability"),
        dictgen::InsensitiveStr::Ascii("rnable"),
    ],
    values: &[
        &["vulnerabilities"],
        &["vulnerability"],
        &["vulnerable"],
        &["vulnerabilities"],
        &["vulnerability"],
        &["vulnerable"],
        &["vulnerabilities"],
        &["vulnerability"],
        &["vulnerable"],
    ],
    range: 5..=11,
};

static WORD_VULB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_VULB_CHILDREN),
    value: None,
};

pub static WORD_VULB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("earable"),
        dictgen::InsensitiveStr::Ascii("earabule"),
        dictgen::InsensitiveStr::Ascii("earbilities"),
        dictgen::InsensitiveStr::Ascii("earbility"),
        dictgen::InsensitiveStr::Ascii("earbuilities"),
        dictgen::InsensitiveStr::Ascii("earbuility"),
        dictgen::InsensitiveStr::Ascii("erabilility"),
        dictgen::InsensitiveStr::Ascii("erabilites"),
        dictgen::InsensitiveStr::Ascii("erabiliti"),
        dictgen::InsensitiveStr::Ascii("erabilitie"),
        dictgen::InsensitiveStr::Ascii("erabilitis"),
        dictgen::InsensitiveStr::Ascii("erabilitiy"),
        dictgen::InsensitiveStr::Ascii("erability"),
        dictgen::InsensitiveStr::Ascii("erabillities"),
        dictgen::InsensitiveStr::Ascii("erabillity"),
        dictgen::InsensitiveStr::Ascii("erabilties"),
        dictgen::InsensitiveStr::Ascii("erabilty"),
        dictgen::InsensitiveStr::Ascii("erablility"),
        dictgen::InsensitiveStr::Ascii("erabuilility"),
        dictgen::InsensitiveStr::Ascii("erabuilites"),
        dictgen::InsensitiveStr::Ascii("erabuiliti"),
        dictgen::InsensitiveStr::Ascii("erabuilitie"),
        dictgen::InsensitiveStr::Ascii("erabuilities"),
        dictgen::InsensitiveStr::Ascii("erabuilitis"),
        dictgen::InsensitiveStr::Ascii("erabuilitiy"),
        dictgen::InsensitiveStr::Ascii("erabuility"),
        dictgen::InsensitiveStr::Ascii("erabuillities"),
        dictgen::InsensitiveStr::Ascii("erabuillity"),
        dictgen::InsensitiveStr::Ascii("erabuilties"),
        dictgen::InsensitiveStr::Ascii("erabuilty"),
        dictgen::InsensitiveStr::Ascii("erabule"),
        dictgen::InsensitiveStr::Ascii("erabulility"),
        dictgen::InsensitiveStr::Ascii("erbilities"),
        dictgen::InsensitiveStr::Ascii("erbility"),
        dictgen::InsensitiveStr::Ascii("erbuilities"),
        dictgen::InsensitiveStr::Ascii("erbuility"),
    ],
    values: &[
        &["vulnerable"],
        &["vulnerable"],
        &["vulnerabilities"],
        &["vulnerability"],
        &["vulnerabilities"],
        &["vulnerability"],
        &["vulnerability"],
        &["vulnerabilities"],
        &["vulnerability"],
        &["vulnerability"],
        &["vulnerabilities"],
        &["vulnerability"],
        &["vulnerability"],
        &["vulnerabilities"],
        &["vulnerability"],
        &["vulnerabilities"],
        &["vulnerability"],
        &["vulnerability"],
        &["vulnerability"],
        &["vulnerabilities"],
        &["vulnerability"],
        &["vulnerability"],
        &["vulnerabilities"],
        &["vulnerabilities"],
        &["vulnerability"],
        &["vulnerability"],
        &["vulnerabilities"],
        &["vulnerability"],
        &["vulnerabilities"],
        &["vulnerability"],
        &["vulnerable"],
        &["vulnerability"],
        &["vulnerabilities"],
        &["vulnerability"],
        &["vulnerabilities"],
        &["vulnerability"],
    ],
    range: 7..=13,
};

static WORD_VULA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_VULA_CHILDREN),
    value: None,
};

pub static WORD_VULA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cn"),
        dictgen::InsensitiveStr::Ascii("kn"),
    ],
    values: &[&["vulcan"], &["vulkan"]],
    range: 2..=2,
};

static WORD_VR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_VR_CHILDREN),
    value: None,
};

pub static WORD_VR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eity"),
        dictgen::InsensitiveStr::Ascii("esion"),
        dictgen::InsensitiveStr::Ascii("ey"),
        dictgen::InsensitiveStr::Ascii("iable"),
        dictgen::InsensitiveStr::Ascii("iables"),
        dictgen::InsensitiveStr::Ascii("iament"),
        dictgen::InsensitiveStr::Ascii("iety"),
        dictgen::InsensitiveStr::Ascii("ifier"),
        dictgen::InsensitiveStr::Ascii("ifies"),
        dictgen::InsensitiveStr::Ascii("ify"),
        dictgen::InsensitiveStr::Ascii("iginity"),
        dictgen::InsensitiveStr::Ascii("igins"),
        dictgen::InsensitiveStr::Ascii("ilog"),
        dictgen::InsensitiveStr::Ascii("itual"),
        dictgen::InsensitiveStr::Ascii("itualenv"),
        dictgen::InsensitiveStr::Ascii("itualisation"),
        dictgen::InsensitiveStr::Ascii("itualise"),
        dictgen::InsensitiveStr::Ascii("itualization"),
        dictgen::InsensitiveStr::Ascii("itualize"),
        dictgen::InsensitiveStr::Ascii("ituoso"),
        dictgen::InsensitiveStr::Ascii("sion"),
        dictgen::InsensitiveStr::Ascii("sions"),
    ],
    values: &[
        &["variety"],
        &["version"],
        &["very"],
        &["variable"],
        &["variables"],
        &["vraiment"],
        &["variety"],
        &["verifier"],
        &["verifies"],
        &["verify"],
        &["virginity"],
        &["virgins"],
        &["verilog"],
        &["virtual"],
        &["virtualenv"],
        &["virtualisation"],
        &["virtualise"],
        &["virtualization"],
        &["virtualize"],
        &["virtuoso"],
        &["version"],
        &["versions"],
    ],
    range: 2..=12,
};

static WORD_VO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_VO_CHILDREN),
    value: None,
};

static WORD_VO_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    Some(&WORD_VOC_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_VOI_NODE),
    None,
    None,
    Some(&WORD_VOL_NODE),
    None,
    Some(&WORD_VON_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_VOT_NODE),
    Some(&WORD_VOU_NODE),
    None,
    None,
    Some(&WORD_VOX_NODE),
    Some(&WORD_VOY_NODE),
    None,
];

static WORD_VOY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_VOY_CHILDREN),
    value: None,
};

pub static WORD_VOY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("our"),
        dictgen::InsensitiveStr::Ascii("ouristic"),
        dictgen::InsensitiveStr::Ascii("ouristically"),
        dictgen::InsensitiveStr::Ascii("ours"),
    ],
    values: &[
        &["voyeur"],
        &["voyeuristic"],
        &["voyeuristically"],
        &["voyeurs"],
    ],
    range: 3..=12,
};

static WORD_VOX_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_VOX_CHILDREN),
    value: None,
};

pub static WORD_VOX_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("es")],
    values: &[&["voxels", "voxel"]],
    range: 2..=2,
};

static WORD_VOU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_VOU_CHILDREN),
    value: None,
};

pub static WORD_VOU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ld"),
        dictgen::InsensitiveStr::Ascii("me"),
    ],
    values: &[&["would"], &["volume"]],
    range: 2..=2,
};

static WORD_VOT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_VOT_CHILDREN),
    value: None,
};

pub static WORD_VOT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("lage")],
    values: &[&["voltage"]],
    range: 4..=4,
};

static WORD_VON_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_VON_CHILDREN),
    value: None,
};

pub static WORD_VON_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("fig")],
    values: &[&["config"]],
    range: 3..=3,
};

static WORD_VOL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_VOL_CHILDREN),
    value: None,
};

pub static WORD_VOL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("atage"),
        dictgen::InsensitiveStr::Ascii("atages"),
        dictgen::InsensitiveStr::Ascii("atge"),
        dictgen::InsensitiveStr::Ascii("atges"),
        dictgen::InsensitiveStr::Ascii("atiliy"),
        dictgen::InsensitiveStr::Ascii("atillity"),
        dictgen::InsensitiveStr::Ascii("atiltiy"),
        dictgen::InsensitiveStr::Ascii("atily"),
        dictgen::InsensitiveStr::Ascii("ativity"),
        dictgen::InsensitiveStr::Ascii("cando"),
        dictgen::InsensitiveStr::Ascii("canoe"),
        dictgen::InsensitiveStr::Ascii("caron"),
        dictgen::InsensitiveStr::Ascii("enteer"),
        dictgen::InsensitiveStr::Ascii("enteered"),
        dictgen::InsensitiveStr::Ascii("enteers"),
        dictgen::InsensitiveStr::Ascii("entier"),
        dictgen::InsensitiveStr::Ascii("entiered"),
        dictgen::InsensitiveStr::Ascii("entiering"),
        dictgen::InsensitiveStr::Ascii("entiers"),
        dictgen::InsensitiveStr::Ascii("eyball"),
        dictgen::InsensitiveStr::Ascii("itality"),
        dictgen::InsensitiveStr::Ascii("leyboll"),
        dictgen::InsensitiveStr::Ascii("lyeball"),
        dictgen::InsensitiveStr::Ascii("ontary"),
        dictgen::InsensitiveStr::Ascii("onteer"),
        dictgen::InsensitiveStr::Ascii("onteered"),
        dictgen::InsensitiveStr::Ascii("onteering"),
        dictgen::InsensitiveStr::Ascii("onteers"),
        dictgen::InsensitiveStr::Ascii("ounteer"),
        dictgen::InsensitiveStr::Ascii("ounteered"),
        dictgen::InsensitiveStr::Ascii("ounteering"),
        dictgen::InsensitiveStr::Ascii("ounteers"),
        dictgen::InsensitiveStr::Ascii("umn"),
        dictgen::InsensitiveStr::Ascii("umne"),
        dictgen::InsensitiveStr::Ascii("ums"),
        dictgen::InsensitiveStr::Ascii("unatrily"),
        dictgen::InsensitiveStr::Ascii("unatry"),
        dictgen::InsensitiveStr::Ascii("untairly"),
        dictgen::InsensitiveStr::Ascii("untairy"),
        dictgen::InsensitiveStr::Ascii("untarilly"),
        dictgen::InsensitiveStr::Ascii("untarly"),
        dictgen::InsensitiveStr::Ascii("untears"),
        dictgen::InsensitiveStr::Ascii("unteed"),
        dictgen::InsensitiveStr::Ascii("unteeer"),
        dictgen::InsensitiveStr::Ascii("unteeers"),
        dictgen::InsensitiveStr::Ascii("unteerd"),
        dictgen::InsensitiveStr::Ascii("unteraly"),
        dictgen::InsensitiveStr::Ascii("untered"),
        dictgen::InsensitiveStr::Ascii("untereed"),
        dictgen::InsensitiveStr::Ascii("unterily"),
        dictgen::InsensitiveStr::Ascii("unterring"),
        dictgen::InsensitiveStr::Ascii("xel"),
        dictgen::InsensitiveStr::Ascii("xels"),
    ],
    values: &[
        &["voltage"],
        &["voltages"],
        &["voltage"],
        &["voltages"],
        &["volatility"],
        &["volatility"],
        &["volatility"],
        &["volatility"],
        &["volatility"],
        &["volcano"],
        &["volcano"],
        &["volcano"],
        &["volunteer"],
        &["volunteered"],
        &["volunteers"],
        &["volunteer"],
        &["volunteered"],
        &["volunteering"],
        &["volunteers"],
        &["volleyball"],
        &["volatility"],
        &["volleyball"],
        &["volleyball"],
        &["voluntary"],
        &["volunteer"],
        &["volunteered"],
        &["volunteering"],
        &["volunteers"],
        &["volunteer"],
        &["volunteered"],
        &["volunteering"],
        &["volunteers"],
        &["volume"],
        &["volume"],
        &["volume"],
        &["voluntarily"],
        &["voluntary"],
        &["voluntarily"],
        &["voluntarily"],
        &["voluntarily"],
        &["voluntary"],
        &["volunteers"],
        &["volunteered"],
        &["volunteers"],
        &["volunteers"],
        &["volunteered"],
        &["voluntarily"],
        &["volunteered"],
        &["volunteered"],
        &["voluntarily"],
        &["volunteering"],
        &["voxel"],
        &["voxels"],
    ],
    range: 3..=10,
};

static WORD_VOI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_VOI_CHILDREN),
    value: None,
};

pub static WORD_VOI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cemal"),
        dictgen::InsensitiveStr::Ascii("f"),
        dictgen::InsensitiveStr::Ascii("lates"),
        dictgen::InsensitiveStr::Ascii("lating"),
        dictgen::InsensitiveStr::Ascii("lation"),
        dictgen::InsensitiveStr::Ascii("lations"),
        dictgen::InsensitiveStr::Ascii("lently"),
    ],
    values: &[
        &["voicemail"],
        &["void"],
        &["violates"],
        &["violating"],
        &["violation"],
        &["violations"],
        &["violently"],
    ],
    range: 1..=7,
};

static WORD_VOC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_VOC_CHILDREN),
    value: None,
};

pub static WORD_VOC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("abluary"),
        dictgen::InsensitiveStr::Ascii("abularily"),
        dictgen::InsensitiveStr::Ascii("abularity"),
        dictgen::InsensitiveStr::Ascii("abularly"),
        dictgen::InsensitiveStr::Ascii("iemail"),
    ],
    values: &[
        &["vocabulary"],
        &["vocabulary"],
        &["vocabulary"],
        &["vocabulary"],
        &["voicemail"],
    ],
    range: 6..=9,
};

static WORD_VL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_VL_CHILDREN),
    value: None,
};

pub static WORD_VL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("arge"),
        dictgen::InsensitiveStr::Ascii("aue"),
        dictgen::InsensitiveStr::Ascii("aues"),
        dictgen::InsensitiveStr::Ascii("one"),
        dictgen::InsensitiveStr::Ascii("oned"),
        dictgen::InsensitiveStr::Ascii("ones"),
        dictgen::InsensitiveStr::Ascii("ues"),
    ],
    values: &[
        &["large"],
        &["value"],
        &["values"],
        &["clone"],
        &["cloned"],
        &["clones"],
        &["values"],
    ],
    range: 3..=4,
};

static WORD_VI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_VI_CHILDREN),
    value: None,
};

static WORD_VI_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_VIA_NODE),
    Some(&WORD_VIB_NODE),
    Some(&WORD_VIC_NODE),
    Some(&WORD_VID_NODE),
    Some(&WORD_VIE_NODE),
    None,
    Some(&WORD_VIG_NODE),
    None,
    None,
    None,
    Some(&WORD_VIK_NODE),
    Some(&WORD_VIL_NODE),
    None,
    Some(&WORD_VIN_NODE),
    Some(&WORD_VIO_NODE),
    None,
    None,
    Some(&WORD_VIR_NODE),
    Some(&WORD_VIS_NODE),
    Some(&WORD_VIT_NODE),
    Some(&WORD_VIU_NODE),
    None,
    Some(&WORD_VIW_NODE),
    None,
    None,
    Some(&WORD_VIZ_NODE),
];

static WORD_VIZ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_VIZ_CHILDREN),
    value: None,
};

pub static WORD_VIZ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ualisation"),
        dictgen::InsensitiveStr::Ascii("ualisations"),
        dictgen::InsensitiveStr::Ascii("ualise"),
        dictgen::InsensitiveStr::Ascii("ualised"),
        dictgen::InsensitiveStr::Ascii("ualization"),
        dictgen::InsensitiveStr::Ascii("ualize"),
        dictgen::InsensitiveStr::Ascii("ualized"),
    ],
    values: &[
        &["visualisation"],
        &["visualisation"],
        &["visualise"],
        &["visualised"],
        &["visualization", "virtualization"],
        &["visualize"],
        &["visualized"],
    ],
    range: 6..=11,
};

static WORD_VIW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_VIW_CHILDREN),
    value: None,
};

pub static WORD_VIW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("eed"),
        dictgen::InsensitiveStr::Ascii("er"),
        dictgen::InsensitiveStr::Ascii("ers"),
        dictgen::InsensitiveStr::Ascii("es"),
    ],
    values: &[
        &["view"],
        &["viewed"],
        &["viewed"],
        &["viewer"],
        &["viewers"],
        &["views"],
    ],
    range: 1..=3,
};

static WORD_VIU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_VIU_CHILDREN),
    value: None,
};

pub static WORD_VIU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("sally"),
        dictgen::InsensitiveStr::Ascii("sualisation"),
    ],
    values: &[&["visually"], &["visualisation"]],
    range: 5..=11,
};

static WORD_VIT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_VIT_CHILDREN),
    value: None,
};

pub static WORD_VIT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ailty"),
        dictgen::InsensitiveStr::Ascii("aliy"),
        dictgen::InsensitiveStr::Ascii("aminas"),
        dictgen::InsensitiveStr::Ascii("amines"),
        dictgen::InsensitiveStr::Ascii("amis"),
        dictgen::InsensitiveStr::Ascii("enam"),
        dictgen::InsensitiveStr::Ascii("enamese"),
        dictgen::InsensitiveStr::Ascii("imans"),
        dictgen::InsensitiveStr::Ascii("irol"),
        dictgen::InsensitiveStr::Ascii("main"),
        dictgen::InsensitiveStr::Ascii("mains"),
        dictgen::InsensitiveStr::Ascii("ories"),
        dictgen::InsensitiveStr::Ascii("roil"),
        dictgen::InsensitiveStr::Ascii("role"),
        dictgen::InsensitiveStr::Ascii("rual"),
        dictgen::InsensitiveStr::Ascii("rually"),
        dictgen::InsensitiveStr::Ascii("rues"),
        dictgen::InsensitiveStr::Ascii("ual"),
        dictgen::InsensitiveStr::Ascii("ualization"),
    ],
    values: &[
        &["vitality"],
        &["vitality"],
        &["vitamins"],
        &["vitamins"],
        &["vitamins"],
        &["vietnam"],
        &["vietnamese"],
        &["vitamins"],
        &["vitriol"],
        &["vitamin"],
        &["vitamins"],
        &["victories"],
        &["vitriol"],
        &["vitriol"],
        &["virtual"],
        &["virtually"],
        &["virtues"],
        &["virtual"],
        &["visualization"],
    ],
    range: 3..=10,
};

static WORD_VIS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_VIS_CHILDREN),
    value: None,
};

static WORD_VIS_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_VISA_NODE),
    Some(&WORD_VISB_NODE),
    Some(&WORD_VISC_NODE),
    None,
    Some(&WORD_VISE_NODE),
    None,
    None,
    Some(&WORD_VISH_NODE),
    Some(&WORD_VISI_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_VISS_NODE),
    Some(&WORD_VIST_NODE),
    Some(&WORD_VISU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_VISU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_VISU_CHILDREN),
    value: None,
};

pub static WORD_VISU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ab"),
        dictgen::InsensitiveStr::Ascii("abisation"),
        dictgen::InsensitiveStr::Ascii("abise"),
        dictgen::InsensitiveStr::Ascii("abised"),
        dictgen::InsensitiveStr::Ascii("abises"),
        dictgen::InsensitiveStr::Ascii("abization"),
        dictgen::InsensitiveStr::Ascii("abize"),
        dictgen::InsensitiveStr::Ascii("abized"),
        dictgen::InsensitiveStr::Ascii("abizes"),
        dictgen::InsensitiveStr::Ascii("able"),
        dictgen::InsensitiveStr::Ascii("ables"),
        dictgen::InsensitiveStr::Ascii("ably"),
        dictgen::InsensitiveStr::Ascii("abs"),
        dictgen::InsensitiveStr::Ascii("aisation"),
        dictgen::InsensitiveStr::Ascii("aise"),
        dictgen::InsensitiveStr::Ascii("aised"),
        dictgen::InsensitiveStr::Ascii("aises"),
        dictgen::InsensitiveStr::Ascii("aization"),
        dictgen::InsensitiveStr::Ascii("aize"),
        dictgen::InsensitiveStr::Ascii("aized"),
        dictgen::InsensitiveStr::Ascii("aizes"),
        dictgen::InsensitiveStr::Ascii("ale"),
        dictgen::InsensitiveStr::Ascii("ales"),
        dictgen::InsensitiveStr::Ascii("alizacion"),
        dictgen::InsensitiveStr::Ascii("alizaion"),
        dictgen::InsensitiveStr::Ascii("alizaiton"),
        dictgen::InsensitiveStr::Ascii("alizaitons"),
        dictgen::InsensitiveStr::Ascii("alizating"),
        dictgen::InsensitiveStr::Ascii("alizaton"),
        dictgen::InsensitiveStr::Ascii("alizatons"),
        dictgen::InsensitiveStr::Ascii("allisation"),
        dictgen::InsensitiveStr::Ascii("allization"),
        dictgen::InsensitiveStr::Ascii("alsation"),
        dictgen::InsensitiveStr::Ascii("alsations"),
        dictgen::InsensitiveStr::Ascii("aly"),
        dictgen::InsensitiveStr::Ascii("alyse"),
        dictgen::InsensitiveStr::Ascii("alzation"),
        dictgen::InsensitiveStr::Ascii("alzations"),
        dictgen::InsensitiveStr::Ascii("lisation"),
        dictgen::InsensitiveStr::Ascii("lisations"),
        dictgen::InsensitiveStr::Ascii("lization"),
        dictgen::InsensitiveStr::Ascii("lizations"),
    ],
    values: &[
        &["visual"],
        &["visualisation"],
        &["visualise"],
        &["visualised"],
        &["visualises"],
        &["visualization"],
        &["visualize"],
        &["visualized"],
        &["visualizes"],
        &["visual", "visible"],
        &["visuals"],
        &["visually"],
        &["visuals"],
        &["visualisation"],
        &["visualise"],
        &["visualised"],
        &["visualises"],
        &["visualization"],
        &["visualize"],
        &["visualized"],
        &["visualizes"],
        &["visual"],
        &["visuals"],
        &["visualization"],
        &["visualization"],
        &["visualization"],
        &["visualizations"],
        &["visualization"],
        &["visualization"],
        &["visualizations"],
        &["visualisation"],
        &["visualization"],
        &["visualisation"],
        &["visualisations"],
        &["visually"],
        &["visualise"],
        &["visualization"],
        &["visualizations"],
        &["visualisation"],
        &["visualisations"],
        &["visualization"],
        &["visualizations"],
    ],
    range: 2..=10,
};

static WORD_VIST_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_VIST_CHILDREN),
    value: Some(&[
        "visit", "fist", "gist", "list", "mist", "vast", "vest", "vista",
    ]),
};

pub static WORD_VIST_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("ors"),
        dictgen::InsensitiveStr::Ascii("s"),
    ],
    values: &[
        &["visited", "listed", "vested"],
        &["visiting", "listing"],
        &["visitors"],
        &["fists", "lists", "visits"],
    ],
    range: 1..=3,
};

static WORD_VISS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_VISS_CHILDREN),
    value: None,
};

pub static WORD_VISS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ible")],
    values: &[&["visible"]],
    range: 4..=4,
};

static WORD_VISI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_VISI_CHILDREN),
    value: None,
};

pub static WORD_VISI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("able"),
        dictgen::InsensitiveStr::Ascii("ably"),
        dictgen::InsensitiveStr::Ascii("bale"),
        dictgen::InsensitiveStr::Ascii("bibilty"),
        dictgen::InsensitiveStr::Ascii("bile"),
        dictgen::InsensitiveStr::Ascii("bililty"),
        dictgen::InsensitiveStr::Ascii("bilit"),
        dictgen::InsensitiveStr::Ascii("biliy"),
        dictgen::InsensitiveStr::Ascii("billity"),
        dictgen::InsensitiveStr::Ascii("biltiy"),
        dictgen::InsensitiveStr::Ascii("bilty"),
        dictgen::InsensitiveStr::Ascii("bily"),
        dictgen::InsensitiveStr::Ascii("bl"),
        dictgen::InsensitiveStr::Ascii("bleable"),
        dictgen::InsensitiveStr::Ascii("bles"),
        dictgen::InsensitiveStr::Ascii("bley"),
        dictgen::InsensitiveStr::Ascii("blities"),
        dictgen::InsensitiveStr::Ascii("blity"),
        dictgen::InsensitiveStr::Ascii("blle"),
        dictgen::InsensitiveStr::Ascii("blly"),
        dictgen::InsensitiveStr::Ascii("lbity"),
        dictgen::InsensitiveStr::Ascii("nble"),
        dictgen::InsensitiveStr::Ascii("ous"),
        dictgen::InsensitiveStr::Ascii("sble"),
        dictgen::InsensitiveStr::Ascii("ter"),
        dictgen::InsensitiveStr::Ascii("ters"),
        dictgen::InsensitiveStr::Ascii("tng"),
        dictgen::InsensitiveStr::Ascii("vble"),
    ],
    values: &[
        &["visible"],
        &["visibly"],
        &["visible"],
        &["visibility"],
        &["visible"],
        &["visibility"],
        &["visibility"],
        &["visibility", "visibly"],
        &["visibility"],
        &["visibility"],
        &["visibility"],
        &["visibility", "visibly"],
        &["visible"],
        &["visible"],
        &["visible"],
        &["visibly"],
        &["visibilities"],
        &["visibility"],
        &["visible"],
        &["visibly"],
        &["visibility"],
        &["visible"],
        &["vicious"],
        &["visible"],
        &["visitor"],
        &["visitors"],
        &["visiting"],
        &["visible"],
    ],
    range: 2..=7,
};

static WORD_VISH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_VISH_CHILDREN),
    value: None,
};

pub static WORD_VISH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eate"),
        dictgen::InsensitiveStr::Ascii("eation"),
        dictgen::InsensitiveStr::Ascii("eator"),
        dictgen::InsensitiveStr::Ascii("eators"),
        dictgen::InsensitiveStr::Ascii("us"),
        dictgen::InsensitiveStr::Ascii("usly"),
    ],
    values: &[
        &["vitiate"],
        &["vitiation"],
        &["vitiator"],
        &["vitiators"],
        &["vicious"],
        &["viciously"],
    ],
    range: 2..=6,
};

static WORD_VISE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_VISE_CHILDREN),
    value: None,
};

pub static WORD_VISE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ral"),
        dictgen::InsensitiveStr::Ascii("rally"),
        dictgen::InsensitiveStr::Ascii("rcal"),
    ],
    values: &[&["visceral"], &["viscerally"], &["visceral"]],
    range: 3..=5,
};

static WORD_VISC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_VISC_CHILDREN),
    value: None,
};

pub static WORD_VISC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("real")],
    values: &[&["visceral"]],
    range: 4..=4,
};

static WORD_VISB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_VISB_CHILDREN),
    value: None,
};

pub static WORD_VISB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ility"),
        dictgen::InsensitiveStr::Ascii("ily"),
        dictgen::InsensitiveStr::Ascii("le"),
        dictgen::InsensitiveStr::Ascii("lie"),
        dictgen::InsensitiveStr::Ascii("ly"),
    ],
    values: &[
        &["visibility"],
        &["visibly"],
        &["visible"],
        &["visible"],
        &["visibly"],
    ],
    range: 2..=5,
};

static WORD_VISA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_VISA_CHILDREN),
    value: None,
};

pub static WORD_VISA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("bility"),
        dictgen::InsensitiveStr::Ascii("ble"),
        dictgen::InsensitiveStr::Ascii("bly"),
    ],
    values: &[&["visibility"], &["visible"], &["visibly"]],
    range: 3..=6,
};

static WORD_VIR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_VIR_CHILDREN),
    value: None,
};

pub static WORD_VIR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("alence"),
        dictgen::InsensitiveStr::Ascii("alently"),
        dictgen::InsensitiveStr::Ascii("ament"),
        dictgen::InsensitiveStr::Ascii("bate"),
        dictgen::InsensitiveStr::Ascii("bation"),
        dictgen::InsensitiveStr::Ascii("bator"),
        dictgen::InsensitiveStr::Ascii("ginas"),
        dictgen::InsensitiveStr::Ascii("gines"),
        dictgen::InsensitiveStr::Ascii("gings"),
        dictgen::InsensitiveStr::Ascii("ginis"),
        dictgen::InsensitiveStr::Ascii("gintiy"),
        dictgen::InsensitiveStr::Ascii("ginus"),
        dictgen::InsensitiveStr::Ascii("ignity"),
        dictgen::InsensitiveStr::Ascii("igns"),
        dictgen::InsensitiveStr::Ascii("tal"),
        dictgen::InsensitiveStr::Ascii("talenv"),
        dictgen::InsensitiveStr::Ascii("taul"),
        dictgen::InsensitiveStr::Ascii("tical"),
        dictgen::InsensitiveStr::Ascii("tiol"),
        dictgen::InsensitiveStr::Ascii("tiual"),
        dictgen::InsensitiveStr::Ascii("ttual"),
        dictgen::InsensitiveStr::Ascii("ttually"),
        dictgen::InsensitiveStr::Ascii("tualenf"),
        dictgen::InsensitiveStr::Ascii("tualiation"),
        dictgen::InsensitiveStr::Ascii("tualied"),
        dictgen::InsensitiveStr::Ascii("tualisaion"),
        dictgen::InsensitiveStr::Ascii("tualisaiton"),
        dictgen::InsensitiveStr::Ascii("tualizaion"),
        dictgen::InsensitiveStr::Ascii("tualizaiton"),
        dictgen::InsensitiveStr::Ascii("tualiziation"),
        dictgen::InsensitiveStr::Ascii("tualy"),
        dictgen::InsensitiveStr::Ascii("tualzation"),
        dictgen::InsensitiveStr::Ascii("tuell"),
        dictgen::InsensitiveStr::Ascii("tuels"),
        dictgen::InsensitiveStr::Ascii("tuose"),
        dictgen::InsensitiveStr::Ascii("tural"),
        dictgen::InsensitiveStr::Ascii("ture"),
        dictgen::InsensitiveStr::Ascii("ual"),
        dictgen::InsensitiveStr::Ascii("ualization"),
        dictgen::InsensitiveStr::Ascii("utal"),
        dictgen::InsensitiveStr::Ascii("utalenv"),
        dictgen::InsensitiveStr::Ascii("utalisation"),
        dictgen::InsensitiveStr::Ascii("utalise"),
        dictgen::InsensitiveStr::Ascii("utalised"),
        dictgen::InsensitiveStr::Ascii("utalization"),
        dictgen::InsensitiveStr::Ascii("utalize"),
        dictgen::InsensitiveStr::Ascii("utalized"),
        dictgen::InsensitiveStr::Ascii("utally"),
        dictgen::InsensitiveStr::Ascii("utals"),
        dictgen::InsensitiveStr::Ascii("utes"),
        dictgen::InsensitiveStr::Ascii("utual"),
    ],
    values: &[
        &["virulence"],
        &["virulently"],
        &["vraiment"],
        &["vibrate"],
        &["vibration"],
        &["vibrator"],
        &["virgins"],
        &["virgins"],
        &["virgins"],
        &["virgins"],
        &["virginity"],
        &["virgins"],
        &["virginity"],
        &["virgins"],
        &["virtual"],
        &["virtualenv"],
        &["virtual"],
        &["vertical"],
        &["vitriol"],
        &["virtual"],
        &["virtual"],
        &["virtually"],
        &["virtualenv"],
        &["virtualisation", "virtualization"],
        &["virtualised", "virtualized"],
        &["virtualisation"],
        &["virtualisation"],
        &["virtualization"],
        &["virtualization"],
        &["virtualization"],
        &["virtually"],
        &["virtualization"],
        &["virtual"],
        &["virtues"],
        &["virtues"],
        &["virtual"],
        &["virtue"],
        &["virtual", "viral"],
        &["visualization"],
        &["virtual"],
        &["virtualenv"],
        &["virtualisation"],
        &["virtualise"],
        &["virtualised"],
        &["virtualization"],
        &["virtualize"],
        &["virtualized"],
        &["virtually"],
        &["virtuals"],
        &["virtues"],
        &["virtual"],
    ],
    range: 3..=12,
};

static WORD_VIO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_VIO_CHILDREN),
    value: None,
};

pub static WORD_VIO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("alte"),
        dictgen::InsensitiveStr::Ascii("alting"),
        dictgen::InsensitiveStr::Ascii("altion"),
        dictgen::InsensitiveStr::Ascii("latin"),
        dictgen::InsensitiveStr::Ascii("lentce"),
        dictgen::InsensitiveStr::Ascii("lenty"),
        dictgen::InsensitiveStr::Ascii("letas"),
        dictgen::InsensitiveStr::Ascii("loated"),
        dictgen::InsensitiveStr::Ascii("loating"),
        dictgen::InsensitiveStr::Ascii("loation"),
        dictgen::InsensitiveStr::Ascii("loations"),
    ],
    values: &[
        &["violate"],
        &["violating"],
        &["violation"],
        &["violation"],
        &["violence"],
        &["violently"],
        &["violates"],
        &["violated"],
        &["violating"],
        &["violation"],
        &["violations"],
    ],
    range: 4..=8,
};

static WORD_VIN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_VIN_CHILDREN),
    value: None,
};

pub static WORD_VIN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cinity"),
        dictgen::InsensitiveStr::Ascii("dicitve"),
        dictgen::InsensitiveStr::Ascii("dictave"),
        dictgen::InsensitiveStr::Ascii("dicte"),
        dictgen::InsensitiveStr::Ascii("icity"),
        dictgen::InsensitiveStr::Ascii("igar"),
        dictgen::InsensitiveStr::Ascii("igarette"),
        dictgen::InsensitiveStr::Ascii("igarettes"),
        dictgen::InsensitiveStr::Ascii("rator"),
        dictgen::InsensitiveStr::Ascii("yet"),
        dictgen::InsensitiveStr::Ascii("yets"),
    ],
    values: &[
        &["vicinity"],
        &["vindictive"],
        &["vindictive"],
        &["vindictive"],
        &["vicinity"],
        &["vinegar"],
        &["vinaigrette"],
        &["vinaigrettes"],
        &["vibrator"],
        &["vignette"],
        &["vignettes"],
    ],
    range: 3..=9,
};

static WORD_VIL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_VIL_CHILDREN),
    value: None,
};

pub static WORD_VIL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("igant"),
        dictgen::InsensitiveStr::Ascii("igante"),
        dictgen::InsensitiveStr::Ascii("l"),
        dictgen::InsensitiveStr::Ascii("lageois"),
        dictgen::InsensitiveStr::Ascii("lan"),
        dictgen::InsensitiveStr::Ascii("lans"),
        dictgen::InsensitiveStr::Ascii("legas"),
        dictgen::InsensitiveStr::Ascii("lian"),
        dictgen::InsensitiveStr::Ascii("lians"),
        dictgen::InsensitiveStr::Ascii("lification"),
        dictgen::InsensitiveStr::Ascii("lify"),
        dictgen::InsensitiveStr::Ascii("lin"),
        dictgen::InsensitiveStr::Ascii("oently"),
    ],
    values: &[
        &["vigilant"],
        &["vigilante"],
        &["will"],
        &["villages"],
        &["villain"],
        &["villains"],
        &["villages"],
        &["villain"],
        &["villains"],
        &["vilification"],
        &["vilify"],
        &["villain", "villi", "villein"],
        &["violently"],
    ],
    range: 1..=10,
};

static WORD_VIK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_VIK_CHILDREN),
    value: None,
};

pub static WORD_VIK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("igns"),
        dictgen::InsensitiveStr::Ascii("ingos"),
    ],
    values: &[&["vikings"], &["vikings"]],
    range: 4..=5,
};

static WORD_VIG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_VIG_CHILDREN),
    value: None,
};

pub static WORD_VIG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eur"),
        dictgen::InsensitiveStr::Ascii("ilane"),
        dictgen::InsensitiveStr::Ascii("ilantie"),
        dictgen::InsensitiveStr::Ascii("ilanties"),
        dictgen::InsensitiveStr::Ascii("ilanty"),
        dictgen::InsensitiveStr::Ascii("ilence"),
        dictgen::InsensitiveStr::Ascii("liant"),
        dictgen::InsensitiveStr::Ascii("liante"),
        dictgen::InsensitiveStr::Ascii("oruosly"),
        dictgen::InsensitiveStr::Ascii("ourosly"),
        dictgen::InsensitiveStr::Ascii("ourous"),
        dictgen::InsensitiveStr::Ascii("rins"),
    ],
    values: &[
        &["vigueur", "vigour"],
        &["vigilante"],
        &["vigilante"],
        &["vigilante", "vigilantes"],
        &["vigilante"],
        &["vigilance"],
        &["vigilant"],
        &["vigilante"],
        &["vigorously"],
        &["vigorously"],
        &["vigorous"],
        &["virgins"],
    ],
    range: 3..=8,
};

static WORD_VIE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_VIE_CHILDREN),
    value: None,
};

pub static WORD_VIE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("ntam"),
        dictgen::InsensitiveStr::Ascii("ntamese"),
        dictgen::InsensitiveStr::Ascii("port"),
        dictgen::InsensitiveStr::Ascii("ports"),
        dictgen::InsensitiveStr::Ascii("tmanese"),
        dictgen::InsensitiveStr::Ascii("tnamees"),
        dictgen::InsensitiveStr::Ascii("tnameese"),
        dictgen::InsensitiveStr::Ascii("tnamesea"),
        dictgen::InsensitiveStr::Ascii("tnamesse"),
        dictgen::InsensitiveStr::Ascii("tnamiese"),
        dictgen::InsensitiveStr::Ascii("tnamnese"),
        dictgen::InsensitiveStr::Ascii("weres"),
        dictgen::InsensitiveStr::Ascii("wpiont"),
        dictgen::InsensitiveStr::Ascii("wpionts"),
        dictgen::InsensitiveStr::Ascii("wpoert"),
        dictgen::InsensitiveStr::Ascii("wpoit"),
        dictgen::InsensitiveStr::Ascii("wtransfromation"),
    ],
    values: &[
        &["view"],
        &["views"],
        &["vietnam"],
        &["vietnamese"],
        &["viewport"],
        &["viewports"],
        &["vietnamese"],
        &["vietnamese"],
        &["vietnamese"],
        &["vietnamese"],
        &["vietnamese"],
        &["vietnamese"],
        &["vietnamese"],
        &["viewers"],
        &["viewpoint"],
        &["viewpoints"],
        &["viewport"],
        &["viewpoints"],
        &["viewtransformation"],
    ],
    range: 1..=15,
};

static WORD_VID_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_VID_CHILDREN),
    value: None,
};

pub static WORD_VID_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eogaem"),
        dictgen::InsensitiveStr::Ascii("eogaems"),
        dictgen::InsensitiveStr::Ascii("eogamemes"),
        dictgen::InsensitiveStr::Ascii("eogams"),
        dictgen::InsensitiveStr::Ascii("eojames"),
        dictgen::InsensitiveStr::Ascii("eostreamming"),
        dictgen::InsensitiveStr::Ascii("oegame"),
        dictgen::InsensitiveStr::Ascii("oegames"),
    ],
    values: &[
        &["videogame"],
        &["videogames"],
        &["videogames"],
        &["videogames"],
        &["videogames"],
        &["videostreaming"],
        &["videogame"],
        &["videogames"],
    ],
    range: 6..=12,
};

static WORD_VIC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_VIC_CHILDREN),
    value: None,
};

pub static WORD_VIC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("intiy"),
        dictgen::InsensitiveStr::Ascii("itmized"),
        dictgen::InsensitiveStr::Ascii("itms"),
        dictgen::InsensitiveStr::Ascii("otrian"),
        dictgen::InsensitiveStr::Ascii("otries"),
        dictgen::InsensitiveStr::Ascii("otrious"),
        dictgen::InsensitiveStr::Ascii("seral"),
        dictgen::InsensitiveStr::Ascii("tem"),
        dictgen::InsensitiveStr::Ascii("temize"),
        dictgen::InsensitiveStr::Ascii("temized"),
        dictgen::InsensitiveStr::Ascii("temizes"),
        dictgen::InsensitiveStr::Ascii("temizing"),
        dictgen::InsensitiveStr::Ascii("tems"),
        dictgen::InsensitiveStr::Ascii("timas"),
        dictgen::InsensitiveStr::Ascii("times"),
        dictgen::InsensitiveStr::Ascii("toires"),
        dictgen::InsensitiveStr::Ascii("tomized"),
        dictgen::InsensitiveStr::Ascii("torain"),
        dictgen::InsensitiveStr::Ascii("torieuse"),
        dictgen::InsensitiveStr::Ascii("torin"),
        dictgen::InsensitiveStr::Ascii("torina"),
        dictgen::InsensitiveStr::Ascii("torinos"),
        dictgen::InsensitiveStr::Ascii("torinus"),
        dictgen::InsensitiveStr::Ascii("torios"),
        dictgen::InsensitiveStr::Ascii("toriosa"),
        dictgen::InsensitiveStr::Ascii("torioso"),
        dictgen::InsensitiveStr::Ascii("toris"),
        dictgen::InsensitiveStr::Ascii("toriuos"),
        dictgen::InsensitiveStr::Ascii("toriuous"),
        dictgen::InsensitiveStr::Ascii("tum"),
        dictgen::InsensitiveStr::Ascii("tumized"),
        dictgen::InsensitiveStr::Ascii("tums"),
    ],
    values: &[
        &["vicinity"],
        &["victimized"],
        &["victims"],
        &["victorian"],
        &["victories"],
        &["victorious"],
        &["visceral"],
        &["victim"],
        &["victimize"],
        &["victimized"],
        &["victimizes"],
        &["victimizing"],
        &["victims"],
        &["victims"],
        &["victims"],
        &["victories"],
        &["victimized"],
        &["victorian"],
        &["victories"],
        &["victorian"],
        &["victorian"],
        &["victorious"],
        &["victorious"],
        &["victorious"],
        &["victorious"],
        &["victorious"],
        &["victories"],
        &["victorious"],
        &["victorious"],
        &["victim"],
        &["victimized"],
        &["victims"],
    ],
    range: 3..=8,
};

static WORD_VIB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_VIB_CHILDREN),
    value: None,
};

pub static WORD_VIB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ratie"),
        dictgen::InsensitiveStr::Ascii("ratin"),
        dictgen::InsensitiveStr::Ascii("ratoare"),
        dictgen::InsensitiveStr::Ascii("ratr"),
    ],
    values: &[&["vibrate"], &["vibration"], &["vibrator"], &["vibrator"]],
    range: 4..=7,
};

static WORD_VIA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_VIA_CHILDREN),
    value: None,
};

pub static WORD_VIA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("biliy"),
        dictgen::InsensitiveStr::Ascii("riable"),
        dictgen::InsensitiveStr::Ascii("tmin"),
        dictgen::InsensitiveStr::Ascii("tmins"),
        dictgen::InsensitiveStr::Ascii("tnamese"),
    ],
    values: &[
        &["viability"],
        &["variable"],
        &["vitamin"],
        &["vitamins"],
        &["vietnamese"],
    ],
    range: 4..=7,
};

static WORD_VH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_VH_CHILDREN),
    value: None,
};

pub static WORD_VH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ild")],
    values: &[&["child"]],
    range: 3..=3,
};

static WORD_VE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_VE_CHILDREN),
    value: None,
};

static WORD_VE_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_VEA_NODE),
    Some(&WORD_VEB_NODE),
    Some(&WORD_VEC_NODE),
    Some(&WORD_VED_NODE),
    None,
    Some(&WORD_VEF_NODE),
    Some(&WORD_VEG_NODE),
    Some(&WORD_VEH_NODE),
    Some(&WORD_VEI_NODE),
    None,
    Some(&WORD_VEK_NODE),
    Some(&WORD_VEL_NODE),
    None,
    Some(&WORD_VEN_NODE),
    None,
    None,
    None,
    Some(&WORD_VER_NODE),
    Some(&WORD_VES_NODE),
    Some(&WORD_VET_NODE),
    None,
    None,
    Some(&WORD_VEW_NODE),
    None,
    Some(&WORD_VEY_NODE),
    None,
];

static WORD_VEY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_VEY_CHILDREN),
    value: None,
};

pub static WORD_VEY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("r")],
    values: &[&["very"]],
    range: 1..=1,
};

static WORD_VEW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_VEW_CHILDREN),
    value: Some(&["view"]),
};

pub static WORD_VEW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("iership")],
    values: &[&["viewership"]],
    range: 7..=7,
};

static WORD_VET_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_VET_CHILDREN),
    value: None,
};

pub static WORD_VET_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ex"),
        dictgen::InsensitiveStr::Ascii("exes"),
        dictgen::InsensitiveStr::Ascii("inarian"),
        dictgen::InsensitiveStr::Ascii("inarians"),
        dictgen::InsensitiveStr::Ascii("od"),
        dictgen::InsensitiveStr::Ascii("or"),
        dictgen::InsensitiveStr::Ascii("ored"),
        dictgen::InsensitiveStr::Ascii("oring"),
        dictgen::InsensitiveStr::Ascii("ors"),
        dictgen::InsensitiveStr::Ascii("ran"),
        dictgen::InsensitiveStr::Ascii("rans"),
        dictgen::InsensitiveStr::Ascii("ween"),
    ],
    values: &[
        &["vertex"],
        &["vertices"],
        &["veterinarian"],
        &["veterinarians"],
        &["vetoed"],
        &["vector", "veto"],
        &["vectored", "vetoed"],
        &["vectoring", "vetoing"],
        &["vectors", "vetoes"],
        &["veteran"],
        &["veterans"],
        &["between"],
    ],
    range: 2..=8,
};

static WORD_VES_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_VES_CHILDREN),
    value: None,
};

pub static WORD_VES_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ion"),
        dictgen::InsensitiveStr::Ascii("ions"),
        dictgen::InsensitiveStr::Ascii("seles"),
        dictgen::InsensitiveStr::Ascii("sells"),
        dictgen::InsensitiveStr::Ascii("sles"),
    ],
    values: &[
        &["version"],
        &["versions"],
        &["vessels"],
        &["vessels"],
        &["vessels"],
    ],
    range: 3..=5,
};

static WORD_VER_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_VER_CHILDREN),
    value: None,
};

static WORD_VER_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_VERA_NODE),
    Some(&WORD_VERB_NODE),
    Some(&WORD_VERC_NODE),
    None,
    Some(&WORD_VERE_NODE),
    Some(&WORD_VERF_NODE),
    None,
    None,
    Some(&WORD_VERI_NODE),
    None,
    None,
    Some(&WORD_VERL_NODE),
    Some(&WORD_VERM_NODE),
    Some(&WORD_VERN_NODE),
    None,
    None,
    None,
    Some(&WORD_VERR_NODE),
    Some(&WORD_VERS_NODE),
    Some(&WORD_VERT_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_VERY_NODE),
    None,
];

static WORD_VERY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_VERY_CHILDREN),
    value: None,
};

pub static WORD_VERY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("fieng"),
        dictgen::InsensitiveStr::Ascii("fing"),
        dictgen::InsensitiveStr::Ascii("fy"),
        dictgen::InsensitiveStr::Ascii("fying"),
        dictgen::InsensitiveStr::Ascii("ified"),
        dictgen::InsensitiveStr::Ascii("ifies"),
        dictgen::InsensitiveStr::Ascii("ifing"),
        dictgen::InsensitiveStr::Ascii("ify"),
        dictgen::InsensitiveStr::Ascii("ifying"),
    ],
    values: &[
        &["verifying"],
        &["verifying"],
        &["verify"],
        &["verifying"],
        &["verified"],
        &["verifies"],
        &["verifying"],
        &["verify"],
        &["verifying"],
    ],
    range: 2..=6,
};

static WORD_VERT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_VERT_CHILDREN),
    value: None,
};

pub static WORD_VERT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("abim"),
        dictgen::InsensitiveStr::Ascii("abraes"),
        dictgen::InsensitiveStr::Ascii("abray"),
        dictgen::InsensitiveStr::Ascii("abrays"),
        dictgen::InsensitiveStr::Ascii("exes"),
        dictgen::InsensitiveStr::Ascii("extes"),
        dictgen::InsensitiveStr::Ascii("exts"),
        dictgen::InsensitiveStr::Ascii("gio"),
        dictgen::InsensitiveStr::Ascii("ial"),
        dictgen::InsensitiveStr::Ascii("icall"),
        dictgen::InsensitiveStr::Ascii("icallity"),
        dictgen::InsensitiveStr::Ascii("icaly"),
        dictgen::InsensitiveStr::Ascii("icies"),
        dictgen::InsensitiveStr::Ascii("icla"),
        dictgen::InsensitiveStr::Ascii("icle"),
        dictgen::InsensitiveStr::Ascii("iclealign"),
        dictgen::InsensitiveStr::Ascii("icles"),
        dictgen::InsensitiveStr::Ascii("iece"),
        dictgen::InsensitiveStr::Ascii("ieces"),
        dictgen::InsensitiveStr::Ascii("ifiable"),
        dictgen::InsensitiveStr::Ascii("ification"),
        dictgen::InsensitiveStr::Ascii("ifications"),
        dictgen::InsensitiveStr::Ascii("ify"),
        dictgen::InsensitiveStr::Ascii("igro"),
        dictgen::InsensitiveStr::Ascii("ikal"),
        dictgen::InsensitiveStr::Ascii("ix"),
        dictgen::InsensitiveStr::Ascii("ixes"),
        dictgen::InsensitiveStr::Ascii("ixs"),
        dictgen::InsensitiveStr::Ascii("x"),
    ],
    values: &[
        &["verbatim"],
        &["vertebraes"],
        &["vertebrae"],
        &["vertebraes"],
        &["vertices"],
        &["vertices"],
        &["vertices"],
        &["vertigo"],
        &["vertical"],
        &["vertical"],
        &["vertically"],
        &["vertically"],
        &["vertices"],
        &["vertical"],
        &["vertical"],
        &["verticalalign"],
        &["verticals"],
        &["vertex"],
        &["vertices"],
        &["verifiable"],
        &["certification", "verification"],
        &["verifications"],
        &["verify"],
        &["vertigo"],
        &["vertical"],
        &["vertex"],
        &["vertices"],
        &["vertices"],
        &["vertex"],
    ],
    range: 1..=10,
};

static WORD_VERS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_VERS_CHILDREN),
    value: None,
};

pub static WORD_VERS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("alite"),
        dictgen::InsensitiveStr::Ascii("atality"),
        dictgen::InsensitiveStr::Ascii("atel"),
        dictgen::InsensitiveStr::Ascii("atiliy"),
        dictgen::InsensitiveStr::Ascii("atille"),
        dictgen::InsensitiveStr::Ascii("atillity"),
        dictgen::InsensitiveStr::Ascii("atilty"),
        dictgen::InsensitiveStr::Ascii("atily"),
        dictgen::InsensitiveStr::Ascii("atle"),
        dictgen::InsensitiveStr::Ascii("hin"),
        dictgen::InsensitiveStr::Ascii("in"),
        dictgen::InsensitiveStr::Ascii("ino"),
        dictgen::InsensitiveStr::Ascii("inos"),
        dictgen::InsensitiveStr::Ascii("ins"),
        dictgen::InsensitiveStr::Ascii("io"),
        dictgen::InsensitiveStr::Ascii("iob"),
        dictgen::InsensitiveStr::Ascii("ioed"),
        dictgen::InsensitiveStr::Ascii("ioing"),
        dictgen::InsensitiveStr::Ascii("iom"),
        dictgen::InsensitiveStr::Ascii("ionaddded"),
        dictgen::InsensitiveStr::Ascii("iones"),
        dictgen::InsensitiveStr::Ascii("ionm"),
        dictgen::InsensitiveStr::Ascii("ionms"),
        dictgen::InsensitiveStr::Ascii("ionned"),
        dictgen::InsensitiveStr::Ascii("ionning"),
        dictgen::InsensitiveStr::Ascii("ios"),
        dictgen::InsensitiveStr::Ascii("ital"),
        dictgen::InsensitiveStr::Ascii("itale"),
        dictgen::InsensitiveStr::Ascii("itality"),
        dictgen::InsensitiveStr::Ascii("itilaty"),
        dictgen::InsensitiveStr::Ascii("itile"),
        dictgen::InsensitiveStr::Ascii("itle"),
        dictgen::InsensitiveStr::Ascii("itlity"),
        dictgen::InsensitiveStr::Ascii("oin"),
        dictgen::InsensitiveStr::Ascii("oion"),
        dictgen::InsensitiveStr::Ascii("oions"),
        dictgen::InsensitiveStr::Ascii("on"),
        dictgen::InsensitiveStr::Ascii("oned"),
        dictgen::InsensitiveStr::Ascii("ons"),
        dictgen::InsensitiveStr::Ascii("taile"),
    ],
    values: &[
        &["versatile"],
        &["versatility"],
        &["versatile"],
        &["versatility"],
        &["versatile"],
        &["versatility"],
        &["versatility"],
        &["versatility"],
        &["versatile"],
        &["version"],
        &["version"],
        &["version"],
        &["versions"],
        &["versions"],
        &["version"],
        &["version"],
        &["versioned"],
        &["versioning"],
        &["version"],
        &["versionadded"],
        &["versions"],
        &["version"],
        &["versions"],
        &["versioned"],
        &["versioning"],
        &["versions"],
        &["versatile"],
        &["versatile"],
        &["versatility"],
        &["versatility"],
        &["versatile"],
        &["versatile"],
        &["versatility"],
        &["version"],
        &["version"],
        &["versions"],
        &["version"],
        &["versioned"],
        &["versions"],
        &["versatile"],
    ],
    range: 2..=9,
};

static WORD_VERR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_VERR_CHILDREN),
    value: None,
};

pub static WORD_VERR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ical"),
        dictgen::InsensitiveStr::Ascii("y"),
    ],
    values: &[&["vertical"], &["very"]],
    range: 1..=4,
};

static WORD_VERN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_VERN_CHILDREN),
    value: None,
};

pub static WORD_VERN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aculaire"),
        dictgen::InsensitiveStr::Ascii("dor"),
        dictgen::InsensitiveStr::Ascii("ecular"),
        dictgen::InsensitiveStr::Ascii("icular"),
    ],
    values: &[
        &["vernacular"],
        &["vendor"],
        &["vernacular"],
        &["vernacular"],
    ],
    range: 3..=8,
};

static WORD_VERM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_VERM_CHILDREN),
    value: None,
};

pub static WORD_VERM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("en"),
        dictgen::InsensitiveStr::Ascii("uth"),
    ],
    values: &[&["vermin"], &["vermouth"]],
    range: 2..=3,
};

static WORD_VERL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_VERL_CHILDREN),
    value: None,
};

pub static WORD_VERL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("y")],
    values: &[&["very"]],
    range: 1..=1,
};

static WORD_VERI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_VERI_CHILDREN),
    value: None,
};

pub static WORD_VERI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("able"),
        dictgen::InsensitiveStr::Ascii("ables"),
        dictgen::InsensitiveStr::Ascii("asion"),
        dictgen::InsensitiveStr::Ascii("asions"),
        dictgen::InsensitiveStr::Ascii("ation"),
        dictgen::InsensitiveStr::Ascii("ations"),
        dictgen::InsensitiveStr::Ascii("cal"),
        dictgen::InsensitiveStr::Ascii("cally"),
        dictgen::InsensitiveStr::Ascii("cation"),
        dictgen::InsensitiveStr::Ascii("cations"),
        dictgen::InsensitiveStr::Ascii("fcation"),
        dictgen::InsensitiveStr::Ascii("fcations"),
        dictgen::InsensitiveStr::Ascii("fer"),
        dictgen::InsensitiveStr::Ascii("fi"),
        dictgen::InsensitiveStr::Ascii("fiaction"),
        dictgen::InsensitiveStr::Ascii("fiactions"),
        dictgen::InsensitiveStr::Ascii("ficacion"),
        dictgen::InsensitiveStr::Ascii("ficaion"),
        dictgen::InsensitiveStr::Ascii("ficaions"),
        dictgen::InsensitiveStr::Ascii("ficaiton"),
        dictgen::InsensitiveStr::Ascii("ficato"),
        dictgen::InsensitiveStr::Ascii("ficiation"),
        dictgen::InsensitiveStr::Ascii("ficiations"),
        dictgen::InsensitiveStr::Ascii("fie"),
        dictgen::InsensitiveStr::Ascii("fieing"),
        dictgen::InsensitiveStr::Ascii("fikation"),
        dictgen::InsensitiveStr::Ascii("fing"),
        dictgen::InsensitiveStr::Ascii("fiy"),
        dictgen::InsensitiveStr::Ascii("fiying"),
        dictgen::InsensitiveStr::Ascii("fiyng"),
        dictgen::InsensitiveStr::Ascii("fty"),
        dictgen::InsensitiveStr::Ascii("ftying"),
        dictgen::InsensitiveStr::Ascii("fyable"),
        dictgen::InsensitiveStr::Ascii("fyied"),
        dictgen::InsensitiveStr::Ascii("gated"),
        dictgen::InsensitiveStr::Ascii("on"),
        dictgen::InsensitiveStr::Ascii("ons"),
        dictgen::InsensitiveStr::Ascii("osn"),
        dictgen::InsensitiveStr::Ascii("osns"),
        dictgen::InsensitiveStr::Ascii("ous"),
        dictgen::InsensitiveStr::Ascii("sion"),
        dictgen::InsensitiveStr::Ascii("sions"),
        dictgen::InsensitiveStr::Ascii("son"),
        dictgen::InsensitiveStr::Ascii("soned"),
        dictgen::InsensitiveStr::Ascii("soner"),
        dictgen::InsensitiveStr::Ascii("soners"),
        dictgen::InsensitiveStr::Ascii("soning"),
        dictgen::InsensitiveStr::Ascii("sons"),
        dictgen::InsensitiveStr::Ascii("tcal"),
        dictgen::InsensitiveStr::Ascii("tcally"),
        dictgen::InsensitiveStr::Ascii("tgo"),
        dictgen::InsensitiveStr::Ascii("tiable"),
        dictgen::InsensitiveStr::Ascii("tical"),
    ],
    values: &[
        &["variable", "veritable"],
        &["variables"],
        &["variation"],
        &["variations"],
        &["variation"],
        &["variations"],
        &["vertical"],
        &["vertically"],
        &["verification"],
        &["verifications"],
        &["verification"],
        &["verifications"],
        &["verifier"],
        &["verify", "verified"],
        &["verification"],
        &["verifications"],
        &["verification"],
        &["verification"],
        &["verifications"],
        &["verification"],
        &["verification"],
        &["verification"],
        &["verifications"],
        &["verify", "verified"],
        &["verifying"],
        &["verification"],
        &["verifying"],
        &["verify"],
        &["verifying"],
        &["verifying"],
        &["verify"],
        &["verifying"],
        &["verifiable"],
        &["verified"],
        &["variegated"],
        &["version"],
        &["versions"],
        &["version"],
        &["versions"],
        &["various"],
        &["version"],
        &["revisions"],
        &["version"],
        &["versioned"],
        &["versioner"],
        &["versioners"],
        &["versioning"],
        &["versions"],
        &["vertical"],
        &["vertically"],
        &["vertigo"],
        &["verifiable"],
        &["vertical"],
    ],
    range: 2..=10,
};

static WORD_VERF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_VERF_CHILDREN),
    value: None,
};

pub static WORD_VERF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ication"),
        dictgen::InsensitiveStr::Ascii("iciation"),
        dictgen::InsensitiveStr::Ascii("ier"),
        dictgen::InsensitiveStr::Ascii("ies"),
        dictgen::InsensitiveStr::Ascii("ifiable"),
        dictgen::InsensitiveStr::Ascii("ification"),
        dictgen::InsensitiveStr::Ascii("ifications"),
        dictgen::InsensitiveStr::Ascii("ified"),
        dictgen::InsensitiveStr::Ascii("ifier"),
        dictgen::InsensitiveStr::Ascii("ifiers"),
        dictgen::InsensitiveStr::Ascii("ifies"),
        dictgen::InsensitiveStr::Ascii("ify"),
        dictgen::InsensitiveStr::Ascii("ifying"),
        dictgen::InsensitiveStr::Ascii("ires"),
        dictgen::InsensitiveStr::Ascii("iy"),
        dictgen::InsensitiveStr::Ascii("iying"),
        dictgen::InsensitiveStr::Ascii("y"),
        dictgen::InsensitiveStr::Ascii("ying"),
    ],
    values: &[
        &["verification"],
        &["verification"],
        &["verifier"],
        &["verifies"],
        &["verifiable"],
        &["verification"],
        &["verifications"],
        &["verified"],
        &["verifier"],
        &["verifiers"],
        &["verifies"],
        &["verify"],
        &["verifying"],
        &["verifies"],
        &["verify"],
        &["verifying"],
        &["verify"],
        &["verifying"],
    ],
    range: 1..=10,
};

static WORD_VERE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_VERE_CHILDREN),
    value: None,
};

pub static WORD_VERE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("gated"),
        dictgen::InsensitiveStr::Ascii("igated"),
        dictgen::InsensitiveStr::Ascii("sion"),
        dictgen::InsensitiveStr::Ascii("sions"),
    ],
    values: &[
        &["variegated"],
        &["variegated"],
        &["version"],
        &["versions"],
    ],
    range: 4..=6,
};

static WORD_VERC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_VERC_CHILDREN),
    value: None,
};

pub static WORD_VERC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("hew"),
        dictgen::InsensitiveStr::Ascii("hews"),
        dictgen::InsensitiveStr::Ascii("tor"),
        dictgen::InsensitiveStr::Ascii("tors"),
    ],
    values: &[&["virtue"], &["virtues"], &["vector"], &["vectors"]],
    range: 3..=4,
};

static WORD_VERB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_VERB_CHILDREN),
    value: None,
};

pub static WORD_VERB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("age"),
        dictgen::InsensitiveStr::Ascii("aitm"),
        dictgen::InsensitiveStr::Ascii("aly"),
        dictgen::InsensitiveStr::Ascii("atium"),
        dictgen::InsensitiveStr::Ascii("atum"),
        dictgen::InsensitiveStr::Ascii("oase"),
        dictgen::InsensitiveStr::Ascii("oce"),
        dictgen::InsensitiveStr::Ascii("ode"),
        dictgen::InsensitiveStr::Ascii("ous"),
        dictgen::InsensitiveStr::Ascii("ouse"),
        dictgen::InsensitiveStr::Ascii("ously"),
        dictgen::InsensitiveStr::Ascii("se"),
    ],
    values: &[
        &["verbiage"],
        &["verbatim"],
        &["verbally"],
        &["verbatim"],
        &["verbatim"],
        &["verbose"],
        &["verbose"],
        &["verbose"],
        &["verbose"],
        &["verbose"],
        &["verbosely"],
        &["verbose"],
    ],
    range: 2..=5,
};

static WORD_VERA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_VERA_CHILDREN),
    value: None,
};

pub static WORD_VERA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("blly"),
        dictgen::InsensitiveStr::Ascii("gated"),
        dictgen::InsensitiveStr::Ascii("stility"),
    ],
    values: &[&["verbally"], &["variegated"], &["versatility"]],
    range: 4..=7,
};

static WORD_VEN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_VEN_CHILDREN),
    value: None,
};

pub static WORD_VEN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("deta"),
        dictgen::InsensitiveStr::Ascii("dettta"),
        dictgen::InsensitiveStr::Ascii("egance"),
        dictgen::InsensitiveStr::Ascii("elope"),
        dictgen::InsensitiveStr::Ascii("emous"),
        dictgen::InsensitiveStr::Ascii("euzela"),
        dictgen::InsensitiveStr::Ascii("ezeula"),
        dictgen::InsensitiveStr::Ascii("ezuelean"),
        dictgen::InsensitiveStr::Ascii("ezuelian"),
        dictgen::InsensitiveStr::Ascii("ezuella"),
        dictgen::InsensitiveStr::Ascii("ezulea"),
        dictgen::InsensitiveStr::Ascii("gaence"),
        dictgen::InsensitiveStr::Ascii("gance"),
        dictgen::InsensitiveStr::Ascii("genace"),
        dictgen::InsensitiveStr::Ascii("gence"),
        dictgen::InsensitiveStr::Ascii("talation"),
        dictgen::InsensitiveStr::Ascii("telation"),
        dictgen::InsensitiveStr::Ascii("tialtion"),
        dictgen::InsensitiveStr::Ascii("tilacion"),
        dictgen::InsensitiveStr::Ascii("tilato"),
        dictgen::InsensitiveStr::Ascii("tillate"),
        dictgen::InsensitiveStr::Ascii("tillated"),
        dictgen::InsensitiveStr::Ascii("tillates"),
        dictgen::InsensitiveStr::Ascii("tillating"),
        dictgen::InsensitiveStr::Ascii("yet"),
        dictgen::InsensitiveStr::Ascii("yets"),
    ],
    values: &[
        &["vendetta"],
        &["vendetta"],
        &["vengeance"],
        &["envelope"],
        &["venomous"],
        &["venezuela"],
        &["venezuela"],
        &["venezuela"],
        &["venezuela"],
        &["venezuela"],
        &["venezuela"],
        &["vengeance"],
        &["vengeance"],
        &["vengeance"],
        &["vengeance"],
        &["ventilation"],
        &["ventilation"],
        &["ventilation"],
        &["ventilation"],
        &["ventilation"],
        &["ventilate"],
        &["ventilated"],
        &["ventilates"],
        &["ventilating"],
        &["vignette"],
        &["vignettes"],
    ],
    range: 3..=9,
};

static WORD_VEL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_VEL_CHILDREN),
    value: None,
};

pub static WORD_VEL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("antine"),
        dictgen::InsensitiveStr::Ascii("city"),
        dictgen::InsensitiveStr::Ascii("idate"),
        dictgen::InsensitiveStr::Ascii("l"),
        dictgen::InsensitiveStr::Ascii("ociries"),
        dictgen::InsensitiveStr::Ascii("ociry"),
    ],
    values: &[
        &["valentine"],
        &["velocity"],
        &["validate"],
        &["well"],
        &["velocities"],
        &["velocity"],
    ],
    range: 1..=7,
};

static WORD_VEK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_VEK_CHILDREN),
    value: None,
};

pub static WORD_VEK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("tor"),
        dictgen::InsensitiveStr::Ascii("tors"),
    ],
    values: &[&["vector"], &["vectors"]],
    range: 3..=4,
};

static WORD_VEI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_VEI_CHILDREN),
    value: None,
};

pub static WORD_VEI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("chles"),
        dictgen::InsensitiveStr::Ascii("cle"),
        dictgen::InsensitiveStr::Ascii("cles"),
        dictgen::InsensitiveStr::Ascii("fy"),
        dictgen::InsensitiveStr::Ascii("tnam"),
        dictgen::InsensitiveStr::Ascii("tnamese"),
        dictgen::InsensitiveStr::Ascii("w"),
        dictgen::InsensitiveStr::Ascii("wed"),
        dictgen::InsensitiveStr::Ascii("wer"),
        dictgen::InsensitiveStr::Ascii("wers"),
        dictgen::InsensitiveStr::Ascii("wership"),
        dictgen::InsensitiveStr::Ascii("wing"),
        dictgen::InsensitiveStr::Ascii("wings"),
        dictgen::InsensitiveStr::Ascii("wpoint"),
        dictgen::InsensitiveStr::Ascii("wpoints"),
        dictgen::InsensitiveStr::Ascii("ws"),
    ],
    values: &[
        &["vehicles"],
        &["vehicle"],
        &["vehicles"],
        &["verify"],
        &["vietnam"],
        &["vietnamese"],
        &["view"],
        &["viewed"],
        &["viewer"],
        &["viewers"],
        &["viewership"],
        &["viewing"],
        &["viewings"],
        &["viewpoint"],
        &["viewpoints"],
        &["views"],
    ],
    range: 1..=7,
};

static WORD_VEH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_VEH_CHILDREN),
    value: None,
};

pub static WORD_VEH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ciles"),
        dictgen::InsensitiveStr::Ascii("emantly"),
        dictgen::InsensitiveStr::Ascii("ementely"),
        dictgen::InsensitiveStr::Ascii("ementy"),
        dictgen::InsensitiveStr::Ascii("emontly"),
        dictgen::InsensitiveStr::Ascii("icels"),
        dictgen::InsensitiveStr::Ascii("icule"),
    ],
    values: &[
        &["vehicles"],
        &["vehemently"],
        &["vehemently"],
        &["vehemently"],
        &["vehemently"],
        &["vehicles"],
        &["vehicle"],
    ],
    range: 5..=8,
};

static WORD_VEG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_VEG_CHILDREN),
    value: None,
};

pub static WORD_VEG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("anisim"),
        dictgen::InsensitiveStr::Ascii("ansim"),
        dictgen::InsensitiveStr::Ascii("atarian"),
        dictgen::InsensitiveStr::Ascii("aterian"),
        dictgen::InsensitiveStr::Ascii("aterians"),
        dictgen::InsensitiveStr::Ascii("eratian"),
        dictgen::InsensitiveStr::Ascii("etairan"),
        dictgen::InsensitiveStr::Ascii("etarain"),
        dictgen::InsensitiveStr::Ascii("etarianas"),
        dictgen::InsensitiveStr::Ascii("etarianos"),
        dictgen::InsensitiveStr::Ascii("etarien"),
        dictgen::InsensitiveStr::Ascii("etariens"),
        dictgen::InsensitiveStr::Ascii("etarin"),
        dictgen::InsensitiveStr::Ascii("etarion"),
        dictgen::InsensitiveStr::Ascii("etarions"),
        dictgen::InsensitiveStr::Ascii("etatian"),
        dictgen::InsensitiveStr::Ascii("etatians"),
        dictgen::InsensitiveStr::Ascii("eterian"),
        dictgen::InsensitiveStr::Ascii("eterians"),
        dictgen::InsensitiveStr::Ascii("itable"),
        dictgen::InsensitiveStr::Ascii("itables"),
        dictgen::InsensitiveStr::Ascii("itarian"),
        dictgen::InsensitiveStr::Ascii("itarians"),
        dictgen::InsensitiveStr::Ascii("itarien"),
        dictgen::InsensitiveStr::Ascii("itariens"),
        dictgen::InsensitiveStr::Ascii("itarion"),
        dictgen::InsensitiveStr::Ascii("itarions"),
        dictgen::InsensitiveStr::Ascii("table"),
    ],
    values: &[
        &["veganism"],
        &["veganism"],
        &["vegetarian"],
        &["vegetarian"],
        &["vegetarians"],
        &["vegetarians"],
        &["vegetarians"],
        &["vegetarians"],
        &["vegetarians"],
        &["vegetarians"],
        &["vegetarian"],
        &["vegetarians"],
        &["vegetarians"],
        &["vegetarian"],
        &["vegetarians"],
        &["vegetarian"],
        &["vegetarians"],
        &["vegetarian"],
        &["vegetarians"],
        &["vegetable"],
        &["vegetables"],
        &["vegetarian"],
        &["vegetarians"],
        &["vegetarian"],
        &["vegetarians"],
        &["vegetarian"],
        &["vegetarians"],
        &["vegetable"],
    ],
    range: 5..=9,
};

static WORD_VEF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_VEF_CHILDREN),
    value: None,
};

pub static WORD_VEF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("iry")],
    values: &[&["verify"]],
    range: 3..=3,
};

static WORD_VED_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_VED_CHILDREN),
    value: None,
};

pub static WORD_VED_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("io")],
    values: &[&["video"]],
    range: 2..=2,
};

static WORD_VEC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_VEC_CHILDREN),
    value: None,
};

pub static WORD_VEC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("hiles"),
        dictgen::InsensitiveStr::Ascii("otor"),
        dictgen::InsensitiveStr::Ascii("otr"),
        dictgen::InsensitiveStr::Ascii("otrs"),
        dictgen::InsensitiveStr::Ascii("tices"),
        dictgen::InsensitiveStr::Ascii("tore"),
        dictgen::InsensitiveStr::Ascii("tores"),
        dictgen::InsensitiveStr::Ascii("torr"),
        dictgen::InsensitiveStr::Ascii("torrs"),
        dictgen::InsensitiveStr::Ascii("torss"),
        dictgen::InsensitiveStr::Ascii("tror"),
        dictgen::InsensitiveStr::Ascii("trors"),
        dictgen::InsensitiveStr::Ascii("tros"),
        dictgen::InsensitiveStr::Ascii("vtor"),
        dictgen::InsensitiveStr::Ascii("vtors"),
    ],
    values: &[
        &["vehicles"],
        &["vector"],
        &["vector"],
        &["vectors"],
        &["vertices"],
        &["vector"],
        &["vectors"],
        &["vector"],
        &["vectors"],
        &["vectors"],
        &["vector"],
        &["vectors"],
        &["vectors"],
        &["vector"],
        &["vectors"],
    ],
    range: 3..=5,
};

static WORD_VEB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_VEB_CHILDREN),
    value: None,
};

pub static WORD_VEB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("rose")],
    values: &[&["verbose"]],
    range: 4..=4,
};

static WORD_VEA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_VEA_CHILDREN),
    value: None,
};

pub static WORD_VEA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("mant"),
        dictgen::InsensitiveStr::Ascii("mantly"),
    ],
    values: &[&["vehement"], &["vehemently"]],
    range: 4..=6,
};

static WORD_VB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_VB_CHILDREN),
    value: None,
};

pub static WORD_VB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("srcript")],
    values: &[&["vbscript"]],
    range: 7..=7,
};

static WORD_VA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_VA_CHILDREN),
    value: None,
};

static WORD_VA_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_VAA_NODE),
    None,
    Some(&WORD_VAC_NODE),
    None,
    Some(&WORD_VAE_NODE),
    None,
    Some(&WORD_VAG_NODE),
    None,
    Some(&WORD_VAI_NODE),
    None,
    Some(&WORD_VAK_NODE),
    Some(&WORD_VAL_NODE),
    Some(&WORD_VAM_NODE),
    Some(&WORD_VAN_NODE),
    None,
    None,
    None,
    Some(&WORD_VAR_NODE),
    Some(&WORD_VAS_NODE),
    Some(&WORD_VAT_NODE),
    Some(&WORD_VAU_NODE),
    Some(&WORD_VAV_NODE),
    Some(&WORD_VAW_NODE),
    None,
    Some(&WORD_VAY_NODE),
    None,
];

static WORD_VAY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_VAY_CHILDREN),
    value: None,
};

pub static WORD_VAY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("lkrie")],
    values: &[&["valkyrie"]],
    range: 5..=5,
};

static WORD_VAW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_VAW_CHILDREN),
    value: None,
};

pub static WORD_VAW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("dville"),
        dictgen::InsensitiveStr::Ascii("dvillean"),
        dictgen::InsensitiveStr::Ascii("dvillian"),
    ],
    values: &[&["vaudeville"], &["vaudevillian"], &["vaudevillian"]],
    range: 6..=8,
};

static WORD_VAV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_VAV_CHILDREN),
    value: None,
};

pub static WORD_VAV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("le"),
        dictgen::InsensitiveStr::Ascii("lue"),
        dictgen::InsensitiveStr::Ascii("riable"),
        dictgen::InsensitiveStr::Ascii("riables"),
    ],
    values: &[
        &["have", "valve"],
        &["valve"],
        &["value"],
        &["variable"],
        &["variables"],
    ],
    range: 1..=7,
};

static WORD_VAU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_VAU_CHILDREN),
    value: None,
};

pub static WORD_VAU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("gely"),
        dictgen::InsensitiveStr::Ascii("lable"),
        dictgen::InsensitiveStr::Ascii("le"),
        dictgen::InsensitiveStr::Ascii("led"),
        dictgen::InsensitiveStr::Ascii("les"),
        dictgen::InsensitiveStr::Ascii("ling"),
    ],
    values: &[
        &["value"],
        &["valued"],
        &["values"],
        &["vaguely"],
        &["valuable"],
        &["value"],
        &["valued"],
        &["values"],
        &["valuing"],
    ],
    range: 1..=5,
};

static WORD_VAT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_VAT_CHILDREN),
    value: None,
};

pub static WORD_VAT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("icaan"),
        dictgen::InsensitiveStr::Ascii("icina"),
    ],
    values: &[&["vatican"], &["vatican"]],
    range: 5..=5,
};

static WORD_VAS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_VAS_CHILDREN),
    value: Some(&["was"]),
};

pub static WORD_VAS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("all"),
        dictgen::InsensitiveStr::Ascii("alls"),
        dictgen::InsensitiveStr::Ascii("cetomy"),
        dictgen::InsensitiveStr::Ascii("ectomey"),
        dictgen::InsensitiveStr::Ascii("sales"),
        dictgen::InsensitiveStr::Ascii("salls"),
        dictgen::InsensitiveStr::Ascii("salos"),
        dictgen::InsensitiveStr::Ascii("slas"),
        dictgen::InsensitiveStr::Ascii("tecomy"),
    ],
    values: &[
        &["vassal"],
        &["vassals"],
        &["vasectomy"],
        &["vasectomy"],
        &["vassals"],
        &["vassals"],
        &["vassals"],
        &["vassals"],
        &["vasectomy"],
    ],
    range: 3..=7,
};

static WORD_VAR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_VAR_CHILDREN),
    value: None,
};

static WORD_VAR_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_VARA_NODE),
    None,
    None,
    None,
    Some(&WORD_VARE_NODE),
    None,
    None,
    None,
    Some(&WORD_VARI_NODE),
    None,
    None,
    None,
    Some(&WORD_VARM_NODE),
    Some(&WORD_VARN_NODE),
    Some(&WORD_VARO_NODE),
    None,
    None,
    Some(&WORD_VARR_NODE),
    Some(&WORD_VARS_NODE),
    Some(&WORD_VART_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_VART_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_VART_CHILDREN),
    value: Some(&["cart", "wart"]),
};

pub static WORD_VART_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ical"),
        dictgen::InsensitiveStr::Ascii("ically"),
        dictgen::InsensitiveStr::Ascii("s"),
    ],
    values: &[&["vertical"], &["vertically"], &["carts", "warts"]],
    range: 1..=6,
};

static WORD_VARS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_VARS_CHILDREN),
    value: None,
};

pub static WORD_VARS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("tiy")],
    values: &[&["varsity"]],
    range: 3..=3,
};

static WORD_VARR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_VARR_CHILDREN),
    value: None,
};

pub static WORD_VARR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("iance"),
        dictgen::InsensitiveStr::Ascii("iances"),
    ],
    values: &[&["variance"], &["variances"]],
    range: 5..=6,
};

static WORD_VARO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_VARO_CHILDREN),
    value: None,
};

pub static WORD_VARO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ius"),
        dictgen::InsensitiveStr::Ascii("us"),
        dictgen::InsensitiveStr::Ascii("usly"),
    ],
    values: &[&["various"], &["various"], &["variously"]],
    range: 2..=4,
};

static WORD_VARN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_VARN_CHILDREN),
    value: Some(&["warn"]),
};

pub static WORD_VARN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("ings"),
        dictgen::InsensitiveStr::Ascii("s"),
    ],
    values: &[&["warned"], &["warning"], &["warnings"], &["warns"]],
    range: 1..=4,
};

static WORD_VARM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_VARM_CHILDREN),
    value: None,
};

pub static WORD_VARM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("it"),
        dictgen::InsensitiveStr::Ascii("its"),
    ],
    values: &[&["varmint"], &["varmints"]],
    range: 2..=3,
};

static WORD_VARI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_VARI_CHILDREN),
    value: None,
};

pub static WORD_VARI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("abble"),
        dictgen::InsensitiveStr::Ascii("abbles"),
        dictgen::InsensitiveStr::Ascii("abe"),
        dictgen::InsensitiveStr::Ascii("abel"),
        dictgen::InsensitiveStr::Ascii("abele"),
        dictgen::InsensitiveStr::Ascii("abes"),
        dictgen::InsensitiveStr::Ascii("abl"),
        dictgen::InsensitiveStr::Ascii("abla"),
        dictgen::InsensitiveStr::Ascii("ablen"),
        dictgen::InsensitiveStr::Ascii("ablies"),
        dictgen::InsensitiveStr::Ascii("albe"),
        dictgen::InsensitiveStr::Ascii("albes"),
        dictgen::InsensitiveStr::Ascii("albles"),
        dictgen::InsensitiveStr::Ascii("ale"),
        dictgen::InsensitiveStr::Ascii("an"),
        dictgen::InsensitiveStr::Ascii("ans"),
        dictgen::InsensitiveStr::Ascii("antes"),
        dictgen::InsensitiveStr::Ascii("antions"),
        dictgen::InsensitiveStr::Ascii("atinos"),
        dictgen::InsensitiveStr::Ascii("ationnal"),
        dictgen::InsensitiveStr::Ascii("atoin"),
        dictgen::InsensitiveStr::Ascii("atoins"),
        dictgen::InsensitiveStr::Ascii("aty"),
        dictgen::InsensitiveStr::Ascii("avle"),
        dictgen::InsensitiveStr::Ascii("avles"),
        dictgen::InsensitiveStr::Ascii("bable"),
        dictgen::InsensitiveStr::Ascii("bables"),
        dictgen::InsensitiveStr::Ascii("bale"),
        dictgen::InsensitiveStr::Ascii("bales"),
        dictgen::InsensitiveStr::Ascii("baless"),
        dictgen::InsensitiveStr::Ascii("bel"),
        dictgen::InsensitiveStr::Ascii("bels"),
        dictgen::InsensitiveStr::Ascii("bility"),
        dictgen::InsensitiveStr::Ascii("blae"),
        dictgen::InsensitiveStr::Ascii("blaes"),
        dictgen::InsensitiveStr::Ascii("ble"),
        dictgen::InsensitiveStr::Ascii("bles"),
        dictgen::InsensitiveStr::Ascii("eable"),
        dictgen::InsensitiveStr::Ascii("eables"),
        dictgen::InsensitiveStr::Ascii("ence"),
        dictgen::InsensitiveStr::Ascii("ent"),
        dictgen::InsensitiveStr::Ascii("ents"),
        dictgen::InsensitiveStr::Ascii("erty"),
        dictgen::InsensitiveStr::Ascii("ey"),
        dictgen::InsensitiveStr::Ascii("fication"),
        dictgen::InsensitiveStr::Ascii("fications"),
        dictgen::InsensitiveStr::Ascii("fied"),
        dictgen::InsensitiveStr::Ascii("fies"),
        dictgen::InsensitiveStr::Ascii("fy"),
        dictgen::InsensitiveStr::Ascii("fying"),
        dictgen::InsensitiveStr::Ascii("gated"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("lue"),
        dictgen::InsensitiveStr::Ascii("lues"),
        dictgen::InsensitiveStr::Ascii("ng"),
        dictgen::InsensitiveStr::Ascii("sty"),
        dictgen::InsensitiveStr::Ascii("tey"),
        dictgen::InsensitiveStr::Ascii("ties"),
        dictgen::InsensitiveStr::Ascii("ty"),
        dictgen::InsensitiveStr::Ascii("uos"),
        dictgen::InsensitiveStr::Ascii("uous"),
        dictgen::InsensitiveStr::Ascii("us"),
    ],
    values: &[
        &["variable"],
        &["variables"],
        &["variable"],
        &["variable"],
        &["variable"],
        &["variables"],
        &["variable"],
        &["variable"],
        &["variable"],
        &["variables"],
        &["variable"],
        &["variables"],
        &["variables"],
        &["variable"],
        &["variant"],
        &["variants"],
        &["variants"],
        &["variations"],
        &["variations"],
        &["variational"],
        &["variation"],
        &["variations"],
        &["variety"],
        &["variable"],
        &["variables"],
        &["variable"],
        &["variables"],
        &["variable"],
        &["variables"],
        &["variables"],
        &["variable"],
        &["variables"],
        &["variability"],
        &["variable"],
        &["variables"],
        &["variable"],
        &["variables"],
        &["variable"],
        &["variables"],
        &["variance"],
        &["variant"],
        &["variants"],
        &["variety"],
        &["variety"],
        &["verification"],
        &["verifications"],
        &["verified"],
        &["verifies"],
        &["verify"],
        &["verifying"],
        &["variegated"],
        &["varying"],
        &["value", "variable"],
        &["values", "variables"],
        &["varying"],
        &["varsity"],
        &["variety"],
        &["varieties"],
        &["variety"],
        &["various"],
        &["various"],
        &["various"],
    ],
    range: 2..=9,
};

static WORD_VARE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_VARE_CHILDREN),
    value: None,
};

pub static WORD_VARE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("gated"),
        dictgen::InsensitiveStr::Ascii("igated"),
        dictgen::InsensitiveStr::Ascii("ity"),
    ],
    values: &[&["variegated"], &["variegated"], &["variety"]],
    range: 3..=6,
};

static WORD_VARA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_VARA_CHILDREN),
    value: None,
};

pub static WORD_VARA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ble"),
        dictgen::InsensitiveStr::Ascii("bles"),
        dictgen::InsensitiveStr::Ascii("gated"),
        dictgen::InsensitiveStr::Ascii("iable"),
        dictgen::InsensitiveStr::Ascii("iables"),
        dictgen::InsensitiveStr::Ascii("iance"),
        dictgen::InsensitiveStr::Ascii("iation"),
        dictgen::InsensitiveStr::Ascii("ible"),
        dictgen::InsensitiveStr::Ascii("ibles"),
        dictgen::InsensitiveStr::Ascii("int"),
        dictgen::InsensitiveStr::Ascii("ints"),
        dictgen::InsensitiveStr::Ascii("tion"),
        dictgen::InsensitiveStr::Ascii("tions"),
    ],
    values: &[
        &["variable"],
        &["variables"],
        &["variegated"],
        &["variable"],
        &["variables"],
        &["variance"],
        &["variation"],
        &["variable"],
        &["variables"],
        &["variant"],
        &["variants"],
        &["variation"],
        &["variations"],
    ],
    range: 3..=6,
};

static WORD_VAN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_VAN_CHILDREN),
    value: None,
};

pub static WORD_VAN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("adlism"),
        dictgen::InsensitiveStr::Ascii("dalisim"),
        dictgen::InsensitiveStr::Ascii("dalsim"),
        dictgen::InsensitiveStr::Ascii("guad"),
        dictgen::InsensitiveStr::Ascii("gurad"),
        dictgen::InsensitiveStr::Ascii("illia"),
        dictgen::InsensitiveStr::Ascii("illla"),
        dictgen::InsensitiveStr::Ascii("ishs"),
        dictgen::InsensitiveStr::Ascii("ugard"),
    ],
    values: &[
        &["vandalism"],
        &["vandalism"],
        &["vandalism"],
        &["vanguard"],
        &["vanguard"],
        &["vanilla"],
        &["vanilla"],
        &["vanishes"],
        &["vanguard"],
    ],
    range: 4..=7,
};

static WORD_VAM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_VAM_CHILDREN),
    value: None,
};

pub static WORD_VAM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ipres"),
        dictgen::InsensitiveStr::Ascii("piers"),
        dictgen::InsensitiveStr::Ascii("pirs"),
        dictgen::InsensitiveStr::Ascii("pries"),
    ],
    values: &[&["vampires"], &["vampires"], &["vampires"], &["vampires"]],
    range: 4..=5,
};

static WORD_VAL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_VAL_CHILDREN),
    value: None,
};

static WORD_VAL_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_VALA_NODE),
    None,
    None,
    Some(&WORD_VALD_NODE),
    Some(&WORD_VALE_NODE),
    None,
    None,
    None,
    Some(&WORD_VALI_NODE),
    None,
    Some(&WORD_VALK_NODE),
    Some(&WORD_VALL_NODE),
    None,
    Some(&WORD_VALN_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_VALS_NODE),
    Some(&WORD_VALT_NODE),
    Some(&WORD_VALU_NODE),
    None,
    None,
    None,
    Some(&WORD_VALY_NODE),
    None,
];

static WORD_VALY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_VALY_CHILDREN),
    value: None,
};

pub static WORD_VALY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("krie"),
    ],
    values: &[&["valse", "value", "valve"], &["valkyrie"]],
    range: 1..=4,
};

static WORD_VALU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_VALU_CHILDREN),
    value: Some(&["value"]),
};

pub static WORD_VALU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("abe"),
        dictgen::InsensitiveStr::Ascii("bale"),
        dictgen::InsensitiveStr::Ascii("ble"),
        dictgen::InsensitiveStr::Ascii("d"),
        dictgen::InsensitiveStr::Ascii("des"),
        dictgen::InsensitiveStr::Ascii("eable"),
        dictgen::InsensitiveStr::Ascii("ess"),
        dictgen::InsensitiveStr::Ascii("ie"),
        dictgen::InsensitiveStr::Ascii("lation"),
        dictgen::InsensitiveStr::Ascii("lations"),
        dictgen::InsensitiveStr::Ascii("le"),
        dictgen::InsensitiveStr::Ascii("led"),
        dictgen::InsensitiveStr::Ascii("les"),
        dictgen::InsensitiveStr::Ascii("ling"),
        dictgen::InsensitiveStr::Ascii("s"),
        dictgen::InsensitiveStr::Ascii("se"),
    ],
    values: &[
        &["valuable"],
        &["valuable"],
        &["valuable"],
        &["valid", "value"],
        &["values"],
        &["valuable"],
        &["values"],
        &["value"],
        &["valuation"],
        &["valuations"],
        &["value"],
        &["valued"],
        &["values"],
        &["valuing"],
        &["values", "talus", "value"],
        &["values", "value"],
    ],
    range: 1..=7,
};

static WORD_VALT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_VALT_CHILDREN),
    value: None,
};

pub static WORD_VALT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("age"),
        dictgen::InsensitiveStr::Ascii("ages"),
    ],
    values: &[&["voltage"], &["voltages"]],
    range: 3..=4,
};

static WORD_VALS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_VALS_CHILDREN),
    value: None,
};

pub static WORD_VALS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ues")],
    values: &[&["values"]],
    range: 3..=3,
};

static WORD_VALN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_VALN_CHILDREN),
    value: None,
};

pub static WORD_VALN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ecia"),
        dictgen::InsensitiveStr::Ascii("etines"),
    ],
    values: &[&["valencia"], &["valentines"]],
    range: 4..=6,
};

static WORD_VALL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_VALL_CHILDREN),
    value: None,
};

pub static WORD_VALL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ay"),
        dictgen::InsensitiveStr::Ascii("ayed"),
        dictgen::InsensitiveStr::Ascii("aying"),
        dictgen::InsensitiveStr::Ascii("ays"),
        dictgen::InsensitiveStr::Ascii("grind"),
        dictgen::InsensitiveStr::Ascii("id"),
        dictgen::InsensitiveStr::Ascii("idation"),
        dictgen::InsensitiveStr::Ascii("idity"),
        dictgen::InsensitiveStr::Ascii("ies"),
        dictgen::InsensitiveStr::Ascii("ue"),
        dictgen::InsensitiveStr::Ascii("ues"),
        dictgen::InsensitiveStr::Ascii("y"),
        dictgen::InsensitiveStr::Ascii("ys"),
    ],
    values: &[
        &["valet", "valley"],
        &["valeted"],
        &["valeting"],
        &["valets", "valleys"],
        &["valgrind"],
        &["valid"],
        &["validation"],
        &["validity"],
        &["valleys"],
        &["value"],
        &["values"],
        &["valley"],
        &["valleys"],
    ],
    range: 1..=7,
};

static WORD_VALK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_VALK_CHILDREN),
    value: None,
};

pub static WORD_VALK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("irye"),
        dictgen::InsensitiveStr::Ascii("iyre"),
        dictgen::InsensitiveStr::Ascii("riye"),
        dictgen::InsensitiveStr::Ascii("ryie"),
        dictgen::InsensitiveStr::Ascii("ues"),
        dictgen::InsensitiveStr::Ascii("yire"),
        dictgen::InsensitiveStr::Ascii("yre"),
    ],
    values: &[
        &["valkyrie"],
        &["valkyrie"],
        &["valkyrie"],
        &["valkyrie"],
        &["values"],
        &["valkyrie"],
        &["valkyrie"],
    ],
    range: 3..=4,
};

static WORD_VALI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_VALI_CHILDREN),
    value: None,
};

pub static WORD_VALI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ation"),
        dictgen::InsensitiveStr::Ascii("ator"),
        dictgen::InsensitiveStr::Ascii("dade"),
        dictgen::InsensitiveStr::Ascii("data"),
        dictgen::InsensitiveStr::Ascii("dataion"),
        dictgen::InsensitiveStr::Ascii("daterelase"),
        dictgen::InsensitiveStr::Ascii("dationt"),
        dictgen::InsensitiveStr::Ascii("dattion"),
        dictgen::InsensitiveStr::Ascii("daty"),
        dictgen::InsensitiveStr::Ascii("dd"),
        dictgen::InsensitiveStr::Ascii("de"),
        dictgen::InsensitiveStr::Ascii("didty"),
        dictgen::InsensitiveStr::Ascii("ding"),
        dictgen::InsensitiveStr::Ascii("ditity"),
        dictgen::InsensitiveStr::Ascii("ditiy"),
        dictgen::InsensitiveStr::Ascii("dte"),
        dictgen::InsensitiveStr::Ascii("dted"),
        dictgen::InsensitiveStr::Ascii("dtes"),
        dictgen::InsensitiveStr::Ascii("dting"),
        dictgen::InsensitiveStr::Ascii("dtion"),
        dictgen::InsensitiveStr::Ascii("dty"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("f"),
        dictgen::InsensitiveStr::Ascii("tdity"),
    ],
    values: &[
        &["validation"],
        &["validator"],
        &["validated", "validate"],
        &["validate"],
        &["validation"],
        &["validaterelease"],
        &["validation"],
        &["validation"],
        &["validity"],
        &["valid"],
        &["valid"],
        &["validity"],
        &["validating"],
        &["validity"],
        &["validity"],
        &["validate"],
        &["validated"],
        &["validates"],
        &["validating"],
        &["validation"],
        &["validity"],
        &["valid"],
        &["values"],
        &["valid"],
        &["validity"],
    ],
    range: 1..=10,
};

static WORD_VALE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_VALE_CHILDREN),
    value: None,
};

pub static WORD_VALE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("nca"),
        dictgen::InsensitiveStr::Ascii("nica"),
        dictgen::InsensitiveStr::Ascii("ntein"),
        dictgen::InsensitiveStr::Ascii("ntians"),
        dictgen::InsensitiveStr::Ascii("ntie"),
        dictgen::InsensitiveStr::Ascii("ntien"),
        dictgen::InsensitiveStr::Ascii("ntiens"),
        dictgen::InsensitiveStr::Ascii("ntimes"),
        dictgen::InsensitiveStr::Ascii("ntinas"),
        dictgen::InsensitiveStr::Ascii("ntinos"),
        dictgen::InsensitiveStr::Ascii("ntins"),
        dictgen::InsensitiveStr::Ascii("ntis"),
        dictgen::InsensitiveStr::Ascii("ntones"),
        dictgen::InsensitiveStr::Ascii("tta"),
        dictgen::InsensitiveStr::Ascii("u"),
    ],
    values: &[
        &["valencia"],
        &["valencia"],
        &["valentine"],
        &["valentines"],
        &["valentines"],
        &["valentine"],
        &["valentines"],
        &["valentines"],
        &["valentines"],
        &["valentines"],
        &["valentines"],
        &["valentines"],
        &["valentines"],
        &["valletta"],
        &["value"],
    ],
    range: 1..=6,
};

static WORD_VALD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_VALD_CHILDREN),
    value: None,
};

pub static WORD_VALD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ate"),
        dictgen::InsensitiveStr::Ascii("iated"),
        dictgen::InsensitiveStr::Ascii("ity"),
    ],
    values: &[&["validate"], &["validated"], &["validity"]],
    range: 3..=5,
};

static WORD_VALA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_VALA_CHILDREN),
    value: None,
};

pub static WORD_VALA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ilable")],
    values: &[&["available"]],
    range: 6..=6,
};

static WORD_VAK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_VAK_CHILDREN),
    value: None,
};

pub static WORD_VAK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("lyrie"),
        dictgen::InsensitiveStr::Ascii("ue"),
        dictgen::InsensitiveStr::Ascii("ued"),
        dictgen::InsensitiveStr::Ascii("ues"),
    ],
    values: &[&["valkyrie"], &["value"], &["valued"], &["values"]],
    range: 2..=5,
};

static WORD_VAI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_VAI_CHILDREN),
    value: Some(&["via", "vie"]),
};

pub static WORD_VAI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("able"),
        dictgen::InsensitiveStr::Ascii("ables"),
        dictgen::InsensitiveStr::Ascii("ant"),
        dictgen::InsensitiveStr::Ascii("ants"),
        dictgen::InsensitiveStr::Ascii("ation"),
        dictgen::InsensitiveStr::Ascii("bility"),
        dictgen::InsensitiveStr::Ascii("d"),
        dictgen::InsensitiveStr::Ascii("date"),
        dictgen::InsensitiveStr::Ascii("eties"),
        dictgen::InsensitiveStr::Ascii("lable"),
        dictgen::InsensitiveStr::Ascii("ld"),
        dictgen::InsensitiveStr::Ascii("ldated"),
        dictgen::InsensitiveStr::Ascii("lidity"),
        dictgen::InsensitiveStr::Ascii("lidty"),
        dictgen::InsensitiveStr::Ascii("rable"),
        dictgen::InsensitiveStr::Ascii("rables"),
        dictgen::InsensitiveStr::Ascii("rant"),
        dictgen::InsensitiveStr::Ascii("rous"),
    ],
    values: &[
        &["variable"],
        &["variables"],
        &["variant"],
        &["variants"],
        &["aviation"],
        &["viability"],
        &["valid", "void"],
        &["validate"],
        &["varieties"],
        &["available"],
        &["valid"],
        &["validated"],
        &["validity"],
        &["validity"],
        &["variable"],
        &["variables"],
        &["variant"],
        &["various"],
    ],
    range: 1..=6,
};

static WORD_VAG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_VAG_CHILDREN),
    value: None,
};

pub static WORD_VAG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("euly"),
        dictgen::InsensitiveStr::Ascii("uaries"),
        dictgen::InsensitiveStr::Ascii("uelly"),
        dictgen::InsensitiveStr::Ascii("uley"),
    ],
    values: &[&["vaguely"], &["vagaries"], &["vaguely"], &["vaguely"]],
    range: 4..=6,
};

static WORD_VAE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_VAE_CHILDREN),
    value: None,
};

pub static WORD_VAE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("lue"),
        dictgen::InsensitiveStr::Ascii("lues"),
    ],
    values: &[&["value", "valued"], &["values"]],
    range: 3..=4,
};

static WORD_VAC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_VAC_CHILDREN),
    value: None,
};

pub static WORD_VAC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ciante"),
        dictgen::InsensitiveStr::Ascii("ciantion"),
        dictgen::InsensitiveStr::Ascii("cinae"),
        dictgen::InsensitiveStr::Ascii("cinatie"),
        dictgen::InsensitiveStr::Ascii("cinaties"),
        dictgen::InsensitiveStr::Ascii("cinato"),
        dictgen::InsensitiveStr::Ascii("cineras"),
        dictgen::InsensitiveStr::Ascii("ciners"),
        dictgen::InsensitiveStr::Ascii("cinet"),
        dictgen::InsensitiveStr::Ascii("cins"),
        dictgen::InsensitiveStr::Ascii("cum"),
        dictgen::InsensitiveStr::Ascii("cume"),
        dictgen::InsensitiveStr::Ascii("cuum"),
        dictgen::InsensitiveStr::Ascii("estomy"),
        dictgen::InsensitiveStr::Ascii("inate"),
        dictgen::InsensitiveStr::Ascii("inated"),
        dictgen::InsensitiveStr::Ascii("inates"),
        dictgen::InsensitiveStr::Ascii("inating"),
        dictgen::InsensitiveStr::Ascii("ination"),
        dictgen::InsensitiveStr::Ascii("inations"),
        dictgen::InsensitiveStr::Ascii("ine"),
        dictgen::InsensitiveStr::Ascii("ines"),
        dictgen::InsensitiveStr::Ascii("inity"),
        dictgen::InsensitiveStr::Ascii("tor"),
        dictgen::InsensitiveStr::Ascii("tors"),
        dictgen::InsensitiveStr::Ascii("ume"),
        dictgen::InsensitiveStr::Ascii("umed"),
        dictgen::InsensitiveStr::Ascii("umeed"),
        dictgen::InsensitiveStr::Ascii("umes"),
        dictgen::InsensitiveStr::Ascii("uming"),
        dictgen::InsensitiveStr::Ascii("umme"),
        dictgen::InsensitiveStr::Ascii("ummes"),
        dictgen::InsensitiveStr::Ascii("ums"),
        dictgen::InsensitiveStr::Ascii("uosly"),
    ],
    values: &[
        &["vaccinate"],
        &["vaccination"],
        &["vaccinated"],
        &["vaccinated"],
        &["vaccinate"],
        &["vaccination"],
        &["vaccines"],
        &["vaccines"],
        &["vaccinated"],
        &["vaccines"],
        &["vacuum"],
        &["vacuum"],
        &["vacuum"],
        &["vasectomy"],
        &["vaccinate"],
        &["vaccinated"],
        &["vaccinates"],
        &["vaccinating"],
        &["vaccination"],
        &["vaccinations"],
        &["vaccine"],
        &["vaccines"],
        &["vicinity"],
        &["vector"],
        &["vectors"],
        &["vacuum"],
        &["vacuumed"],
        &["vacuumed"],
        &["vacuums"],
        &["vacuuming"],
        &["vacuum"],
        &["vacuums"],
        &["vacuums"],
        &["vacuously"],
    ],
    range: 3..=8,
};

static WORD_VAA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_VAA_CHILDREN),
    value: None,
};

pub static WORD_VAA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("lues")],
    values: &[&["values"]],
    range: 4..=4,
};

static WORD_U_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_U_CHILDREN),
    value: None,
};

static WORD_U_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    Some(&WORD_UB_NODE),
    None,
    Some(&WORD_UD_NODE),
    Some(&WORD_UE_NODE),
    Some(&WORD_UF_NODE),
    Some(&WORD_UG_NODE),
    None,
    Some(&WORD_UI_NODE),
    None,
    Some(&WORD_UK_NODE),
    Some(&WORD_UL_NODE),
    Some(&WORD_UM_NODE),
    Some(&WORD_UN_NODE),
    None,
    Some(&WORD_UP_NODE),
    Some(&WORD_UQ_NODE),
    Some(&WORD_UR_NODE),
    Some(&WORD_US_NODE),
    Some(&WORD_UT_NODE),
    Some(&WORD_UU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_UU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UU_CHILDREN),
    value: None,
};

pub static WORD_UU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("pload"),
        dictgen::InsensitiveStr::Ascii("pper"),
    ],
    values: &[&["upload"], &["upper"]],
    range: 4..=5,
};

static WORD_UT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UT_CHILDREN),
    value: None,
};

pub static WORD_UT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("iilties"),
        dictgen::InsensitiveStr::Ascii("iliatrian"),
        dictgen::InsensitiveStr::Ascii("ilies"),
        dictgen::InsensitiveStr::Ascii("ililties"),
        dictgen::InsensitiveStr::Ascii("ilis"),
        dictgen::InsensitiveStr::Ascii("ilisa"),
        dictgen::InsensitiveStr::Ascii("ilisaton"),
        dictgen::InsensitiveStr::Ascii("ilitatian"),
        dictgen::InsensitiveStr::Ascii("iliterian"),
        dictgen::InsensitiveStr::Ascii("ilites"),
        dictgen::InsensitiveStr::Ascii("ilitisation"),
        dictgen::InsensitiveStr::Ascii("ilitise"),
        dictgen::InsensitiveStr::Ascii("ilitises"),
        dictgen::InsensitiveStr::Ascii("ilitising"),
        dictgen::InsensitiveStr::Ascii("ilitiy"),
        dictgen::InsensitiveStr::Ascii("ilitization"),
        dictgen::InsensitiveStr::Ascii("ilitize"),
        dictgen::InsensitiveStr::Ascii("ilitizes"),
        dictgen::InsensitiveStr::Ascii("ilitizing"),
        dictgen::InsensitiveStr::Ascii("iliz"),
        dictgen::InsensitiveStr::Ascii("iliza"),
        dictgen::InsensitiveStr::Ascii("ilizacion"),
        dictgen::InsensitiveStr::Ascii("ilizaiton"),
        dictgen::InsensitiveStr::Ascii("ilizating"),
        dictgen::InsensitiveStr::Ascii("ilizaton"),
        dictgen::InsensitiveStr::Ascii("ill"),
        dictgen::InsensitiveStr::Ascii("illities"),
        dictgen::InsensitiveStr::Ascii("iltiarian"),
        dictgen::InsensitiveStr::Ascii("ilties"),
        dictgen::InsensitiveStr::Ascii("iltities"),
        dictgen::InsensitiveStr::Ascii("iltity"),
        dictgen::InsensitiveStr::Ascii("iltiy"),
        dictgen::InsensitiveStr::Ascii("ilty"),
        dictgen::InsensitiveStr::Ascii("itity"),
        dictgen::InsensitiveStr::Ascii("itlities"),
        dictgen::InsensitiveStr::Ascii("itlity"),
        dictgen::InsensitiveStr::Ascii("itlty"),
        dictgen::InsensitiveStr::Ascii("limate"),
        dictgen::InsensitiveStr::Ascii("limately"),
        dictgen::InsensitiveStr::Ascii("limatum"),
        dictgen::InsensitiveStr::Ascii("lities"),
        dictgen::InsensitiveStr::Ascii("lity"),
        dictgen::InsensitiveStr::Ascii("lrasound"),
        dictgen::InsensitiveStr::Ascii("opain"),
        dictgen::InsensitiveStr::Ascii("poian"),
        dictgen::InsensitiveStr::Ascii("put"),
        dictgen::InsensitiveStr::Ascii("puts"),
    ],
    values: &[
        &["utilities"],
        &["utilitarian"],
        &["utilities"],
        &["utilities"],
        &["utilise"],
        &["utilise"],
        &["utilisation"],
        &["utilitarian"],
        &["utilitarian"],
        &["utilities"],
        &["utilisation"],
        &["utilise"],
        &["utilises"],
        &["utilising"],
        &["utility"],
        &["utilization"],
        &["utilize"],
        &["utilizes"],
        &["utilizing"],
        &["utilize"],
        &["utilize"],
        &["utilization"],
        &["utilization"],
        &["utilization"],
        &["utilization"],
        &["until", "utils"],
        &["utilities"],
        &["utilitarian"],
        &["utilities"],
        &["utilities"],
        &["utility"],
        &["utility"],
        &["utility"],
        &["utility"],
        &["utilities"],
        &["utility"],
        &["utility"],
        &["ultimate"],
        &["ultimately"],
        &["ultimatum"],
        &["utilities"],
        &["utility"],
        &["ultrasound"],
        &["utopian"],
        &["utopian"],
        &["output"],
        &["outputs"],
    ],
    range: 3..=11,
};

static WORD_US_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_US_CHILDREN),
    value: None,
};

static WORD_US_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_USA_NODE),
    None,
    Some(&WORD_USC_NODE),
    None,
    Some(&WORD_USE_NODE),
    None,
    None,
    None,
    Some(&WORD_USI_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_USN_NODE),
    None,
    Some(&WORD_USP_NODE),
    None,
    None,
    Some(&WORD_USS_NODE),
    None,
    Some(&WORD_USU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_USU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_USU_CHILDREN),
    value: None,
};

pub static WORD_USU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("able"),
        dictgen::InsensitiveStr::Ascii("age"),
        dictgen::InsensitiveStr::Ascii("all"),
        dictgen::InsensitiveStr::Ascii("allly"),
        dictgen::InsensitiveStr::Ascii("aly"),
        dictgen::InsensitiveStr::Ascii("alyl"),
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("eful"),
        dictgen::InsensitiveStr::Ascii("er"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("pported"),
        dictgen::InsensitiveStr::Ascii("sal"),
        dictgen::InsensitiveStr::Ascii("sally"),
    ],
    values: &[
        &["usable"],
        &["usage"],
        &["usually", "usual"],
        &["usually"],
        &["usually"],
        &["usually"],
        &["use"],
        &["used"],
        &["useful"],
        &["user"],
        &["using"],
        &["unsupported"],
        &["usual"],
        &["usually"],
    ],
    range: 1..=7,
};

static WORD_USS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_USS_CHILDREN),
    value: None,
};

pub static WORD_USS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("age"),
        dictgen::InsensitiveStr::Ascii("eful"),
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("ual"),
        dictgen::InsensitiveStr::Ascii("uall"),
        dictgen::InsensitiveStr::Ascii("ually"),
    ],
    values: &[
        &["usage"],
        &["useful"],
        &["uses"],
        &["usual"],
        &["usual"],
        &["usually"],
    ],
    range: 2..=5,
};

static WORD_USP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_USP_CHILDREN),
    value: None,
};

pub static WORD_USP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ported"),
        dictgen::InsensitiveStr::Ascii("tart"),
        dictgen::InsensitiveStr::Ascii("tarts"),
    ],
    values: &[&["supported", "unsupported"], &["upstart"], &["upstarts"]],
    range: 4..=6,
};

static WORD_USN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_USN_CHILDREN),
    value: None,
};

pub static WORD_USN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("g"),
        dictgen::InsensitiveStr::Ascii("ig"),
    ],
    values: &[&["using"], &["using"]],
    range: 1..=2,
};

static WORD_USI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_USI_CHILDREN),
    value: None,
};

pub static WORD_USI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("bility"),
        dictgen::InsensitiveStr::Ascii("ble"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("g"),
        dictgen::InsensitiveStr::Ascii("gn"),
        dictgen::InsensitiveStr::Ascii("gned"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("n"),
        dictgen::InsensitiveStr::Ascii("nd"),
        dictgen::InsensitiveStr::Ascii("nging"),
        dictgen::InsensitiveStr::Ascii("nng"),
    ],
    values: &[
        &["usability"],
        &["usable"],
        &["busied", "used"],
        &["using"],
        &["using", "unsign"],
        &["unsigned"],
        &["using"],
        &["using"],
        &["using"],
        &["using"],
        &["using"],
    ],
    range: 1..=6,
};

static WORD_USE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_USE_CHILDREN),
    value: None,
};

pub static WORD_USE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("age"),
        dictgen::InsensitiveStr::Ascii("bility"),
        dictgen::InsensitiveStr::Ascii("ble"),
        dictgen::InsensitiveStr::Ascii("ddd"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("fl"),
        dictgen::InsensitiveStr::Ascii("fule"),
        dictgen::InsensitiveStr::Ascii("full"),
        dictgen::InsensitiveStr::Ascii("fullness"),
        dictgen::InsensitiveStr::Ascii("fult"),
        dictgen::InsensitiveStr::Ascii("fulu"),
        dictgen::InsensitiveStr::Ascii("fuly"),
        dictgen::InsensitiveStr::Ascii("futl"),
        dictgen::InsensitiveStr::Ascii("g"),
        dictgen::InsensitiveStr::Ascii("ge"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("ra"),
        dictgen::InsensitiveStr::Ascii("rame"),
        dictgen::InsensitiveStr::Ascii("rames"),
        dictgen::InsensitiveStr::Ascii("rapace"),
        dictgen::InsensitiveStr::Ascii("re"),
        dictgen::InsensitiveStr::Ascii("rful"),
        dictgen::InsensitiveStr::Ascii("rpace"),
        dictgen::InsensitiveStr::Ascii("rpsace"),
        dictgen::InsensitiveStr::Ascii("rsapce"),
        dictgen::InsensitiveStr::Ascii("rspase"),
        dictgen::InsensitiveStr::Ascii("sfull"),
        dictgen::InsensitiveStr::Ascii("space"),
        dictgen::InsensitiveStr::Ascii("tnet"),
    ],
    values: &[
        &["usage"],
        &["usability"],
        &["usable"],
        &["used"],
        &["used"],
        &["uses"],
        &["useful"],
        &["useful"],
        &["useful"],
        &["usefulness"],
        &["useful"],
        &["useful"],
        &["usefully"],
        &["useful"],
        &["user", "usage"],
        &["usage"],
        &["using"],
        &["users"],
        &["username"],
        &["usernames"],
        &["userspace"],
        &["user"],
        &["useful"],
        &["userspace"],
        &["userspace"],
        &["userspace"],
        &["userspace"],
        &["useful"],
        &["userspace"],
        &["usenet"],
    ],
    range: 1..=8,
};

static WORD_USC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_USC_CHILDREN),
    value: None,
};

pub static WORD_USC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aled"),
        dictgen::InsensitiveStr::Ascii("cess"),
    ],
    values: &[&["unscaled"], &["success"]],
    range: 4..=4,
};

static WORD_USA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_USA_CHILDREN),
    value: None,
};

pub static WORD_USA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("g"),
        dictgen::InsensitiveStr::Ascii("l"),
        dictgen::InsensitiveStr::Ascii("lly"),
    ],
    values: &[&["usage"], &["usual"], &["usually"]],
    range: 1..=3,
};

static WORD_UR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UR_CHILDREN),
    value: None,
};

pub static WORD_UR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ainum"),
        dictgen::InsensitiveStr::Ascii("anuim"),
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("ethrea"),
        dictgen::InsensitiveStr::Ascii("etrha"),
        dictgen::InsensitiveStr::Ascii("kaine"),
        dictgen::InsensitiveStr::Ascii("kainian"),
        dictgen::InsensitiveStr::Ascii("kainians"),
        dictgen::InsensitiveStr::Ascii("naium"),
        dictgen::InsensitiveStr::Ascii("rlib"),
        dictgen::InsensitiveStr::Ascii("ugauy"),
        dictgen::InsensitiveStr::Ascii("uguary"),
    ],
    values: &[
        &["uranium"],
        &["uranium"],
        &["sure", "ire", "are", "urea", "rue"],
        &["urethra"],
        &["urethra"],
        &["ukraine"],
        &["ukrainian"],
        &["ukrainians"],
        &["uranium"],
        &["urllib"],
        &["uruguay"],
        &["uruguay"],
    ],
    range: 1..=8,
};

static WORD_UQ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UQ_CHILDREN),
    value: None,
};

pub static WORD_UQ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("est"),
        dictgen::InsensitiveStr::Ascii("ests"),
    ],
    values: &[&["quest"], &["quests"]],
    range: 3..=4,
};

static WORD_UP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_UP_CHILDREN),
    value: None,
};

static WORD_UP_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_UPA_NODE),
    None,
    Some(&WORD_UPC_NODE),
    Some(&WORD_UPD_NODE),
    Some(&WORD_UPE_NODE),
    None,
    Some(&WORD_UPG_NODE),
    Some(&WORD_UPH_NODE),
    None,
    None,
    None,
    Some(&WORD_UPL_NODE),
    None,
    None,
    None,
    Some(&WORD_UPP_NODE),
    None,
    Some(&WORD_UPR_NODE),
    Some(&WORD_UPS_NODE),
    Some(&WORD_UPT_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_UPT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UPT_CHILDREN),
    value: None,
};

pub static WORD_UPT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("adeable"),
        dictgen::InsensitiveStr::Ascii("date"),
        dictgen::InsensitiveStr::Ascii("im"),
        dictgen::InsensitiveStr::Ascii("ions"),
        dictgen::InsensitiveStr::Ascii("ream"),
        dictgen::InsensitiveStr::Ascii("reamed"),
        dictgen::InsensitiveStr::Ascii("reamer"),
        dictgen::InsensitiveStr::Ascii("reaming"),
        dictgen::InsensitiveStr::Ascii("reams"),
    ],
    values: &[
        &["updatable"],
        &["update"],
        &["uptime"],
        &["options"],
        &["upstream"],
        &["upstreamed"],
        &["upstreamer"],
        &["upstreaming"],
        &["upstreams"],
    ],
    range: 2..=7,
};

static WORD_UPS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UPS_CHILDREN),
    value: None,
};

pub static WORD_UPS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ream"),
        dictgen::InsensitiveStr::Ascii("reamed"),
        dictgen::InsensitiveStr::Ascii("reamer"),
        dictgen::InsensitiveStr::Ascii("reaming"),
        dictgen::InsensitiveStr::Ascii("reams"),
        dictgen::InsensitiveStr::Ascii("rteam"),
        dictgen::InsensitiveStr::Ascii("rteamed"),
        dictgen::InsensitiveStr::Ascii("rteamer"),
        dictgen::InsensitiveStr::Ascii("rteaming"),
        dictgen::InsensitiveStr::Ascii("rteams"),
        dictgen::InsensitiveStr::Ascii("taris"),
        dictgen::InsensitiveStr::Ascii("team"),
        dictgen::InsensitiveStr::Ascii("teamed"),
        dictgen::InsensitiveStr::Ascii("teamer"),
        dictgen::InsensitiveStr::Ascii("teaming"),
        dictgen::InsensitiveStr::Ascii("teams"),
        dictgen::InsensitiveStr::Ascii("teram"),
        dictgen::InsensitiveStr::Ascii("teramed"),
        dictgen::InsensitiveStr::Ascii("teramer"),
        dictgen::InsensitiveStr::Ascii("teraming"),
        dictgen::InsensitiveStr::Ascii("terams"),
        dictgen::InsensitiveStr::Ascii("tiars"),
        dictgen::InsensitiveStr::Ascii("tread"),
        dictgen::InsensitiveStr::Ascii("treamedd"),
        dictgen::InsensitiveStr::Ascii("treammed"),
        dictgen::InsensitiveStr::Ascii("treammer"),
        dictgen::InsensitiveStr::Ascii("treamming"),
        dictgen::InsensitiveStr::Ascii("treem"),
        dictgen::InsensitiveStr::Ascii("treemed"),
        dictgen::InsensitiveStr::Ascii("treemer"),
        dictgen::InsensitiveStr::Ascii("treeming"),
        dictgen::InsensitiveStr::Ascii("treems"),
        dictgen::InsensitiveStr::Ascii("trem"),
        dictgen::InsensitiveStr::Ascii("trema"),
        dictgen::InsensitiveStr::Ascii("upported"),
    ],
    values: &[
        &["upstream"],
        &["upstreamed"],
        &["upstreamer"],
        &["upstreaming"],
        &["upstreams"],
        &["upstream"],
        &["upstreamed"],
        &["upstreamer"],
        &["upstreaming"],
        &["upstreams"],
        &["upstairs"],
        &["upstream"],
        &["upstreamed"],
        &["upstreamer"],
        &["upstreaming"],
        &["upstreams"],
        &["upstream"],
        &["upstreamed"],
        &["upstreamer"],
        &["upstreaming"],
        &["upstreams"],
        &["upstairs"],
        &["upstream"],
        &["upstreamed"],
        &["upstreamed"],
        &["upstreamer"],
        &["upstreaming"],
        &["upstream"],
        &["upstreamed"],
        &["upstreamer"],
        &["upstreaming"],
        &["upstreams"],
        &["upstream"],
        &["upstream"],
        &["unsupported"],
    ],
    range: 4..=9,
};

static WORD_UPR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UPR_CHILDREN),
    value: None,
};

pub static WORD_UPR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ade"),
        dictgen::InsensitiveStr::Ascii("aded"),
        dictgen::InsensitiveStr::Ascii("ades"),
        dictgen::InsensitiveStr::Ascii("ading"),
        dictgen::InsensitiveStr::Ascii("gade"),
        dictgen::InsensitiveStr::Ascii("gaded"),
        dictgen::InsensitiveStr::Ascii("gades"),
        dictgen::InsensitiveStr::Ascii("gading"),
    ],
    values: &[
        &["upgrade"],
        &["upgraded"],
        &["upgrades"],
        &["upgrading"],
        &["upgrade"],
        &["upgraded"],
        &["upgrades"],
        &["upgrading"],
    ],
    range: 3..=6,
};

static WORD_UPP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UPP_CHILDREN),
    value: None,
};

pub static WORD_UPP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ercas"),
        dictgen::InsensitiveStr::Ascii("ler"),
        dictgen::InsensitiveStr::Ascii("on"),
        dictgen::InsensitiveStr::Ascii("ort"),
        dictgen::InsensitiveStr::Ascii("orted"),
        dictgen::InsensitiveStr::Ascii("orterd"),
        dictgen::InsensitiveStr::Ascii("per"),
        dictgen::InsensitiveStr::Ascii("stream"),
        dictgen::InsensitiveStr::Ascii("streamed"),
        dictgen::InsensitiveStr::Ascii("streamer"),
        dictgen::InsensitiveStr::Ascii("streaming"),
        dictgen::InsensitiveStr::Ascii("streams"),
        dictgen::InsensitiveStr::Ascii("wards"),
    ],
    values: &[
        &["uppercase"],
        &["upper"],
        &["upon"],
        &["support"],
        &["supported"],
        &["supported"],
        &["upper"],
        &["upstream"],
        &["upstreamed"],
        &["upstreamer"],
        &["upstreaming"],
        &["upstreams"],
        &["upwards"],
    ],
    range: 2..=9,
};

static WORD_UPL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UPL_CHILDREN),
    value: None,
};

pub static WORD_UPL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ad"),
        dictgen::InsensitiveStr::Ascii("adad"),
        dictgen::InsensitiveStr::Ascii("adaded"),
        dictgen::InsensitiveStr::Ascii("aded"),
        dictgen::InsensitiveStr::Ascii("ader"),
        dictgen::InsensitiveStr::Ascii("aders"),
        dictgen::InsensitiveStr::Ascii("ading"),
        dictgen::InsensitiveStr::Ascii("ads"),
        dictgen::InsensitiveStr::Ascii("aod"),
        dictgen::InsensitiveStr::Ascii("aodad"),
        dictgen::InsensitiveStr::Ascii("aodaded"),
        dictgen::InsensitiveStr::Ascii("aoded"),
        dictgen::InsensitiveStr::Ascii("aoder"),
        dictgen::InsensitiveStr::Ascii("aoders"),
        dictgen::InsensitiveStr::Ascii("aodes"),
        dictgen::InsensitiveStr::Ascii("aoding"),
        dictgen::InsensitiveStr::Ascii("aods"),
        dictgen::InsensitiveStr::Ascii("fiting"),
        dictgen::InsensitiveStr::Ascii("iad"),
        dictgen::InsensitiveStr::Ascii("ifitng"),
        dictgen::InsensitiveStr::Ascii("oades"),
        dictgen::InsensitiveStr::Ascii("od"),
        dictgen::InsensitiveStr::Ascii("odad"),
        dictgen::InsensitiveStr::Ascii("odaded"),
        dictgen::InsensitiveStr::Ascii("oded"),
        dictgen::InsensitiveStr::Ascii("oder"),
        dictgen::InsensitiveStr::Ascii("oders"),
        dictgen::InsensitiveStr::Ascii("oding"),
        dictgen::InsensitiveStr::Ascii("ods"),
    ],
    values: &[
        &["upload"],
        &["upload", "uploaded"],
        &["uploaded"],
        &["uploaded"],
        &["uploader"],
        &["uploaders"],
        &["uploading"],
        &["uploads"],
        &["upload"],
        &["upload", "uploaded"],
        &["uploaded"],
        &["uploaded"],
        &["uploader"],
        &["uploaders"],
        &["uploads"],
        &["uploading"],
        &["uploads"],
        &["uplifting"],
        &["upload"],
        &["uplifting"],
        &["uploads"],
        &["upload"],
        &["upload", "uploaded"],
        &["uploaded"],
        &["uploaded"],
        &["uploader"],
        &["uploaders"],
        &["uploading"],
        &["uploads"],
    ],
    range: 2..=7,
};

static WORD_UPH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UPH_CHILDREN),
    value: None,
};

pub static WORD_UPH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("olstry")],
    values: &[&["upholstery"]],
    range: 6..=6,
};

static WORD_UPG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UPG_CHILDREN),
    value: None,
};

pub static WORD_UPG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ade"),
        dictgen::InsensitiveStr::Ascii("aded"),
        dictgen::InsensitiveStr::Ascii("ades"),
        dictgen::InsensitiveStr::Ascii("ading"),
        dictgen::InsensitiveStr::Ascii("arade"),
        dictgen::InsensitiveStr::Ascii("araded"),
        dictgen::InsensitiveStr::Ascii("arades"),
        dictgen::InsensitiveStr::Ascii("arading"),
        dictgen::InsensitiveStr::Ascii("arde"),
        dictgen::InsensitiveStr::Ascii("arded"),
        dictgen::InsensitiveStr::Ascii("ardes"),
        dictgen::InsensitiveStr::Ascii("arding"),
        dictgen::InsensitiveStr::Ascii("arte"),
        dictgen::InsensitiveStr::Ascii("arted"),
        dictgen::InsensitiveStr::Ascii("artes"),
        dictgen::InsensitiveStr::Ascii("arting"),
        dictgen::InsensitiveStr::Ascii("erade"),
        dictgen::InsensitiveStr::Ascii("eraded"),
        dictgen::InsensitiveStr::Ascii("erades"),
        dictgen::InsensitiveStr::Ascii("erading"),
        dictgen::InsensitiveStr::Ascii("radablilty"),
        dictgen::InsensitiveStr::Ascii("radde"),
        dictgen::InsensitiveStr::Ascii("radded"),
        dictgen::InsensitiveStr::Ascii("raddes"),
        dictgen::InsensitiveStr::Ascii("radding"),
        dictgen::InsensitiveStr::Ascii("radei"),
        dictgen::InsensitiveStr::Ascii("radingn"),
        dictgen::InsensitiveStr::Ascii("rads"),
        dictgen::InsensitiveStr::Ascii("rate"),
        dictgen::InsensitiveStr::Ascii("rated"),
        dictgen::InsensitiveStr::Ascii("rates"),
        dictgen::InsensitiveStr::Ascii("rating"),
    ],
    values: &[
        &["upgrade"],
        &["upgraded"],
        &["upgrades"],
        &["upgrading"],
        &["upgrade"],
        &["upgraded"],
        &["upgrades"],
        &["upgrading"],
        &["upgrade"],
        &["upgraded"],
        &["upgrades"],
        &["upgrading"],
        &["upgrade"],
        &["upgraded"],
        &["upgrades"],
        &["upgrading"],
        &["upgrade"],
        &["upgraded"],
        &["upgrades"],
        &["upgrading"],
        &["upgradability"],
        &["upgrade"],
        &["upgraded"],
        &["upgrades"],
        &["upgrading"],
        &["upgrade"],
        &["upgrading"],
        &["upgrades"],
        &["upgrade"],
        &["upgraded"],
        &["upgrades"],
        &["upgrading"],
    ],
    range: 3..=10,
};

static WORD_UPE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UPE_CHILDREN),
    value: None,
};

pub static WORD_UPE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("r"),
        dictgen::InsensitiveStr::Ascii("rcase"),
        dictgen::InsensitiveStr::Ascii("rclass"),
    ],
    values: &[&["super", "upper"], &["uppercase"], &["upperclass"]],
    range: 1..=6,
};

static WORD_UPD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UPD_CHILDREN),
    value: None,
};

pub static WORD_UPD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aing"),
        dictgen::InsensitiveStr::Ascii("at"),
        dictgen::InsensitiveStr::Ascii("ateded"),
        dictgen::InsensitiveStr::Ascii("ateed"),
        dictgen::InsensitiveStr::Ascii("atees"),
        dictgen::InsensitiveStr::Ascii("ateing"),
        dictgen::InsensitiveStr::Ascii("atess"),
        dictgen::InsensitiveStr::Ascii("atig"),
        dictgen::InsensitiveStr::Ascii("ats"),
        dictgen::InsensitiveStr::Ascii("date"),
        dictgen::InsensitiveStr::Ascii("grade"),
        dictgen::InsensitiveStr::Ascii("graded"),
        dictgen::InsensitiveStr::Ascii("grades"),
        dictgen::InsensitiveStr::Ascii("grading"),
        dictgen::InsensitiveStr::Ascii("load"),
        dictgen::InsensitiveStr::Ascii("rage"),
        dictgen::InsensitiveStr::Ascii("raged"),
        dictgen::InsensitiveStr::Ascii("rages"),
        dictgen::InsensitiveStr::Ascii("raging"),
        dictgen::InsensitiveStr::Ascii("te"),
    ],
    values: &[
        &["updating"],
        &["update"],
        &["updated"],
        &["updated"],
        &["updates"],
        &["updating"],
        &["updates"],
        &["updating"],
        &["updates"],
        &["update"],
        &["upgrade"],
        &["upgraded"],
        &["upgrades"],
        &["upgrading"],
        &["upload"],
        &["upgrade"],
        &["upgraded"],
        &["upgrades"],
        &["upgrading"],
        &["update"],
    ],
    range: 2..=7,
};

static WORD_UPC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UPC_CHILDREN),
    value: None,
};

pub static WORD_UPC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("omming")],
    values: &[&["upcoming"]],
    range: 6..=6,
};

static WORD_UPA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UPA_CHILDREN),
    value: None,
};

pub static WORD_UPA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("date"),
        dictgen::InsensitiveStr::Ascii("dated"),
        dictgen::InsensitiveStr::Ascii("dater"),
        dictgen::InsensitiveStr::Ascii("dates"),
        dictgen::InsensitiveStr::Ascii("dating"),
        dictgen::InsensitiveStr::Ascii("dte"),
        dictgen::InsensitiveStr::Ascii("dted"),
        dictgen::InsensitiveStr::Ascii("dter"),
        dictgen::InsensitiveStr::Ascii("dters"),
        dictgen::InsensitiveStr::Ascii("dtes"),
        dictgen::InsensitiveStr::Ascii("grade"),
        dictgen::InsensitiveStr::Ascii("graded"),
        dictgen::InsensitiveStr::Ascii("grades"),
        dictgen::InsensitiveStr::Ascii("grading"),
        dictgen::InsensitiveStr::Ascii("te"),
        dictgen::InsensitiveStr::Ascii("ted"),
        dictgen::InsensitiveStr::Ascii("ter"),
        dictgen::InsensitiveStr::Ascii("tes"),
        dictgen::InsensitiveStr::Ascii("ting"),
    ],
    values: &[
        &["update"],
        &["updated"],
        &["updater"],
        &["updates"],
        &["updating"],
        &["update"],
        &["updated"],
        &["updater"],
        &["updaters"],
        &["updates"],
        &["upgrade"],
        &["upgraded"],
        &["upgrades"],
        &["upgrading"],
        &["update"],
        &["updated"],
        &["updater"],
        &["updates"],
        &["updating"],
    ],
    range: 2..=7,
};

static WORD_UN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_UN_CHILDREN),
    value: None,
};

static WORD_UN_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_UNA_NODE),
    Some(&WORD_UNB_NODE),
    Some(&WORD_UNC_NODE),
    Some(&WORD_UND_NODE),
    Some(&WORD_UNE_NODE),
    Some(&WORD_UNF_NODE),
    Some(&WORD_UNG_NODE),
    Some(&WORD_UNH_NODE),
    Some(&WORD_UNI_NODE),
    Some(&WORD_UNJ_NODE),
    Some(&WORD_UNK_NODE),
    Some(&WORD_UNL_NODE),
    Some(&WORD_UNM_NODE),
    Some(&WORD_UNN_NODE),
    Some(&WORD_UNO_NODE),
    Some(&WORD_UNP_NODE),
    Some(&WORD_UNQ_NODE),
    Some(&WORD_UNR_NODE),
    Some(&WORD_UNS_NODE),
    Some(&WORD_UNT_NODE),
    Some(&WORD_UNU_NODE),
    Some(&WORD_UNV_NODE),
    Some(&WORD_UNW_NODE),
    Some(&WORD_UNX_NODE),
    None,
    Some(&WORD_UNZ_NODE),
];

static WORD_UNZ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNZ_CHILDREN),
    value: None,
};

pub static WORD_UNZ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("iped")],
    values: &[&["unzipped"]],
    range: 4..=4,
};

static WORD_UNX_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNX_CHILDREN),
    value: Some(&["unix"]),
};

pub static WORD_UNX_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("epected"),
        dictgen::InsensitiveStr::Ascii("epectedly"),
        dictgen::InsensitiveStr::Ascii("pected"),
    ],
    values: &[&["unexpected"], &["unexpectedly"], &["unexpected"]],
    range: 6..=9,
};

static WORD_UNW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNW_CHILDREN),
    value: None,
};

pub static WORD_UNW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("arrented"),
        dictgen::InsensitiveStr::Ascii("eildly"),
        dictgen::InsensitiveStr::Ascii("ieldly"),
        dictgen::InsensitiveStr::Ascii("irtten"),
        dictgen::InsensitiveStr::Ascii("orhty"),
        dictgen::InsensitiveStr::Ascii("orthly"),
        dictgen::InsensitiveStr::Ascii("orty"),
        dictgen::InsensitiveStr::Ascii("raped"),
        dictgen::InsensitiveStr::Ascii("raping"),
        dictgen::InsensitiveStr::Ascii("rittern"),
        dictgen::InsensitiveStr::Ascii("rritten"),
    ],
    values: &[
        &["unwarranted"],
        &["unwieldy"],
        &["unwieldy"],
        &["unwritten"],
        &["unworthy"],
        &["unworthy"],
        &["unworthy"],
        &["unwrapped"],
        &["unwrapping"],
        &["unwritten"],
        &["unwritten"],
    ],
    range: 4..=8,
};

static WORD_UNV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNV_CHILDREN),
    value: None,
};

pub static WORD_UNV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ailable"),
        dictgen::InsensitiveStr::Ascii("alid"),
        dictgen::InsensitiveStr::Ascii("alidate"),
        dictgen::InsensitiveStr::Ascii("elievable"),
        dictgen::InsensitiveStr::Ascii("elievably"),
        dictgen::InsensitiveStr::Ascii("erfified"),
        dictgen::InsensitiveStr::Ascii("ersionned"),
        dictgen::InsensitiveStr::Ascii("ersoned"),
        dictgen::InsensitiveStr::Ascii("iersally"),
        dictgen::InsensitiveStr::Ascii("ierse"),
        dictgen::InsensitiveStr::Ascii("ierses"),
        dictgen::InsensitiveStr::Ascii("iersities"),
        dictgen::InsensitiveStr::Ascii("iersity"),
        dictgen::InsensitiveStr::Ascii("ulnerable"),
    ],
    values: &[
        &["unavailable"],
        &["invalid"],
        &["invalidate"],
        &["unbelievable"],
        &["unbelievably"],
        &["unverified"],
        &["unversioned"],
        &["unversioned"],
        &["universally"],
        &["universe"],
        &["universes"],
        &["universities"],
        &["university"],
        &["invulnerable"],
    ],
    range: 4..=9,
};

static WORD_UNU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNU_CHILDREN),
    value: None,
};

pub static WORD_UNU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("nsed"),
        dictgen::InsensitiveStr::Ascii("nsual"),
        dictgen::InsensitiveStr::Ascii("sabe"),
        dictgen::InsensitiveStr::Ascii("sal"),
        dictgen::InsensitiveStr::Ascii("sally"),
        dictgen::InsensitiveStr::Ascii("saully"),
        dictgen::InsensitiveStr::Ascii("seable"),
        dictgen::InsensitiveStr::Ascii("sre"),
        dictgen::InsensitiveStr::Ascii("suable"),
        dictgen::InsensitiveStr::Ascii("sualy"),
        dictgen::InsensitiveStr::Ascii("sued"),
    ],
    values: &[
        &["unused"],
        &["unused"],
        &["unusual"],
        &["unusable"],
        &["unusual"],
        &["unusually"],
        &["unusually"],
        &["unusable"],
        &["unsure"],
        &["unusable"],
        &["unusually"],
        &["unused"],
    ],
    range: 2..=6,
};

static WORD_UNT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNT_CHILDREN),
    value: None,
};

pub static WORD_UNT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("argetted"),
        dictgen::InsensitiveStr::Ascii("er"),
        dictgen::InsensitiveStr::Ascii("ill"),
        dictgen::InsensitiveStr::Ascii("ils"),
        dictgen::InsensitiveStr::Ascii("intuitive"),
        dictgen::InsensitiveStr::Ascii("oched"),
        dictgen::InsensitiveStr::Ascii("queue"),
        dictgen::InsensitiveStr::Ascii("rached"),
        dictgen::InsensitiveStr::Ascii("raind"),
        dictgen::InsensitiveStr::Ascii("ranslateable"),
        dictgen::InsensitiveStr::Ascii("rasform"),
        dictgen::InsensitiveStr::Ascii("rasformed"),
        dictgen::InsensitiveStr::Ascii("rasposed"),
        dictgen::InsensitiveStr::Ascii("rianed"),
        dictgen::InsensitiveStr::Ascii("rustworty"),
    ],
    values: &[
        &["untargeted"],
        &["under"],
        &["until"],
        &["until", "utils"],
        &["unintuitive"],
        &["untouched"],
        &["unqueue"],
        &["untracked"],
        &["untrained"],
        &["untranslatable"],
        &["untransform"],
        &["untransformed"],
        &["untransposed"],
        &["untrained"],
        &["untrustworthy"],
    ],
    range: 2..=12,
};

static WORD_UNS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_UNS_CHILDREN),
    value: None,
};

static WORD_UNS_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_UNSA_NODE),
    None,
    Some(&WORD_UNSC_NODE),
    None,
    Some(&WORD_UNSE_NODE),
    None,
    None,
    Some(&WORD_UNSH_NODE),
    Some(&WORD_UNSI_NODE),
    None,
    None,
    Some(&WORD_UNSL_NODE),
    None,
    None,
    Some(&WORD_UNSO_NODE),
    Some(&WORD_UNSP_NODE),
    None,
    None,
    Some(&WORD_UNSS_NODE),
    Some(&WORD_UNST_NODE),
    Some(&WORD_UNSU_NODE),
    None,
    Some(&WORD_UNSW_NODE),
    None,
    Some(&WORD_UNSY_NODE),
    None,
];

static WORD_UNSY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNSY_CHILDREN),
    value: None,
};

pub static WORD_UNSY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("chronise"),
        dictgen::InsensitiveStr::Ascii("chronised"),
        dictgen::InsensitiveStr::Ascii("chronize"),
        dictgen::InsensitiveStr::Ascii("chronized"),
    ],
    values: &[
        &["unsynchronise"],
        &["unsynchronised"],
        &["unsynchronize"],
        &["unsynchronized"],
    ],
    range: 8..=9,
};

static WORD_UNSW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNSW_CHILDREN),
    value: None,
};

pub static WORD_UNSW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ithced")],
    values: &[&["unswitched"]],
    range: 6..=6,
};

static WORD_UNSU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_UNSU_CHILDREN),
    value: None,
};

static WORD_UNSU_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_UNSUA_NODE),
    Some(&WORD_UNSUB_NODE),
    Some(&WORD_UNSUC_NODE),
    None,
    Some(&WORD_UNSUE_NODE),
    Some(&WORD_UNSUF_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_UNSUN_NODE),
    None,
    Some(&WORD_UNSUP_NODE),
    None,
    Some(&WORD_UNSUR_NODE),
    Some(&WORD_UNSUS_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_UNSUS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNSUS_CHILDREN),
    value: None,
};

pub static WORD_UNSUS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("bcribe"),
        dictgen::InsensitiveStr::Ascii("bcribed"),
        dictgen::InsensitiveStr::Ascii("btantiated"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("tainble"),
        dictgen::InsensitiveStr::Ascii("tainible"),
        dictgen::InsensitiveStr::Ascii("tianable"),
    ],
    values: &[
        &["unsubscribe"],
        &["unsubscribed"],
        &["unsubstantiated"],
        &["unused"],
        &["unsustainable"],
        &["unsustainable"],
        &["unsustainable"],
    ],
    range: 2..=10,
};

static WORD_UNSUR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNSUR_CHILDREN),
    value: None,
};

pub static WORD_UNSUR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("prized"),
        dictgen::InsensitiveStr::Ascii("prizing"),
        dictgen::InsensitiveStr::Ascii("prizingly"),
    ],
    values: &[&["unsurprised"], &["unsurprising"], &["unsurprisingly"]],
    range: 6..=9,
};

static WORD_UNSUP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNSUP_CHILDREN),
    value: None,
};

pub static WORD_UNSUP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ortable"),
        dictgen::InsensitiveStr::Ascii("orted"),
        dictgen::InsensitiveStr::Ascii("port"),
        dictgen::InsensitiveStr::Ascii("proted"),
        dictgen::InsensitiveStr::Ascii("prted"),
        dictgen::InsensitiveStr::Ascii("ress"),
        dictgen::InsensitiveStr::Ascii("ressed"),
        dictgen::InsensitiveStr::Ascii("resses"),
        dictgen::InsensitiveStr::Ascii("rised"),
        dictgen::InsensitiveStr::Ascii("rising"),
        dictgen::InsensitiveStr::Ascii("risingly"),
        dictgen::InsensitiveStr::Ascii("rized"),
        dictgen::InsensitiveStr::Ascii("rizing"),
        dictgen::InsensitiveStr::Ascii("rizingly"),
    ],
    values: &[
        &["unsupportable"],
        &["unsupported"],
        &["unsupported"],
        &["unsupported"],
        &["unsupported"],
        &["unsuppress"],
        &["unsuppressed"],
        &["unsuppresses"],
        &["unsurprised"],
        &["unsurprising"],
        &["unsurprisingly"],
        &["unsurprised"],
        &["unsurprising"],
        &["unsurprisingly"],
    ],
    range: 4..=8,
};

static WORD_UNSUN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNSUN_CHILDREN),
    value: None,
};

pub static WORD_UNSUN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("scribe"),
        dictgen::InsensitiveStr::Ascii("scribed"),
    ],
    values: &[&["unsubscribe"], &["unsubscribed"]],
    range: 6..=7,
};

static WORD_UNSUF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNSUF_CHILDREN),
    value: None,
};

pub static WORD_UNSUF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ficient")],
    values: &[&["insufficient"]],
    range: 7..=7,
};

static WORD_UNSUE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNSUE_CHILDREN),
    value: None,
};

pub static WORD_UNSUE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("d")],
    values: &[&["unused"]],
    range: 1..=1,
};

static WORD_UNSUC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNSUC_CHILDREN),
    value: None,
};

pub static WORD_UNSUC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ccessful"),
        dictgen::InsensitiveStr::Ascii("ccessfully"),
        dictgen::InsensitiveStr::Ascii("ccessul"),
        dictgen::InsensitiveStr::Ascii("ccessully"),
        dictgen::InsensitiveStr::Ascii("cee"),
        dictgen::InsensitiveStr::Ascii("ceed"),
        dictgen::InsensitiveStr::Ascii("ceedde"),
        dictgen::InsensitiveStr::Ascii("ceeded"),
        dictgen::InsensitiveStr::Ascii("ceeds"),
        dictgen::InsensitiveStr::Ascii("ceeed"),
        dictgen::InsensitiveStr::Ascii("cees"),
        dictgen::InsensitiveStr::Ascii("cesful"),
        dictgen::InsensitiveStr::Ascii("cesfull"),
        dictgen::InsensitiveStr::Ascii("cesfully"),
        dictgen::InsensitiveStr::Ascii("cess"),
        dictgen::InsensitiveStr::Ascii("cessfull"),
        dictgen::InsensitiveStr::Ascii("cessfullly"),
        dictgen::InsensitiveStr::Ascii("cessul"),
        dictgen::InsensitiveStr::Ascii("esful"),
        dictgen::InsensitiveStr::Ascii("esfull"),
        dictgen::InsensitiveStr::Ascii("esfully"),
        dictgen::InsensitiveStr::Ascii("esfuly"),
        dictgen::InsensitiveStr::Ascii("essefully"),
        dictgen::InsensitiveStr::Ascii("essflly"),
        dictgen::InsensitiveStr::Ascii("essfually"),
        dictgen::InsensitiveStr::Ascii("essful"),
        dictgen::InsensitiveStr::Ascii("essfull"),
        dictgen::InsensitiveStr::Ascii("essfully"),
        dictgen::InsensitiveStr::Ascii("essfuly"),
        dictgen::InsensitiveStr::Ascii("esssful"),
        dictgen::InsensitiveStr::Ascii("esssfull"),
        dictgen::InsensitiveStr::Ascii("esssfully"),
        dictgen::InsensitiveStr::Ascii("esssfuly"),
        dictgen::InsensitiveStr::Ascii("essufll"),
        dictgen::InsensitiveStr::Ascii("essuflly"),
        dictgen::InsensitiveStr::Ascii("essully"),
    ],
    values: &[
        &["unsuccessful"],
        &["unsuccessfully"],
        &["unsuccessful"],
        &["unsuccessfully"],
        &["unsuccessful"],
        &["unsuccessful"],
        &["unsuccessful"],
        &["unsuccessful"],
        &["unsuccessful"],
        &["unsuccessful"],
        &["unsuccessful"],
        &["unsuccessful"],
        &["unsuccessful"],
        &["unsuccessfully"],
        &["unsuccessful"],
        &["unsuccessful"],
        &["unsuccessfully"],
        &["unsuccessful"],
        &["unsuccessful"],
        &["unsuccessful"],
        &["unsuccessfully"],
        &["unsuccessfully"],
        &["unsuccessfully"],
        &["unsuccessfully"],
        &["unsuccessfully"],
        &["unsuccessful"],
        &["unsuccessful"],
        &["unsuccessfully"],
        &["unsuccessfully"],
        &["unsuccessful"],
        &["unsuccessful"],
        &["unsuccessfully"],
        &["unsuccessfully"],
        &["unsuccessful"],
        &["unsuccessfully"],
        &["unsuccessfully"],
    ],
    range: 3..=10,
};

static WORD_UNSUB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNSUB_CHILDREN),
    value: None,
};

pub static WORD_UNSUB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("scibe"),
        dictgen::InsensitiveStr::Ascii("scibed"),
        dictgen::InsensitiveStr::Ascii("scibing"),
        dictgen::InsensitiveStr::Ascii("scirbe"),
        dictgen::InsensitiveStr::Ascii("scirbed"),
        dictgen::InsensitiveStr::Ascii("scirbing"),
        dictgen::InsensitiveStr::Ascii("scirption"),
        dictgen::InsensitiveStr::Ascii("scirptions"),
        dictgen::InsensitiveStr::Ascii("scrbe"),
        dictgen::InsensitiveStr::Ascii("scrbed"),
        dictgen::InsensitiveStr::Ascii("scribade"),
        dictgen::InsensitiveStr::Ascii("scribbed"),
        dictgen::InsensitiveStr::Ascii("scrible"),
        dictgen::InsensitiveStr::Ascii("scrided"),
        dictgen::InsensitiveStr::Ascii("scried"),
        dictgen::InsensitiveStr::Ascii("scripe"),
        dictgen::InsensitiveStr::Ascii("scriped"),
        dictgen::InsensitiveStr::Ascii("scritpion"),
        dictgen::InsensitiveStr::Ascii("scritpions"),
        dictgen::InsensitiveStr::Ascii("scritpiton"),
        dictgen::InsensitiveStr::Ascii("scritpitons"),
        dictgen::InsensitiveStr::Ascii("scritption"),
        dictgen::InsensitiveStr::Ascii("scritptions"),
        dictgen::InsensitiveStr::Ascii("scrive"),
        dictgen::InsensitiveStr::Ascii("scrube"),
        dictgen::InsensitiveStr::Ascii("scrubed"),
        dictgen::InsensitiveStr::Ascii("srcibe"),
        dictgen::InsensitiveStr::Ascii("srcibed"),
        dictgen::InsensitiveStr::Ascii("sribe"),
        dictgen::InsensitiveStr::Ascii("stanciated"),
        dictgen::InsensitiveStr::Ascii("stansiated"),
        dictgen::InsensitiveStr::Ascii("stantiaed"),
        dictgen::InsensitiveStr::Ascii("stantianted"),
        dictgen::InsensitiveStr::Ascii("stantiative"),
    ],
    values: &[
        &["unsubscribe"],
        &["unsubscribed"],
        &["unsubscribing"],
        &["unsubscribe"],
        &["unsubscribed"],
        &["unsubscribing"],
        &["unsubscription"],
        &["unsubscriptions"],
        &["unsubscribe"],
        &["unsubscribed"],
        &["unsubscribed"],
        &["unsubscribe"],
        &["unsubscribed"],
        &["unsubscribed"],
        &["unsubscribed"],
        &["unsubscribe"],
        &["unsubscribed"],
        &["unsubscription"],
        &["unsubscriptions"],
        &["unsubscription"],
        &["unsubscriptions"],
        &["unsubscription"],
        &["unsubscriptions"],
        &["unsubscribe"],
        &["unsubscribe"],
        &["unsubscribed"],
        &["unsubscribe"],
        &["unsubscribed"],
        &["unsubscribe"],
        &["unsubstantiated"],
        &["unsubstantiated"],
        &["unsubstantiated"],
        &["unsubstantiated"],
        &["unsubstantiated"],
    ],
    range: 5..=11,
};

static WORD_UNSUA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNSUA_CHILDREN),
    value: None,
};

pub static WORD_UNSUA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ble"),
        dictgen::InsensitiveStr::Ascii("l"),
    ],
    values: &[&["unusable"], &["unusual"]],
    range: 1..=3,
};

static WORD_UNST_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNST_CHILDREN),
    value: None,
};

pub static WORD_UNST_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("abel"),
        dictgen::InsensitiveStr::Ascii("albe"),
        dictgen::InsensitiveStr::Ascii("all"),
        dictgen::InsensitiveStr::Ascii("allation"),
        dictgen::InsensitiveStr::Ascii("alled"),
        dictgen::InsensitiveStr::Ascii("aller"),
        dictgen::InsensitiveStr::Ascii("alles"),
        dictgen::InsensitiveStr::Ascii("alling"),
        dictgen::InsensitiveStr::Ascii("alls"),
        dictgen::InsensitiveStr::Ascii("ruction"),
        dictgen::InsensitiveStr::Ascii("ructions"),
    ],
    values: &[
        &["unstable"],
        &["unstable"],
        &["install", "uninstall"],
        &["installation", "uninstallation"],
        &["installed", "uninstalled"],
        &["installer", "uninstaller"],
        &["installs", "uninstalls"],
        &["installing", "uninstalling"],
        &["installs", "uninstalls"],
        &["instruction"],
        &["instructions"],
    ],
    range: 3..=8,
};

static WORD_UNSS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNSS_CHILDREN),
    value: None,
};

pub static WORD_UNSS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("upported")],
    values: &[&["unsupported"]],
    range: 8..=8,
};

static WORD_UNSP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNSP_CHILDREN),
    value: None,
};

pub static WORD_UNSP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ecializated"),
        dictgen::InsensitiveStr::Ascii("ecificed"),
        dictgen::InsensitiveStr::Ascii("ecifiec"),
        dictgen::InsensitiveStr::Ascii("ecifiecd"),
        dictgen::InsensitiveStr::Ascii("ecifieced"),
        dictgen::InsensitiveStr::Ascii("efcifieid"),
        dictgen::InsensitiveStr::Ascii("efeid"),
        dictgen::InsensitiveStr::Ascii("eficed"),
        dictgen::InsensitiveStr::Ascii("eficeid"),
        dictgen::InsensitiveStr::Ascii("eficialleid"),
        dictgen::InsensitiveStr::Ascii("eficiallied"),
        dictgen::InsensitiveStr::Ascii("eficiallifed"),
        dictgen::InsensitiveStr::Ascii("eficied"),
        dictgen::InsensitiveStr::Ascii("eficieid"),
        dictgen::InsensitiveStr::Ascii("eficifed"),
        dictgen::InsensitiveStr::Ascii("eficifeid"),
        dictgen::InsensitiveStr::Ascii("eficified"),
        dictgen::InsensitiveStr::Ascii("eficififed"),
        dictgen::InsensitiveStr::Ascii("eficiied"),
        dictgen::InsensitiveStr::Ascii("eficiifed"),
        dictgen::InsensitiveStr::Ascii("eficilleid"),
        dictgen::InsensitiveStr::Ascii("eficillied"),
        dictgen::InsensitiveStr::Ascii("eficillifed"),
        dictgen::InsensitiveStr::Ascii("eficiteid"),
        dictgen::InsensitiveStr::Ascii("eficitied"),
        dictgen::InsensitiveStr::Ascii("eficitifed"),
        dictgen::InsensitiveStr::Ascii("efied"),
        dictgen::InsensitiveStr::Ascii("efifed"),
        dictgen::InsensitiveStr::Ascii("efifeid"),
        dictgen::InsensitiveStr::Ascii("efified"),
        dictgen::InsensitiveStr::Ascii("efififed"),
        dictgen::InsensitiveStr::Ascii("efiied"),
        dictgen::InsensitiveStr::Ascii("efiifeid"),
        dictgen::InsensitiveStr::Ascii("efiified"),
        dictgen::InsensitiveStr::Ascii("efiififed"),
        dictgen::InsensitiveStr::Ascii("efixeid"),
        dictgen::InsensitiveStr::Ascii("efixied"),
        dictgen::InsensitiveStr::Ascii("efixifed"),
        dictgen::InsensitiveStr::Ascii("ported"),
    ],
    values: &[
        &["unspecialized"],
        &["unspecified"],
        &["unspecific"],
        &["unspecified"],
        &["unspecified"],
        &["unspecified"],
        &["unspecified"],
        &["unspecified"],
        &["unspecified"],
        &["unspecified"],
        &["unspecified"],
        &["unspecified"],
        &["unspecified"],
        &["unspecified"],
        &["unspecified"],
        &["unspecified"],
        &["unspecified"],
        &["unspecified"],
        &["unspecified"],
        &["unspecified"],
        &["unspecified"],
        &["unspecified"],
        &["unspecified"],
        &["unspecified"],
        &["unspecified"],
        &["unspecified"],
        &["unspecified"],
        &["unspecified"],
        &["unspecified"],
        &["unspecified"],
        &["unspecified"],
        &["unspecified"],
        &["unspecified"],
        &["unspecified"],
        &["unspecified"],
        &["unspecified"],
        &["unspecified"],
        &["unspecified"],
        &["unsupported"],
    ],
    range: 5..=12,
};

static WORD_UNSO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNSO_CHILDREN),
    value: None,
};

pub static WORD_UNSO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("clicited"),
        dictgen::InsensitiveStr::Ascii("licated"),
        dictgen::InsensitiveStr::Ascii("liciated"),
        dictgen::InsensitiveStr::Ascii("licitied"),
        dictgen::InsensitiveStr::Ascii("licted"),
        dictgen::InsensitiveStr::Ascii("liticed"),
        dictgen::InsensitiveStr::Ascii("llicited"),
        dictgen::InsensitiveStr::Ascii("locited"),
    ],
    values: &[
        &["unsolicited"],
        &["unsolicited"],
        &["unsolicited"],
        &["unsolicited"],
        &["unsolicited"],
        &["unsolicited"],
        &["unsolicited"],
        &["unsolicited"],
    ],
    range: 6..=8,
};

static WORD_UNSL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNSL_CHILDREN),
    value: None,
};

pub static WORD_UNSL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ess")],
    values: &[&["unless", "useless"]],
    range: 3..=3,
};

static WORD_UNSI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNSI_CHILDREN),
    value: None,
};

pub static WORD_UNSI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("bscribed"),
        dictgen::InsensitiveStr::Ascii("bstantiated"),
        dictgen::InsensitiveStr::Ascii("ged"),
        dictgen::InsensitiveStr::Ascii("gend"),
        dictgen::InsensitiveStr::Ascii("gnd"),
        dictgen::InsensitiveStr::Ascii("gnificant"),
        dictgen::InsensitiveStr::Ascii("ng"),
        dictgen::InsensitiveStr::Ascii("nged"),
        dictgen::InsensitiveStr::Ascii("ntalled"),
        dictgen::InsensitiveStr::Ascii("stainable"),
    ],
    values: &[
        &["unsubscribed"],
        &["unsubstantiated"],
        &["unsigned"],
        &["unsigned"],
        &["unsigned"],
        &["insignificant"],
        &["unsigned", "using"],
        &["unsigned"],
        &["uninstalled"],
        &["unsustainable"],
    ],
    range: 2..=11,
};

static WORD_UNSH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNSH_CHILDREN),
    value: None,
};

pub static WORD_UNSH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("arable"),
        dictgen::InsensitiveStr::Ascii("fit"),
        dictgen::InsensitiveStr::Ascii("fited"),
        dictgen::InsensitiveStr::Ascii("fiting"),
        dictgen::InsensitiveStr::Ascii("fits"),
    ],
    values: &[
        &["unshareable"],
        &["unshift"],
        &["unshifted"],
        &["unshifting"],
        &["unshifts"],
    ],
    range: 3..=6,
};

static WORD_UNSE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNSE_CHILDREN),
    value: None,
};

pub static WORD_UNSE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("arcahble"),
        dictgen::InsensitiveStr::Ascii("ccessful"),
        dictgen::InsensitiveStr::Ascii("d"),
        dictgen::InsensitiveStr::Ascii("lct"),
        dictgen::InsensitiveStr::Ascii("lcted"),
        dictgen::InsensitiveStr::Ascii("lctes"),
        dictgen::InsensitiveStr::Ascii("lcting"),
        dictgen::InsensitiveStr::Ascii("lcts"),
        dictgen::InsensitiveStr::Ascii("lecgt"),
        dictgen::InsensitiveStr::Ascii("lecgted"),
        dictgen::InsensitiveStr::Ascii("lecgtes"),
        dictgen::InsensitiveStr::Ascii("lecgting"),
        dictgen::InsensitiveStr::Ascii("lecgts"),
        dictgen::InsensitiveStr::Ascii("lectabe"),
        dictgen::InsensitiveStr::Ascii("ncored"),
        dictgen::InsensitiveStr::Ascii("pcified"),
        dictgen::InsensitiveStr::Ascii("r"),
        dictgen::InsensitiveStr::Ascii("specting"),
        dictgen::InsensitiveStr::Ascii("ting"),
        dictgen::InsensitiveStr::Ascii("tlling"),
        dictgen::InsensitiveStr::Ascii("tset"),
        dictgen::InsensitiveStr::Ascii("ttin"),
        dictgen::InsensitiveStr::Ascii("ttleing"),
    ],
    values: &[
        &["unsearchable"],
        &["unsuccessful"],
        &["used", "unused", "unset"],
        &["unselect"],
        &["unselected"],
        &["unselects"],
        &["unselecting"],
        &["unselects"],
        &["unselect"],
        &["unselected"],
        &["unselects"],
        &["unselecting"],
        &["unselects"],
        &["unselectable"],
        &["uncensored"],
        &["unspecified"],
        &["under", "unset", "unsure", "user"],
        &["unsuspecting"],
        &["unsetting"],
        &["unsettling"],
        &["unset"],
        &["unsetting"],
        &["unsettling"],
    ],
    range: 1..=8,
};

static WORD_UNSC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNSC_CHILDREN),
    value: None,
};

pub static WORD_UNSC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cessful"),
        dictgen::InsensitiveStr::Ascii("ubscribe"),
        dictgen::InsensitiveStr::Ascii("ubscribed"),
    ],
    values: &[&["unsuccessful"], &["subscribe"], &["subscribed"]],
    range: 7..=9,
};

static WORD_UNSA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNSA_CHILDREN),
    value: None,
};

pub static WORD_UNSA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ble"),
        dictgen::InsensitiveStr::Ascii("nfe"),
    ],
    values: &[&["unusable", "usable", "unstable", "unable"], &["unsafe"]],
    range: 3..=3,
};

static WORD_UNR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_UNR_CHILDREN),
    value: None,
};

static WORD_UNR_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_UNRA_NODE),
    None,
    None,
    None,
    Some(&WORD_UNRE_NODE),
    None,
    Some(&WORD_UNRG_NODE),
    None,
    Some(&WORD_UNRI_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_UNRN_NODE),
    Some(&WORD_UNRO_NODE),
    Some(&WORD_UNRP_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_UNRW_NODE),
    None,
    None,
    None,
];

static WORD_UNRW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNRW_CHILDREN),
    value: None,
};

pub static WORD_UNRW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("itten")],
    values: &[&["unwritten"]],
    range: 5..=5,
};

static WORD_UNRP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNRP_CHILDREN),
    value: None,
};

pub static WORD_UNRP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("oven")],
    values: &[&["unproven"]],
    range: 4..=4,
};

static WORD_UNRO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNRO_CHILDREN),
    value: None,
};

pub static WORD_UNRO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ated"),
        dictgen::InsensitiveStr::Ascii("sponsive"),
    ],
    values: &[&["unrotated"], &["unresponsive"]],
    range: 4..=8,
};

static WORD_UNRN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNRN_CHILDREN),
    value: None,
};

pub static WORD_UNRN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("aked")],
    values: &[&["unranked"]],
    range: 4..=4,
};

static WORD_UNRI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNRI_CHILDREN),
    value: None,
};

pub static WORD_UNRI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("stricted")],
    values: &[&["unrestricted"]],
    range: 8..=8,
};

static WORD_UNRG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNRG_CHILDREN),
    value: None,
};

pub static WORD_UNRG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("esiter")],
    values: &[&["unregister"]],
    range: 6..=6,
};

static WORD_UNRE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_UNRE_CHILDREN),
    value: None,
};

static WORD_UNRE_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_UNREA_NODE),
    None,
    Some(&WORD_UNREC_NODE),
    None,
    None,
    None,
    Some(&WORD_UNREG_NODE),
    None,
    Some(&WORD_UNREI_NODE),
    None,
    None,
    Some(&WORD_UNREL_NODE),
    None,
    None,
    None,
    Some(&WORD_UNREP_NODE),
    None,
    None,
    Some(&WORD_UNRES_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_UNRES_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNRES_CHILDREN),
    value: None,
};

pub static WORD_UNRES_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("gister"),
        dictgen::InsensitiveStr::Ascii("gisterd"),
        dictgen::InsensitiveStr::Ascii("gistered"),
        dictgen::InsensitiveStr::Ascii("gisters"),
        dictgen::InsensitiveStr::Ascii("olvabvle"),
        dictgen::InsensitiveStr::Ascii("onable"),
        dictgen::InsensitiveStr::Ascii("ovlable"),
        dictgen::InsensitiveStr::Ascii("ovled"),
        dictgen::InsensitiveStr::Ascii("poncive"),
        dictgen::InsensitiveStr::Ascii("ponisve"),
        dictgen::InsensitiveStr::Ascii("ponive"),
        dictgen::InsensitiveStr::Ascii("ponse"),
        dictgen::InsensitiveStr::Ascii("ponsibe"),
        dictgen::InsensitiveStr::Ascii("ponsivness"),
        dictgen::InsensitiveStr::Ascii("posive"),
        dictgen::InsensitiveStr::Ascii("tircted"),
        dictgen::InsensitiveStr::Ascii("trcited"),
        dictgen::InsensitiveStr::Ascii("triced"),
        dictgen::InsensitiveStr::Ascii("trictred"),
    ],
    values: &[
        &["unregister"],
        &["unregistered"],
        &["unregistered"],
        &["unregisters"],
        &["unresolvable"],
        &["unreasonable"],
        &["unresolvable"],
        &["unresolved"],
        &["unresponsive"],
        &["unresponsive"],
        &["unresponsive"],
        &["unresponsive"],
        &["unresponsive"],
        &["unresponsive"],
        &["unresponsive"],
        &["unrestricted"],
        &["unrestricted"],
        &["unrestricted"],
        &["unrestricted"],
    ],
    range: 5..=10,
};

static WORD_UNREP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNREP_CHILDREN),
    value: None,
};

pub static WORD_UNREP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("entent"),
        dictgen::InsensitiveStr::Ascii("etant"),
        dictgen::InsensitiveStr::Ascii("etent"),
        dictgen::InsensitiveStr::Ascii("lacable"),
        dictgen::InsensitiveStr::Ascii("lacalbe"),
        dictgen::InsensitiveStr::Ascii("roducable"),
        dictgen::InsensitiveStr::Ascii("sonsive"),
    ],
    values: &[
        &["unrepentant"],
        &["unrepentant"],
        &["unrepentant"],
        &["unreplaceable"],
        &["unreplaceable"],
        &["unreproducible"],
        &["unresponsive"],
    ],
    range: 5..=9,
};

static WORD_UNREL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNREL_CHILDREN),
    value: None,
};

pub static WORD_UNREL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aible"),
        dictgen::InsensitiveStr::Ascii("atd"),
        dictgen::InsensitiveStr::Ascii("eated"),
        dictgen::InsensitiveStr::Ascii("iabe"),
        dictgen::InsensitiveStr::Ascii("ted"),
        dictgen::InsensitiveStr::Ascii("yable"),
        dictgen::InsensitiveStr::Ascii("ying"),
    ],
    values: &[
        &["unreliable"],
        &["unrelated"],
        &["unreleased", "unrelated"],
        &["unreliable"],
        &["unrelated"],
        &["unreliable"],
        &["underlying"],
    ],
    range: 3..=5,
};

static WORD_UNREI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNREI_CHILDREN),
    value: None,
};

pub static WORD_UNREI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("gister"),
        dictgen::InsensitiveStr::Ascii("gster"),
        dictgen::InsensitiveStr::Ascii("gstered"),
        dictgen::InsensitiveStr::Ascii("gstering"),
        dictgen::InsensitiveStr::Ascii("gsters"),
    ],
    values: &[
        &["unregister"],
        &["unregister"],
        &["unregistered"],
        &["unregistering"],
        &["unregisters"],
    ],
    range: 5..=8,
};

static WORD_UNREG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNREG_CHILDREN),
    value: None,
};

pub static WORD_UNREG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ester"),
        dictgen::InsensitiveStr::Ascii("iste"),
        dictgen::InsensitiveStr::Ascii("isted"),
        dictgen::InsensitiveStr::Ascii("isteing"),
        dictgen::InsensitiveStr::Ascii("isterd"),
        dictgen::InsensitiveStr::Ascii("isteres"),
        dictgen::InsensitiveStr::Ascii("istert"),
        dictgen::InsensitiveStr::Ascii("istes"),
        dictgen::InsensitiveStr::Ascii("isting"),
        dictgen::InsensitiveStr::Ascii("istred"),
        dictgen::InsensitiveStr::Ascii("istrs"),
        dictgen::InsensitiveStr::Ascii("iter"),
        dictgen::InsensitiveStr::Ascii("iters"),
        dictgen::InsensitiveStr::Ascii("luated"),
        dictgen::InsensitiveStr::Ascii("nized"),
        dictgen::InsensitiveStr::Ascii("ognised"),
        dictgen::InsensitiveStr::Ascii("siter"),
        dictgen::InsensitiveStr::Ascii("sitered"),
        dictgen::InsensitiveStr::Ascii("sitering"),
        dictgen::InsensitiveStr::Ascii("siters"),
        dictgen::InsensitiveStr::Ascii("ster"),
        dictgen::InsensitiveStr::Ascii("stered"),
        dictgen::InsensitiveStr::Ascii("stering"),
        dictgen::InsensitiveStr::Ascii("sters"),
        dictgen::InsensitiveStr::Ascii("ualted"),
        dictgen::InsensitiveStr::Ascii("ulared"),
    ],
    values: &[
        &["unregister"],
        &["unregister"],
        &["unregistered"],
        &["registering"],
        &["unregistered"],
        &["unregisters", "unregistered"],
        &["unregistered"],
        &["unregisters"],
        &["unregistering"],
        &["unregistered"],
        &["unregisters"],
        &["unregister"],
        &["unregisters"],
        &["unregulated"],
        &["unrecognized"],
        &["unrecognised"],
        &["unregister"],
        &["unregistered"],
        &["unregistering"],
        &["unregisters"],
        &["unregister"],
        &["unregistered"],
        &["unregistering"],
        &["unregisters"],
        &["unregulated"],
        &["unregulated"],
    ],
    range: 4..=8,
};

static WORD_UNREC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNREC_CHILDREN),
    value: None,
};

pub static WORD_UNREC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("hable"),
        dictgen::InsensitiveStr::Ascii("ocnized"),
        dictgen::InsensitiveStr::Ascii("oginized"),
        dictgen::InsensitiveStr::Ascii("ogized"),
        dictgen::InsensitiveStr::Ascii("ognixed"),
        dictgen::InsensitiveStr::Ascii("ongized"),
        dictgen::InsensitiveStr::Ascii("onized"),
        dictgen::InsensitiveStr::Ascii("ovable"),
        dictgen::InsensitiveStr::Ascii("ovarable"),
        dictgen::InsensitiveStr::Ascii("overd"),
    ],
    values: &[
        &["unreachable"],
        &["unrecognized"],
        &["unrecognized"],
        &["unrecognized"],
        &["unrecognized"],
        &["unrecognized"],
        &["unrecognized"],
        &["unrecoverable"],
        &["unrecoverable"],
        &["unrecovered"],
    ],
    range: 5..=8,
};

static WORD_UNREA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNREA_CHILDREN),
    value: None,
};

pub static WORD_UNREA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cahable"),
        dictgen::InsensitiveStr::Ascii("cahble"),
        dictgen::InsensitiveStr::Ascii("cheable"),
        dictgen::InsensitiveStr::Ascii("leased"),
        dictgen::InsensitiveStr::Ascii("lesed"),
        dictgen::InsensitiveStr::Ascii("lible"),
        dictgen::InsensitiveStr::Ascii("lisitc"),
        dictgen::InsensitiveStr::Ascii("lisitic"),
        dictgen::InsensitiveStr::Ascii("listc"),
        dictgen::InsensitiveStr::Ascii("listisch"),
        dictgen::InsensitiveStr::Ascii("litic"),
        dictgen::InsensitiveStr::Ascii("lsitic"),
        dictgen::InsensitiveStr::Ascii("ponsive"),
        dictgen::InsensitiveStr::Ascii("sonabily"),
        dictgen::InsensitiveStr::Ascii("sonablely"),
        dictgen::InsensitiveStr::Ascii("sonabley"),
        dictgen::InsensitiveStr::Ascii("sonablly"),
        dictgen::InsensitiveStr::Ascii("sonal"),
        dictgen::InsensitiveStr::Ascii("sonalby"),
        dictgen::InsensitiveStr::Ascii("sonbly"),
    ],
    values: &[
        &["unreachable"],
        &["unreachable"],
        &["unreachable"],
        &["unreleased"],
        &["unreleased"],
        &["unreliable"],
        &["unrealistic"],
        &["unrealistic"],
        &["unrealistic"],
        &["unrealistic"],
        &["unrealistic"],
        &["unrealistic"],
        &["unresponsive"],
        &["unreasonably"],
        &["unreasonably"],
        &["unreasonably"],
        &["unreasonably"],
        &["unreasonably"],
        &["unreasonably"],
        &["unreasonably"],
    ],
    range: 5..=9,
};

static WORD_UNRA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNRA_CHILDREN),
    value: None,
};

pub static WORD_UNRA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("kned"),
        dictgen::InsensitiveStr::Ascii("nkend"),
    ],
    values: &[&["unranked"], &["unranked"]],
    range: 4..=5,
};

static WORD_UNQ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNQ_CHILDREN),
    value: None,
};

pub static WORD_UNQ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aulified"),
        dictgen::InsensitiveStr::Ascii("iue"),
        dictgen::InsensitiveStr::Ascii("iuely"),
        dictgen::InsensitiveStr::Ascii("iueness"),
        dictgen::InsensitiveStr::Ascii("oute"),
        dictgen::InsensitiveStr::Ascii("outed"),
        dictgen::InsensitiveStr::Ascii("outes"),
        dictgen::InsensitiveStr::Ascii("outing"),
        dictgen::InsensitiveStr::Ascii("ualifed"),
        dictgen::InsensitiveStr::Ascii("ue"),
    ],
    values: &[
        &["unqualified"],
        &["unique"],
        &["uniquely"],
        &["uniqueness"],
        &["unquote"],
        &["unquoted"],
        &["unquotes"],
        &["unquoting"],
        &["unqualified"],
        &["unique"],
    ],
    range: 2..=8,
};

static WORD_UNP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNP_CHILDREN),
    value: None,
};

pub static WORD_UNP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("acke"),
        dictgen::InsensitiveStr::Ascii("acket"),
        dictgen::InsensitiveStr::Ascii("arseable"),
        dictgen::InsensitiveStr::Ascii("ertubated"),
        dictgen::InsensitiveStr::Ascii("erturb"),
        dictgen::InsensitiveStr::Ascii("erturbated"),
        dictgen::InsensitiveStr::Ascii("erturbe"),
        dictgen::InsensitiveStr::Ascii("lacable"),
        dictgen::InsensitiveStr::Ascii("layabe"),
        dictgen::InsensitiveStr::Ascii("laybale"),
        dictgen::InsensitiveStr::Ascii("layeble"),
        dictgen::InsensitiveStr::Ascii("lease"),
        dictgen::InsensitiveStr::Ascii("leaseant"),
        dictgen::InsensitiveStr::Ascii("leasent"),
        dictgen::InsensitiveStr::Ascii("lesant"),
        dictgen::InsensitiveStr::Ascii("lesent"),
        dictgen::InsensitiveStr::Ascii("oened"),
        dictgen::InsensitiveStr::Ascii("opluar"),
        dictgen::InsensitiveStr::Ascii("opulair"),
        dictgen::InsensitiveStr::Ascii("ortected"),
        dictgen::InsensitiveStr::Ascii("recendented"),
        dictgen::InsensitiveStr::Ascii("recendeted"),
        dictgen::InsensitiveStr::Ascii("recidented"),
        dictgen::InsensitiveStr::Ascii("recise"),
        dictgen::InsensitiveStr::Ascii("redecented"),
        dictgen::InsensitiveStr::Ascii("redicable"),
        dictgen::InsensitiveStr::Ascii("redicatable"),
        dictgen::InsensitiveStr::Ascii("redicatble"),
        dictgen::InsensitiveStr::Ascii("redictabe"),
        dictgen::InsensitiveStr::Ascii("redictablity"),
        dictgen::InsensitiveStr::Ascii("redictible"),
        dictgen::InsensitiveStr::Ascii("reductive"),
        dictgen::InsensitiveStr::Ascii("repaired"),
        dictgen::InsensitiveStr::Ascii("reparred"),
        dictgen::InsensitiveStr::Ascii("resedented"),
        dictgen::InsensitiveStr::Ascii("ridictable"),
        dictgen::InsensitiveStr::Ascii("riviledged"),
        dictgen::InsensitiveStr::Ascii("riviliged"),
        dictgen::InsensitiveStr::Ascii("rmopted"),
        dictgen::InsensitiveStr::Ascii("robable"),
        dictgen::InsensitiveStr::Ascii("robably"),
        dictgen::InsensitiveStr::Ascii("roducive"),
        dictgen::InsensitiveStr::Ascii("roduktive"),
        dictgen::InsensitiveStr::Ascii("rofessinal"),
        dictgen::InsensitiveStr::Ascii("rofessionel"),
        dictgen::InsensitiveStr::Ascii("rofessionnal"),
        dictgen::InsensitiveStr::Ascii("rone"),
        dictgen::InsensitiveStr::Ascii("roteced"),
        dictgen::InsensitiveStr::Ascii("rotexted"),
    ],
    values: &[
        &["unpacked"],
        &["unpacked"],
        &["unparsable"],
        &["unperturbed"],
        &["unperturbed"],
        &["unperturbed"],
        &["unperturbed"],
        &["unplayable"],
        &["unplayable"],
        &["unplayable"],
        &["unplayable"],
        &["displease"],
        &["unpleasant"],
        &["unpleasant"],
        &["unpleasant"],
        &["unpleasant"],
        &["unopened"],
        &["unpopular"],
        &["unpopular"],
        &["unprotected"],
        &["unprecedented"],
        &["unprecedented"],
        &["unprecedented"],
        &["imprecise"],
        &["unprecedented"],
        &["unpredictable"],
        &["unpredictable"],
        &["unpredictable"],
        &["unpredictable"],
        &["unpredictability"],
        &["unpredictable"],
        &["unproductive"],
        &["unprepared"],
        &["unprepared"],
        &["unprecedented"],
        &["unpredictable"],
        &["unprivileged"],
        &["unprivileged"],
        &["unprompted"],
        &["improbable", "unprovable"],
        &["improbably"],
        &["unproductive"],
        &["unproductive"],
        &["unprofessional"],
        &["unprofessional"],
        &["unprofessional"],
        &["unproven"],
        &["unprotected"],
        &["unprotected"],
    ],
    range: 4..=12,
};

static WORD_UNO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNO_CHILDREN),
    value: None,
};

pub static WORD_UNO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("bstrusive"),
        dictgen::InsensitiveStr::Ascii("cde"),
        dictgen::InsensitiveStr::Ascii("fficail"),
        dictgen::InsensitiveStr::Ascii("ffical"),
        dictgen::InsensitiveStr::Ascii("ffocial"),
        dictgen::InsensitiveStr::Ascii("ficcial"),
        dictgen::InsensitiveStr::Ascii("in"),
        dictgen::InsensitiveStr::Ascii("mpress"),
        dictgen::InsensitiveStr::Ascii("pend"),
        dictgen::InsensitiveStr::Ascii("penend"),
        dictgen::InsensitiveStr::Ascii("perational"),
        dictgen::InsensitiveStr::Ascii("ptimice"),
        dictgen::InsensitiveStr::Ascii("ptimiced"),
        dictgen::InsensitiveStr::Ascii("rderd"),
        dictgen::InsensitiveStr::Ascii("redered"),
        dictgen::InsensitiveStr::Ascii("rginial"),
        dictgen::InsensitiveStr::Ascii("riginial"),
        dictgen::InsensitiveStr::Ascii("rigional"),
        dictgen::InsensitiveStr::Ascii("rignial"),
        dictgen::InsensitiveStr::Ascii("rigonal"),
        dictgen::InsensitiveStr::Ascii("rotated"),
        dictgen::InsensitiveStr::Ascii("ticeable"),
    ],
    values: &[
        &["unobtrusive"],
        &["unicode"],
        &["unofficial"],
        &["unofficial"],
        &["unofficial"],
        &["unofficial"],
        &["union"],
        &["uncompress"],
        &["unopened"],
        &["unopened"],
        &["nonoperational"],
        &["unoptimise", "unoptimize"],
        &["unoptimised", "unoptimized"],
        &["unordered"],
        &["unordered"],
        &["unoriginal"],
        &["unoriginal"],
        &["unoriginal"],
        &["unoriginal"],
        &["unoriginal"],
        &["unrotated"],
        &["unnoticeable"],
    ],
    range: 2..=10,
};

static WORD_UNN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNN_CHILDREN),
    value: None,
};

pub static WORD_UNN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("acquired"),
        dictgen::InsensitiveStr::Ascii("cessary"),
        dictgen::InsensitiveStr::Ascii("ecassarily"),
        dictgen::InsensitiveStr::Ascii("ecassary"),
        dictgen::InsensitiveStr::Ascii("eccecarily"),
        dictgen::InsensitiveStr::Ascii("eccecary"),
        dictgen::InsensitiveStr::Ascii("eccesarily"),
        dictgen::InsensitiveStr::Ascii("eccesary"),
        dictgen::InsensitiveStr::Ascii("eccessarily"),
        dictgen::InsensitiveStr::Ascii("eccessary"),
        dictgen::InsensitiveStr::Ascii("eceesarily"),
        dictgen::InsensitiveStr::Ascii("ecesarily"),
        dictgen::InsensitiveStr::Ascii("ecesarrily"),
        dictgen::InsensitiveStr::Ascii("ecesarry"),
        dictgen::InsensitiveStr::Ascii("ecesary"),
        dictgen::InsensitiveStr::Ascii("ecesasry"),
        dictgen::InsensitiveStr::Ascii("ecessairly"),
        dictgen::InsensitiveStr::Ascii("ecessairy"),
        dictgen::InsensitiveStr::Ascii("ecessar"),
        dictgen::InsensitiveStr::Ascii("ecessarely"),
        dictgen::InsensitiveStr::Ascii("ecessarilly"),
        dictgen::InsensitiveStr::Ascii("ecessarity"),
        dictgen::InsensitiveStr::Ascii("ecessarly"),
        dictgen::InsensitiveStr::Ascii("ecesserily"),
        dictgen::InsensitiveStr::Ascii("ecessery"),
        dictgen::InsensitiveStr::Ascii("ecessiarlly"),
        dictgen::InsensitiveStr::Ascii("ecissarily"),
        dictgen::InsensitiveStr::Ascii("ecissary"),
        dictgen::InsensitiveStr::Ascii("ecssary"),
        dictgen::InsensitiveStr::Ascii("edded"),
        dictgen::InsensitiveStr::Ascii("eded"),
        dictgen::InsensitiveStr::Ascii("eedingly"),
        dictgen::InsensitiveStr::Ascii("escessarily"),
        dictgen::InsensitiveStr::Ascii("escessary"),
        dictgen::InsensitiveStr::Ascii("esesarily"),
        dictgen::InsensitiveStr::Ascii("essarily"),
        dictgen::InsensitiveStr::Ascii("essasary"),
        dictgen::InsensitiveStr::Ascii("essecarily"),
        dictgen::InsensitiveStr::Ascii("essecarry"),
        dictgen::InsensitiveStr::Ascii("essecary"),
        dictgen::InsensitiveStr::Ascii("essesarily"),
        dictgen::InsensitiveStr::Ascii("essesary"),
        dictgen::InsensitiveStr::Ascii("essessarily"),
        dictgen::InsensitiveStr::Ascii("essessary"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("istall"),
        dictgen::InsensitiveStr::Ascii("istalled"),
        dictgen::InsensitiveStr::Ascii("istalling"),
        dictgen::InsensitiveStr::Ascii("necessary"),
        dictgen::InsensitiveStr::Ascii("own"),
        dictgen::InsensitiveStr::Ascii("owns"),
        dictgen::InsensitiveStr::Ascii("supported"),
        dictgen::InsensitiveStr::Ascii("used"),
    ],
    values: &[
        &["unacquired"],
        &["unnecessary"],
        &["unnecessarily"],
        &["unnecessary"],
        &["unnecessarily"],
        &["unnecessary"],
        &["unnecessarily"],
        &["unnecessary"],
        &["unnecessarily"],
        &["unnecessary"],
        &["unnecessarily"],
        &["unnecessarily"],
        &["unnecessarily"],
        &["unnecessary"],
        &["unnecessary"],
        &["unnecessary"],
        &["unnecessarily"],
        &["unnecessarily"],
        &["unnecessary"],
        &["unnecessarily"],
        &["unnecessarily"],
        &["unnecessarily"],
        &["unnecessarily"],
        &["unnecessarily"],
        &["unnecessary"],
        &["unnecessarily"],
        &["unnecessarily"],
        &["unnecessary"],
        &["unnecessary"],
        &["unneeded"],
        &["unneeded"],
        &["unnecessarily"],
        &["unnecessarily"],
        &["unnecessary"],
        &["unnecessarily"],
        &["unnecessarily"],
        &["unnecessary"],
        &["unnecessarily"],
        &["unnecessary"],
        &["unnecessary"],
        &["unnecessarily"],
        &["unnecessary"],
        &["unnecessarily"],
        &["unnecessary"],
        &["running"],
        &["uninstall"],
        &["uninstalled"],
        &["uninstalling"],
        &["unnecessary"],
        &["unknown"],
        &["unknowns"],
        &["unsupported"],
        &["unused"],
    ],
    range: 3..=11,
};

static WORD_UNM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNM_CHILDREN),
    value: None,
};

pub static WORD_UNM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ached"),
        dictgen::InsensitiveStr::Ascii("ainted"),
        dictgen::InsensitiveStr::Ascii("anouverable"),
        dictgen::InsensitiveStr::Ascii("aping"),
        dictgen::InsensitiveStr::Ascii("append"),
        dictgen::InsensitiveStr::Ascii("arsalling"),
        dictgen::InsensitiveStr::Ascii("arshaling"),
        dictgen::InsensitiveStr::Ascii("aximice"),
        dictgen::InsensitiveStr::Ascii("isakable"),
        dictgen::InsensitiveStr::Ascii("isakably"),
        dictgen::InsensitiveStr::Ascii("istakeably"),
        dictgen::InsensitiveStr::Ascii("odfide"),
        dictgen::InsensitiveStr::Ascii("odfided"),
        dictgen::InsensitiveStr::Ascii("odfied"),
        dictgen::InsensitiveStr::Ascii("odfieid"),
        dictgen::InsensitiveStr::Ascii("odfified"),
        dictgen::InsensitiveStr::Ascii("odfitied"),
        dictgen::InsensitiveStr::Ascii("odifable"),
        dictgen::InsensitiveStr::Ascii("odifed"),
        dictgen::InsensitiveStr::Ascii("outned"),
    ],
    values: &[
        &["unmatched"],
        &["unmaintained"],
        &["unmaneuverable", "unmanoeuvrable"],
        &["unmapping"],
        &["unmapped"],
        &["unmarshalling"],
        &["unmarshalling"],
        &["unmaximize"],
        &["unmistakable"],
        &["unmistakably"],
        &["unmistakably"],
        &["unmodified"],
        &["unmodified"],
        &["unmodified"],
        &["unmodified"],
        &["unmodified"],
        &["unmodified"],
        &["unmodifiable"],
        &["unmodified"],
        &["unmounted"],
    ],
    range: 5..=11,
};

static WORD_UNL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNL_CHILDREN),
    value: None,
};

pub static WORD_UNL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("abled"),
        dictgen::InsensitiveStr::Ascii("cean"),
        dictgen::InsensitiveStr::Ascii("cear"),
        dictgen::InsensitiveStr::Ascii("coks"),
        dictgen::InsensitiveStr::Ascii("cuky"),
        dictgen::InsensitiveStr::Ascii("eess"),
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("iaterally"),
        dictgen::InsensitiveStr::Ascii("ikey"),
        dictgen::InsensitiveStr::Ascii("ikley"),
        dictgen::InsensitiveStr::Ascii("imeted"),
        dictgen::InsensitiveStr::Ascii("imitied"),
        dictgen::InsensitiveStr::Ascii("imted"),
        dictgen::InsensitiveStr::Ascii("ine"),
        dictgen::InsensitiveStr::Ascii("oadins"),
        dictgen::InsensitiveStr::Ascii("ockes"),
        dictgen::InsensitiveStr::Ascii("uckly"),
    ],
    values: &[
        &["unlabeled"],
        &["unclean"],
        &["unclear"],
        &["unlocks"],
        &["unlucky"],
        &["unleash", "unless"],
        &["unless"],
        &["unilaterally"],
        &["unlikely"],
        &["unlikely"],
        &["unlimited"],
        &["unlimited"],
        &["unlimited"],
        &["unlike"],
        &["unloading"],
        &["unlocks"],
        &["unlucky"],
    ],
    range: 2..=9,
};

static WORD_UNK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNK_CHILDREN),
    value: None,
};

pub static WORD_UNK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("mown"),
        dictgen::InsensitiveStr::Ascii("non"),
        dictgen::InsensitiveStr::Ascii("nonw"),
        dictgen::InsensitiveStr::Ascii("nonwn"),
        dictgen::InsensitiveStr::Ascii("nonws"),
        dictgen::InsensitiveStr::Ascii("nouwn"),
        dictgen::InsensitiveStr::Ascii("nowingy"),
        dictgen::InsensitiveStr::Ascii("nowinlgy"),
        dictgen::InsensitiveStr::Ascii("nowinly"),
        dictgen::InsensitiveStr::Ascii("nowningly"),
        dictgen::InsensitiveStr::Ascii("nwn"),
        dictgen::InsensitiveStr::Ascii("nwns"),
        dictgen::InsensitiveStr::Ascii("nwoing"),
        dictgen::InsensitiveStr::Ascii("nwoingly"),
        dictgen::InsensitiveStr::Ascii("nwon"),
        dictgen::InsensitiveStr::Ascii("nwons"),
        dictgen::InsensitiveStr::Ascii("nwown"),
        dictgen::InsensitiveStr::Ascii("nwowns"),
        dictgen::InsensitiveStr::Ascii("onw"),
        dictgen::InsensitiveStr::Ascii("onwn"),
        dictgen::InsensitiveStr::Ascii("onwns"),
        dictgen::InsensitiveStr::Ascii("own"),
        dictgen::InsensitiveStr::Ascii("owningly"),
        dictgen::InsensitiveStr::Ascii("owns"),
        dictgen::InsensitiveStr::Ascii("wown"),
    ],
    values: &[
        &["unknown"],
        &["unknown"],
        &["unknown"],
        &["unknown"],
        &["unknowns"],
        &["unknown"],
        &["unknowingly"],
        &["unknowingly"],
        &["unknowingly"],
        &["unknowingly"],
        &["unknown"],
        &["unknowns"],
        &["unknowing"],
        &["unknowingly"],
        &["unknown"],
        &["unknowns"],
        &["unknown"],
        &["unknowns"],
        &["unknown"],
        &["unknown"],
        &["unknowns"],
        &["unknown"],
        &["unknowingly"],
        &["unknowns"],
        &["unknown"],
    ],
    range: 3..=9,
};

static WORD_UNJ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNJ_CHILDREN),
    value: None,
};

pub static WORD_UNJ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ustifed"),
        dictgen::InsensitiveStr::Ascii("ustifyed"),
    ],
    values: &[&["unjustified"], &["unjustified"]],
    range: 7..=8,
};

static WORD_UNI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_UNI_CHILDREN),
    value: None,
};

static WORD_UNI_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    Some(&WORD_UNIC_NODE),
    Some(&WORD_UNID_NODE),
    None,
    Some(&WORD_UNIF_NODE),
    Some(&WORD_UNIG_NODE),
    Some(&WORD_UNIH_NODE),
    None,
    None,
    None,
    Some(&WORD_UNIL_NODE),
    Some(&WORD_UNIM_NODE),
    Some(&WORD_UNIN_NODE),
    Some(&WORD_UNIO_NODE),
    None,
    Some(&WORD_UNIQ_NODE),
    None,
    Some(&WORD_UNIS_NODE),
    Some(&WORD_UNIT_NODE),
    None,
    Some(&WORD_UNIV_NODE),
    None,
    None,
    None,
    None,
];

static WORD_UNIV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNIV_CHILDREN),
    value: None,
};

pub static WORD_UNIV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eral"),
        dictgen::InsensitiveStr::Ascii("erally"),
        dictgen::InsensitiveStr::Ascii("ercity"),
        dictgen::InsensitiveStr::Ascii("eriality"),
        dictgen::InsensitiveStr::Ascii("erisites"),
        dictgen::InsensitiveStr::Ascii("eristies"),
        dictgen::InsensitiveStr::Ascii("eristy"),
        dictgen::InsensitiveStr::Ascii("erities"),
        dictgen::InsensitiveStr::Ascii("erity"),
        dictgen::InsensitiveStr::Ascii("ersale"),
        dictgen::InsensitiveStr::Ascii("ersaly"),
        dictgen::InsensitiveStr::Ascii("ersella"),
        dictgen::InsensitiveStr::Ascii("ersels"),
        dictgen::InsensitiveStr::Ascii("ersets"),
        dictgen::InsensitiveStr::Ascii("ersial"),
        dictgen::InsensitiveStr::Ascii("ersiality"),
        dictgen::InsensitiveStr::Ascii("ersirty"),
        dictgen::InsensitiveStr::Ascii("ersite"),
        dictgen::InsensitiveStr::Ascii("ersites"),
        dictgen::InsensitiveStr::Ascii("ersitets"),
        dictgen::InsensitiveStr::Ascii("ersitites"),
        dictgen::InsensitiveStr::Ascii("ersse"),
        dictgen::InsensitiveStr::Ascii("erstal"),
        dictgen::InsensitiveStr::Ascii("erstiy"),
        dictgen::InsensitiveStr::Ascii("esities"),
        dictgen::InsensitiveStr::Ascii("esity"),
        dictgen::InsensitiveStr::Ascii("iersal"),
        dictgen::InsensitiveStr::Ascii("rsal"),
    ],
    values: &[
        &["universal"],
        &["universally"],
        &["university"],
        &["universality"],
        &["universities"],
        &["universities"],
        &["university"],
        &["universities"],
        &["university"],
        &["universe"],
        &["universally"],
        &["universally"],
        &["universes"],
        &["universes"],
        &["universal"],
        &["universality"],
        &["university"],
        &["universities"],
        &["universities"],
        &["universities"],
        &["universities"],
        &["universes"],
        &["universal"],
        &["university"],
        &["universities"],
        &["university"],
        &["universal"],
        &["universal"],
    ],
    range: 4..=9,
};

static WORD_UNIT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNIT_CHILDREN),
    value: None,
};

pub static WORD_UNIT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("errupted"),
        dictgen::InsensitiveStr::Ascii("esstates"),
        dictgen::InsensitiveStr::Ascii("ialize"),
        dictgen::InsensitiveStr::Ascii("ialized"),
        dictgen::InsensitiveStr::Ascii("ilised"),
        dictgen::InsensitiveStr::Ascii("ilising"),
        dictgen::InsensitiveStr::Ascii("ilities"),
        dictgen::InsensitiveStr::Ascii("ility"),
        dictgen::InsensitiveStr::Ascii("ilized"),
        dictgen::InsensitiveStr::Ascii("ilizing"),
        dictgen::InsensitiveStr::Ascii("ilties"),
        dictgen::InsensitiveStr::Ascii("ilty"),
        dictgen::InsensitiveStr::Ascii("itialized"),
        dictgen::InsensitiveStr::Ascii("l"),
        dictgen::InsensitiveStr::Ascii("led"),
        dictgen::InsensitiveStr::Ascii("ss"),
    ],
    values: &[
        &["uninterrupted"],
        &["unitedstates"],
        &["uninitialize"],
        &["uninitialized"],
        &["uninitialised"],
        &["uninitialising"],
        &["utilities"],
        &["utility"],
        &["uninitialized"],
        &["uninitializing"],
        &["utilities"],
        &["utility"],
        &["uninitialized"],
        &["until"],
        &["untitled"],
        &["units"],
    ],
    range: 1..=9,
};

static WORD_UNIS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNIS_CHILDREN),
    value: None,
};

pub static WORD_UNIS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("gned"),
        dictgen::InsensitiveStr::Ascii("ntall"),
        dictgen::InsensitiveStr::Ascii("ntalled"),
        dictgen::InsensitiveStr::Ascii("ntalling"),
        dictgen::InsensitiveStr::Ascii("talled"),
    ],
    values: &[
        &["unsigned"],
        &["uninstall"],
        &["uninstalled"],
        &["uninstalling"],
        &["uninstalled"],
    ],
    range: 4..=8,
};

static WORD_UNIQ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNIQ_CHILDREN),
    value: None,
};

pub static WORD_UNIQ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("u"),
        dictgen::InsensitiveStr::Ascii("uelly"),
        dictgen::InsensitiveStr::Ascii("uesness"),
        dictgen::InsensitiveStr::Ascii("uey"),
        dictgen::InsensitiveStr::Ascii("uiness"),
        dictgen::InsensitiveStr::Ascii("uley"),
        dictgen::InsensitiveStr::Ascii("uness"),
    ],
    values: &[
        &["unique"],
        &["unique"],
        &["uniquely"],
        &["uniqueness"],
        &["uniquely"],
        &["uniqueness"],
        &["uniquely"],
        &["uniqueness"],
    ],
    range: 1..=7,
};

static WORD_UNIO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNIO_CHILDREN),
    value: Some(&["union"]),
};

pub static WORD_UNIO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cde"),
        dictgen::InsensitiveStr::Ascii("s"),
    ],
    values: &[&["unicode"], &["unions"]],
    range: 1..=3,
};

static WORD_UNIN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_UNIN_CHILDREN),
    value: None,
};

static WORD_UNIN_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_UNINA_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_UNINF_NODE),
    None,
    None,
    Some(&WORD_UNINI_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_UNINS_NODE),
    Some(&WORD_UNINT_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_UNINT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNINT_CHILDREN),
    value: None,
};

pub static WORD_UNINT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ellegent"),
        dictgen::InsensitiveStr::Ascii("elligable"),
        dictgen::InsensitiveStr::Ascii("elligant"),
        dictgen::InsensitiveStr::Ascii("elligient"),
        dictgen::InsensitiveStr::Ascii("ensional"),
        dictgen::InsensitiveStr::Ascii("ensionally"),
        dictgen::InsensitiveStr::Ascii("ented"),
        dictgen::InsensitiveStr::Ascii("entially"),
        dictgen::InsensitiveStr::Ascii("entinal"),
        dictgen::InsensitiveStr::Ascii("entionaly"),
        dictgen::InsensitiveStr::Ascii("entionnal"),
        dictgen::InsensitiveStr::Ascii("entionnally"),
        dictgen::InsensitiveStr::Ascii("eresed"),
        dictgen::InsensitiveStr::Ascii("eresing"),
        dictgen::InsensitiveStr::Ascii("eressting"),
        dictgen::InsensitiveStr::Ascii("eristing"),
        dictgen::InsensitiveStr::Ascii("erneted"),
        dictgen::InsensitiveStr::Ascii("erpretted"),
        dictgen::InsensitiveStr::Ascii("erruped"),
        dictgen::InsensitiveStr::Ascii("erruptable"),
        dictgen::InsensitiveStr::Ascii("ersting"),
        dictgen::InsensitiveStr::Ascii("eruppted"),
        dictgen::InsensitiveStr::Ascii("erupted"),
        dictgen::InsensitiveStr::Ascii("esting"),
        dictgen::InsensitiveStr::Ascii("ialised"),
        dictgen::InsensitiveStr::Ascii("ialized"),
        dictgen::InsensitiveStr::Ascii("iallised"),
        dictgen::InsensitiveStr::Ascii("iallized"),
        dictgen::InsensitiveStr::Ascii("ialsied"),
        dictgen::InsensitiveStr::Ascii("ialzied"),
        dictgen::InsensitiveStr::Ascii("uive"),
    ],
    values: &[
        &["unintelligent"],
        &["unintelligible"],
        &["unintelligent"],
        &["unintelligent"],
        &["unintentional"],
        &["unintentionally"],
        &["unintended", "unindented"],
        &["unintentionally"],
        &["unintentional"],
        &["unintentionally"],
        &["unintentional"],
        &["unintentionally"],
        &["uninterested"],
        &["uninteresting"],
        &["uninteresting"],
        &["uninteresting"],
        &["uninterested"],
        &["uninterpreted"],
        &["uninterrupted"],
        &["uninterruptible"],
        &["uninteresting"],
        &["uninterrupted"],
        &["uninterrupted"],
        &["uninteresting"],
        &["uninitialised"],
        &["uninitialized"],
        &["uninitialised"],
        &["uninitialized"],
        &["uninitialised"],
        &["uninitialized"],
        &["unintuitive"],
    ],
    range: 4..=11,
};

static WORD_UNINS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNINS_CHILDREN),
    value: None,
};

pub static WORD_UNINS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ipred"),
        dictgen::InsensitiveStr::Ascii("piried"),
        dictgen::InsensitiveStr::Ascii("pried"),
        dictgen::InsensitiveStr::Ascii("talable"),
        dictgen::InsensitiveStr::Ascii("taled"),
        dictgen::InsensitiveStr::Ascii("taling"),
        dictgen::InsensitiveStr::Ascii("tallimg"),
        dictgen::InsensitiveStr::Ascii("tallled"),
        dictgen::InsensitiveStr::Ascii("tallling"),
        dictgen::InsensitiveStr::Ascii("tallng"),
        dictgen::InsensitiveStr::Ascii("tatiated"),
        dictgen::InsensitiveStr::Ascii("tlal"),
        dictgen::InsensitiveStr::Ascii("tlalation"),
        dictgen::InsensitiveStr::Ascii("tlalations"),
        dictgen::InsensitiveStr::Ascii("tlaled"),
        dictgen::InsensitiveStr::Ascii("tlaler"),
        dictgen::InsensitiveStr::Ascii("tlaling"),
        dictgen::InsensitiveStr::Ascii("tlals"),
    ],
    values: &[
        &["uninspired"],
        &["uninspired"],
        &["uninspired"],
        &["uninstallable"],
        &["uninstalled"],
        &["uninstalling"],
        &["uninstalling"],
        &["uninstalled"],
        &["uninstalling"],
        &["uninstalling"],
        &["uninstantiated"],
        &["uninstall"],
        &["uninstallation"],
        &["uninstallations"],
        &["uninstalled"],
        &["uninstaller"],
        &["uninstalling"],
        &["uninstalls"],
    ],
    range: 4..=10,
};

static WORD_UNINI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNINI_CHILDREN),
    value: None,
};

pub static WORD_UNINI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("tailised"),
        dictgen::InsensitiveStr::Ascii("tailized"),
        dictgen::InsensitiveStr::Ascii("talise"),
        dictgen::InsensitiveStr::Ascii("talised"),
        dictgen::InsensitiveStr::Ascii("talises"),
        dictgen::InsensitiveStr::Ascii("talizable"),
        dictgen::InsensitiveStr::Ascii("talize"),
        dictgen::InsensitiveStr::Ascii("talized"),
        dictgen::InsensitiveStr::Ascii("talizes"),
        dictgen::InsensitiveStr::Ascii("teresting"),
        dictgen::InsensitiveStr::Ascii("tializaed"),
        dictgen::InsensitiveStr::Ascii("tialse"),
        dictgen::InsensitiveStr::Ascii("tialsed"),
        dictgen::InsensitiveStr::Ascii("tialses"),
        dictgen::InsensitiveStr::Ascii("tialze"),
        dictgen::InsensitiveStr::Ascii("tialzed"),
        dictgen::InsensitiveStr::Ascii("tialzes"),
    ],
    values: &[
        &["uninitialised"],
        &["uninitialized"],
        &["uninitialise"],
        &["uninitialised"],
        &["uninitialises"],
        &["uninitializable"],
        &["uninitialize"],
        &["uninitialized"],
        &["uninitializes"],
        &["uninteresting"],
        &["uninitialized"],
        &["uninitialise"],
        &["uninitialised"],
        &["uninitialises"],
        &["uninitialize"],
        &["uninitialized"],
        &["uninitializes"],
    ],
    range: 6..=9,
};

static WORD_UNINF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNINF_CHILDREN),
    value: None,
};

pub static WORD_UNINF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("rom"),
        dictgen::InsensitiveStr::Ascii("romed"),
        dictgen::InsensitiveStr::Ascii("romes"),
        dictgen::InsensitiveStr::Ascii("roming"),
        dictgen::InsensitiveStr::Ascii("roms"),
    ],
    values: &[
        &["uninform", "uniform"],
        &["uninformed", "uniformed"],
        &["uninforms", "uniforms"],
        &["uninforming", "uniforming"],
        &["uninforms", "uniforms"],
    ],
    range: 3..=6,
};

static WORD_UNINA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNINA_CHILDREN),
    value: None,
};

pub static WORD_UNINA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("mous")],
    values: &[&["unanimous"]],
    range: 4..=4,
};

static WORD_UNIM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNIM_CHILDREN),
    value: None,
};

pub static WORD_UNIM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("pemented"),
        dictgen::InsensitiveStr::Ascii("plemeneted"),
        dictgen::InsensitiveStr::Ascii("plimented"),
        dictgen::InsensitiveStr::Ascii("porant"),
        dictgen::InsensitiveStr::Ascii("portent"),
        dictgen::InsensitiveStr::Ascii("presed"),
        dictgen::InsensitiveStr::Ascii("pressd"),
        dictgen::InsensitiveStr::Ascii("presssed"),
    ],
    values: &[
        &["unimplemented"],
        &["unimplemented"],
        &["unimplemented"],
        &["unimportant"],
        &["unimportant"],
        &["unimpressed"],
        &["unimpressed"],
        &["unimpressed"],
    ],
    range: 6..=10,
};

static WORD_UNIL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNIL_CHILDREN),
    value: None,
};

pub static WORD_UNIL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aterallly"),
        dictgen::InsensitiveStr::Ascii("ateraly"),
        dictgen::InsensitiveStr::Ascii("aterlly"),
        dictgen::InsensitiveStr::Ascii("atreal"),
        dictgen::InsensitiveStr::Ascii("atreally"),
        dictgen::InsensitiveStr::Ascii("iterally"),
    ],
    values: &[
        &["unilaterally"],
        &["unilaterally"],
        &["unilaterally"],
        &["unilateral"],
        &["unilaterally"],
        &["unilaterally"],
    ],
    range: 6..=9,
};

static WORD_UNIH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNIH_CHILDREN),
    value: None,
};

pub static WORD_UNIH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("abited")],
    values: &[&["uninhabited"]],
    range: 6..=6,
};

static WORD_UNIG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNIG_CHILDREN),
    value: None,
};

pub static WORD_UNIG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ned")],
    values: &[&["unsigned"]],
    range: 3..=3,
};

static WORD_UNIF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNIF_CHILDREN),
    value: None,
};

pub static WORD_UNIF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("form"),
        dictgen::InsensitiveStr::Ascii("forms"),
        dictgen::InsensitiveStr::Ascii("iy"),
        dictgen::InsensitiveStr::Ascii("nished"),
        dictgen::InsensitiveStr::Ascii("om"),
        dictgen::InsensitiveStr::Ascii("omly"),
        dictgen::InsensitiveStr::Ascii("omtity"),
        dictgen::InsensitiveStr::Ascii("ormely"),
        dictgen::InsensitiveStr::Ascii("ormes"),
        dictgen::InsensitiveStr::Ascii("ormy"),
        dictgen::InsensitiveStr::Ascii("rom"),
        dictgen::InsensitiveStr::Ascii("romed"),
        dictgen::InsensitiveStr::Ascii("romity"),
        dictgen::InsensitiveStr::Ascii("roms"),
    ],
    values: &[
        &["uniform"],
        &["uniforms"],
        &["unify"],
        &["unfinished"],
        &["uniform"],
        &["uniformly"],
        &["uniformity"],
        &["uniformly"],
        &["uniforms"],
        &["uniformly", "uniform"],
        &["uniform"],
        &["uniformed"],
        &["uniformity"],
        &["uniforms"],
    ],
    range: 2..=6,
};

static WORD_UNID_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNID_CHILDREN),
    value: None,
};

pub static WORD_UNID_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("entifiedly"),
        dictgen::InsensitiveStr::Ascii("imensionnal"),
    ],
    values: &[&["unidentified"], &["unidimensional"]],
    range: 10..=11,
};

static WORD_UNIC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNIC_CHILDREN),
    value: None,
};

pub static WORD_UNIC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("de"),
        dictgen::InsensitiveStr::Ascii("h"),
        dictgen::InsensitiveStr::Ascii("k"),
        dictgen::InsensitiveStr::Ascii("ks"),
        dictgen::InsensitiveStr::Ascii("ornios"),
        dictgen::InsensitiveStr::Ascii("ornis"),
        dictgen::InsensitiveStr::Ascii("ornus"),
        dictgen::InsensitiveStr::Ascii("ors"),
        dictgen::InsensitiveStr::Ascii("rons"),
    ],
    values: &[
        &["unicode"],
        &["unix"],
        &["eunuch", "unix"],
        &["eunuchs"],
        &["unicorns"],
        &["unicorns"],
        &["unicorns"],
        &["unicorns"],
        &["unicorns"],
    ],
    range: 1..=6,
};

static WORD_UNH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNH_CHILDREN),
    value: None,
};

pub static WORD_UNH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("andeled"),
        dictgen::InsensitiveStr::Ascii("apppy"),
        dictgen::InsensitiveStr::Ascii("ealhty"),
        dictgen::InsensitiveStr::Ascii("ealthly"),
        dictgen::InsensitiveStr::Ascii("ealty"),
        dictgen::InsensitiveStr::Ascii("eathly"),
        dictgen::InsensitiveStr::Ascii("elathy"),
        dictgen::InsensitiveStr::Ascii("ilight"),
        dictgen::InsensitiveStr::Ascii("ilighted"),
        dictgen::InsensitiveStr::Ascii("ilights"),
    ],
    values: &[
        &["unhandled"],
        &["unhappy"],
        &["unhealthy"],
        &["unhealthy"],
        &["unhealthy"],
        &["unhealthy"],
        &["unhealthy"],
        &["unhighlight"],
        &["unhighlighted"],
        &["unhighlights"],
    ],
    range: 5..=8,
};

static WORD_UNG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNG_CHILDREN),
    value: None,
};

pub static WORD_UNG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eneralizeable"),
        dictgen::InsensitiveStr::Ascii("ly"),
        dictgen::InsensitiveStr::Ascii("odley"),
        dictgen::InsensitiveStr::Ascii("oldy"),
        dictgen::InsensitiveStr::Ascii("rapeful"),
        dictgen::InsensitiveStr::Ascii("reatful"),
        dictgen::InsensitiveStr::Ascii("reatfull"),
    ],
    values: &[
        &["ungeneralizable"],
        &["ugly"],
        &["ungodly"],
        &["ungodly"],
        &["ungrateful"],
        &["ungrateful"],
        &["ungrateful"],
    ],
    range: 2..=13,
};

static WORD_UNF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNF_CHILDREN),
    value: None,
};

pub static WORD_UNF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ailry"),
        dictgen::InsensitiveStr::Ascii("airy"),
        dictgen::InsensitiveStr::Ascii("amilair"),
        dictgen::InsensitiveStr::Ascii("amilier"),
        dictgen::InsensitiveStr::Ascii("amilliar"),
        dictgen::InsensitiveStr::Ascii("arily"),
        dictgen::InsensitiveStr::Ascii("ilp"),
        dictgen::InsensitiveStr::Ascii("ilpped"),
        dictgen::InsensitiveStr::Ascii("ilpping"),
        dictgen::InsensitiveStr::Ascii("ilps"),
        dictgen::InsensitiveStr::Ascii("insihed"),
        dictgen::InsensitiveStr::Ascii("irendly"),
        dictgen::InsensitiveStr::Ascii("laged"),
        dictgen::InsensitiveStr::Ascii("lexible"),
        dictgen::InsensitiveStr::Ascii("omfortable"),
        dictgen::InsensitiveStr::Ascii("oretunately"),
        dictgen::InsensitiveStr::Ascii("orgetable"),
        dictgen::InsensitiveStr::Ascii("orgiveable"),
        dictgen::InsensitiveStr::Ascii("orgiveble"),
        dictgen::InsensitiveStr::Ascii("orgivible"),
        dictgen::InsensitiveStr::Ascii("ormated"),
        dictgen::InsensitiveStr::Ascii("orseen"),
        dictgen::InsensitiveStr::Ascii("orttunately"),
        dictgen::InsensitiveStr::Ascii("ortuante"),
        dictgen::InsensitiveStr::Ascii("ortuantely"),
        dictgen::InsensitiveStr::Ascii("ortuate"),
        dictgen::InsensitiveStr::Ascii("ortunaltely"),
        dictgen::InsensitiveStr::Ascii("ortunaly"),
        dictgen::InsensitiveStr::Ascii("ortunantly"),
        dictgen::InsensitiveStr::Ascii("ortunat"),
        dictgen::InsensitiveStr::Ascii("ortunatelly"),
        dictgen::InsensitiveStr::Ascii("ortunatetly"),
        dictgen::InsensitiveStr::Ascii("ortunatley"),
        dictgen::InsensitiveStr::Ascii("ortunatly"),
        dictgen::InsensitiveStr::Ascii("ortune"),
        dictgen::InsensitiveStr::Ascii("ortuneatly"),
        dictgen::InsensitiveStr::Ascii("ortunetely"),
        dictgen::InsensitiveStr::Ascii("ortunetly"),
        dictgen::InsensitiveStr::Ascii("ortuntaly"),
        dictgen::InsensitiveStr::Ascii("ortuntely"),
        dictgen::InsensitiveStr::Ascii("orunate"),
        dictgen::InsensitiveStr::Ascii("orunately"),
        dictgen::InsensitiveStr::Ascii("orutunate"),
        dictgen::InsensitiveStr::Ascii("orutunately"),
        dictgen::InsensitiveStr::Ascii("otunately"),
        dictgen::InsensitiveStr::Ascii("ourtunately"),
        dictgen::InsensitiveStr::Ascii("ourtunetly"),
        dictgen::InsensitiveStr::Ascii("reindly"),
        dictgen::InsensitiveStr::Ascii("riednly"),
        dictgen::InsensitiveStr::Ascii("riendy"),
        dictgen::InsensitiveStr::Ascii("riently"),
        dictgen::InsensitiveStr::Ascii("urtunately"),
    ],
    values: &[
        &["unfairly"],
        &["unfairly"],
        &["unfamiliar"],
        &["unfamiliar"],
        &["unfamiliar"],
        &["unfairly"],
        &["unflip"],
        &["unflipped"],
        &["unflipping"],
        &["unflips"],
        &["unfinished"],
        &["unfriendly"],
        &["unflagged"],
        &["inflexible"],
        &["uncomfortable"],
        &["unfortunately"],
        &["unforgettable"],
        &["unforgivable"],
        &["unforgivable"],
        &["unforgivable"],
        &["unformatted"],
        &["unforeseen"],
        &["unfortunately"],
        &["unfortunate"],
        &["unfortunately"],
        &["unfortunate"],
        &["unfortunately"],
        &["unfortunately"],
        &["unfortunately"],
        &["unfortunate"],
        &["unfortunately"],
        &["unfortunately"],
        &["unfortunately"],
        &["unfortunately"],
        &["unfortunate"],
        &["unfortunately"],
        &["unfortunately"],
        &["unfortunately"],
        &["unfortunately"],
        &["unfortunately"],
        &["unfortunate"],
        &["unfortunately"],
        &["unfortunate"],
        &["unfortunately"],
        &["unfortunately"],
        &["unfortunately"],
        &["unfortunately"],
        &["unfriendly"],
        &["unfriendly"],
        &["unfriendly"],
        &["unfriendly"],
        &["unfortunately"],
    ],
    range: 3..=11,
};

static WORD_UNE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_UNE_CHILDREN),
    value: None,
};

static WORD_UNE_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_UNEA_NODE),
    None,
    Some(&WORD_UNEC_NODE),
    Some(&WORD_UNED_NODE),
    Some(&WORD_UNEE_NODE),
    Some(&WORD_UNEF_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_UNEM_NODE),
    Some(&WORD_UNEN_NODE),
    None,
    Some(&WORD_UNEP_NODE),
    Some(&WORD_UNEQ_NODE),
    Some(&WORD_UNER_NODE),
    Some(&WORD_UNES_NODE),
    None,
    None,
    Some(&WORD_UNEV_NODE),
    None,
    Some(&WORD_UNEX_NODE),
    None,
    None,
];

static WORD_UNEX_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNEX_CHILDREN),
    value: None,
};

pub static WORD_UNEX_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cected"),
        dictgen::InsensitiveStr::Ascii("cectedly"),
        dictgen::InsensitiveStr::Ascii("cpected"),
        dictgen::InsensitiveStr::Ascii("cpectedly"),
        dictgen::InsensitiveStr::Ascii("ecpted"),
        dictgen::InsensitiveStr::Ascii("ecptedly"),
        dictgen::InsensitiveStr::Ascii("ected"),
        dictgen::InsensitiveStr::Ascii("ectedly"),
        dictgen::InsensitiveStr::Ascii("epcted"),
        dictgen::InsensitiveStr::Ascii("epctedly"),
        dictgen::InsensitiveStr::Ascii("epected"),
        dictgen::InsensitiveStr::Ascii("epectedly"),
        dictgen::InsensitiveStr::Ascii("pacted"),
        dictgen::InsensitiveStr::Ascii("pactedly"),
        dictgen::InsensitiveStr::Ascii("pcted"),
        dictgen::InsensitiveStr::Ascii("pctedly"),
        dictgen::InsensitiveStr::Ascii("pecetd"),
        dictgen::InsensitiveStr::Ascii("pecetdly"),
        dictgen::InsensitiveStr::Ascii("pect"),
        dictgen::InsensitiveStr::Ascii("pectadely"),
        dictgen::InsensitiveStr::Ascii("pectadly"),
        dictgen::InsensitiveStr::Ascii("pectd"),
        dictgen::InsensitiveStr::Ascii("pectdly"),
        dictgen::InsensitiveStr::Ascii("pecte"),
        dictgen::InsensitiveStr::Ascii("pectely"),
        dictgen::InsensitiveStr::Ascii("pectend"),
        dictgen::InsensitiveStr::Ascii("pectendly"),
        dictgen::InsensitiveStr::Ascii("pectetly"),
        dictgen::InsensitiveStr::Ascii("pectidly"),
        dictgen::InsensitiveStr::Ascii("pectly"),
        dictgen::InsensitiveStr::Ascii("peected"),
        dictgen::InsensitiveStr::Ascii("peectedly"),
        dictgen::InsensitiveStr::Ascii("pepected"),
        dictgen::InsensitiveStr::Ascii("pepectedly"),
        dictgen::InsensitiveStr::Ascii("pepted"),
        dictgen::InsensitiveStr::Ascii("peptedly"),
        dictgen::InsensitiveStr::Ascii("percted"),
        dictgen::InsensitiveStr::Ascii("perctedly"),
        dictgen::InsensitiveStr::Ascii("perience"),
        dictgen::InsensitiveStr::Ascii("pested"),
        dictgen::InsensitiveStr::Ascii("pestedly"),
        dictgen::InsensitiveStr::Ascii("petced"),
        dictgen::InsensitiveStr::Ascii("petcedly"),
        dictgen::InsensitiveStr::Ascii("petct"),
        dictgen::InsensitiveStr::Ascii("petcted"),
        dictgen::InsensitiveStr::Ascii("petctedly"),
        dictgen::InsensitiveStr::Ascii("petctly"),
        dictgen::InsensitiveStr::Ascii("petect"),
        dictgen::InsensitiveStr::Ascii("petected"),
        dictgen::InsensitiveStr::Ascii("petectedly"),
        dictgen::InsensitiveStr::Ascii("petectly"),
        dictgen::InsensitiveStr::Ascii("peted"),
        dictgen::InsensitiveStr::Ascii("petedly"),
        dictgen::InsensitiveStr::Ascii("pexcted"),
        dictgen::InsensitiveStr::Ascii("pexctedly"),
        dictgen::InsensitiveStr::Ascii("pexted"),
        dictgen::InsensitiveStr::Ascii("pextedly"),
        dictgen::InsensitiveStr::Ascii("plaind"),
        dictgen::InsensitiveStr::Ascii("planed"),
        dictgen::InsensitiveStr::Ascii("plicably"),
        dictgen::InsensitiveStr::Ascii("spected"),
        dictgen::InsensitiveStr::Ascii("spectedly"),
    ],
    values: &[
        &["unexpected"],
        &["unexpectedly"],
        &["unexpected"],
        &["unexpectedly"],
        &["unexpected"],
        &["unexpectedly"],
        &["unexpected"],
        &["unexpectedly"],
        &["unexpected"],
        &["unexpectedly"],
        &["unexpected"],
        &["unexpectedly"],
        &["unexpected"],
        &["unexpectedly"],
        &["unexpected"],
        &["unexpectedly"],
        &["unexpected"],
        &["unexpectedly"],
        &["unexpected"],
        &["unexpectedly"],
        &["unexpectedly"],
        &["unexpected"],
        &["unexpectedly"],
        &["unexpected"],
        &["unexpectedly"],
        &["unexpected"],
        &["unexpectedly"],
        &["unexpectedly"],
        &["unexpectedly"],
        &["unexpectedly"],
        &["unexpected"],
        &["unexpectedly"],
        &["unexpected"],
        &["unexpectedly"],
        &["unexpected"],
        &["unexpectedly"],
        &["unexpected"],
        &["unexpectedly"],
        &["inexperience"],
        &["unexpected"],
        &["unexpectedly"],
        &["unexpected"],
        &["unexpectedly"],
        &["unexpected"],
        &["unexpected"],
        &["unexpectedly"],
        &["unexpectedly"],
        &["unexpected"],
        &["unexpected"],
        &["unexpectedly"],
        &["unexpectedly"],
        &["unexpected"],
        &["unexpectedly"],
        &["unexpected"],
        &["unexpectedly"],
        &["unexpected"],
        &["unexpectedly"],
        &["unexplained"],
        &["unexplained"],
        &["inexplicably"],
        &["unexpected"],
        &["unexpectedly"],
    ],
    range: 4..=10,
};

static WORD_UNEV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNEV_CHILDREN),
    value: None,
};

pub static WORD_UNEV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("aluted")],
    values: &[&["unevaluated"]],
    range: 6..=6,
};

static WORD_UNES_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNES_CHILDREN),
    value: None,
};

pub static WORD_UNES_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("acpe"),
        dictgen::InsensitiveStr::Ascii("acped"),
        dictgen::InsensitiveStr::Ascii("secarry"),
        dictgen::InsensitiveStr::Ascii("secary"),
    ],
    values: &[
        &["unescape"],
        &["unescaped"],
        &["unnecessary"],
        &["unnecessary"],
    ],
    range: 4..=7,
};

static WORD_UNER_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNER_CHILDREN),
    value: Some(&["under"]),
};

pub static WORD_UNER_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[],
    values: &[],
    range: 0..=0,
};

static WORD_UNEQ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNEQ_CHILDREN),
    value: None,
};

pub static WORD_UNEQ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ualities"),
        dictgen::InsensitiveStr::Ascii("uality"),
    ],
    values: &[&["inequalities"], &["inequality"]],
    range: 6..=8,
};

static WORD_UNEP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNEP_CHILDREN),
    value: None,
};

pub static WORD_UNEP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ected"),
        dictgen::InsensitiveStr::Ascii("ectedly"),
    ],
    values: &[&["unexpected"], &["unexpectedly"]],
    range: 5..=7,
};

static WORD_UNEN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNEN_CHILDREN),
    value: None,
};

pub static WORD_UNEN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("crpt"),
        dictgen::InsensitiveStr::Ascii("crpted"),
        dictgen::InsensitiveStr::Ascii("cyrpted"),
        dictgen::InsensitiveStr::Ascii("forcable"),
        dictgen::InsensitiveStr::Ascii("ployment"),
    ],
    values: &[
        &["unencrypt"],
        &["unencrypted"],
        &["unencrypted"],
        &["unenforceable"],
        &["unemployment"],
    ],
    range: 4..=8,
};

static WORD_UNEM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNEM_CHILDREN),
    value: None,
};

pub static WORD_UNEM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ployeed"),
        dictgen::InsensitiveStr::Ascii("ployemnt"),
        dictgen::InsensitiveStr::Ascii("ployent"),
        dictgen::InsensitiveStr::Ascii("ploymed"),
        dictgen::InsensitiveStr::Ascii("plyoment"),
        dictgen::InsensitiveStr::Ascii("polyed"),
        dictgen::InsensitiveStr::Ascii("polyment"),
    ],
    values: &[
        &["unemployed"],
        &["unemployment"],
        &["unemployment"],
        &["unemployed"],
        &["unemployment"],
        &["unemployed"],
        &["unemployment"],
    ],
    range: 6..=8,
};

static WORD_UNEF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNEF_CHILDREN),
    value: None,
};

pub static WORD_UNEF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("orceable"),
        dictgen::InsensitiveStr::Ascii("orm"),
    ],
    values: &[&["unenforceable"], &["uniform"]],
    range: 3..=8,
};

static WORD_UNEE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNEE_CHILDREN),
    value: None,
};

pub static WORD_UNEE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ded")],
    values: &[&["unneeded", "unheeded", "needed"]],
    range: 3..=3,
};

static WORD_UNED_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNED_CHILDREN),
    value: None,
};

pub static WORD_UNED_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cuated"),
        dictgen::InsensitiveStr::Ascii("icated"),
    ],
    values: &[&["uneducated"], &["uneducated"]],
    range: 6..=6,
};

static WORD_UNEC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNEC_CHILDREN),
    value: None,
};

pub static WORD_UNEC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cesary"),
        dictgen::InsensitiveStr::Ascii("cessarily"),
        dictgen::InsensitiveStr::Ascii("cessary"),
        dictgen::InsensitiveStr::Ascii("esary"),
        dictgen::InsensitiveStr::Ascii("essarily"),
        dictgen::InsensitiveStr::Ascii("essary"),
        dictgen::InsensitiveStr::Ascii("hecked"),
        dictgen::InsensitiveStr::Ascii("rypted"),
    ],
    values: &[
        &["unnecessary"],
        &["unnecessarily"],
        &["unnecessary"],
        &["unnecessary"],
        &["unnecessarily"],
        &["unnecessary"],
        &["unchecked"],
        &["unencrypted"],
    ],
    range: 5..=9,
};

static WORD_UNEA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNEA_CHILDREN),
    value: None,
};

pub static WORD_UNEA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("lthy")],
    values: &[&["unhealthy"]],
    range: 4..=4,
};

static WORD_UND_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_UND_CHILDREN),
    value: None,
};

static WORD_UND_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    None,
    None,
    Some(&WORD_UNDE_NODE),
    Some(&WORD_UNDF_NODE),
    None,
    None,
    Some(&WORD_UNDI_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_UNDO_NODE),
    None,
    None,
    Some(&WORD_UNDR_NODE),
    None,
    None,
    Some(&WORD_UNDU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_UNDU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNDU_CHILDREN),
    value: None,
};

pub static WORD_UNDU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ely"),
        dictgen::InsensitiveStr::Ascii("pplicated"),
    ],
    values: &[&["unduly"], &["unduplicated"]],
    range: 3..=9,
};

static WORD_UNDR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNDR_CHILDREN),
    value: None,
};

pub static WORD_UNDR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("eground")],
    values: &[&["underground"]],
    range: 7..=7,
};

static WORD_UNDO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNDO_CHILDREN),
    value: None,
};

pub static WORD_UNDO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ctrinated"),
        dictgen::InsensitiveStr::Ascii("cummented"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("rder"),
        dictgen::InsensitiveStr::Ascii("rdered"),
        dictgen::InsensitiveStr::Ascii("ubedtly"),
        dictgen::InsensitiveStr::Ascii("ubetdly"),
        dictgen::InsensitiveStr::Ascii("ubtadly"),
        dictgen::InsensitiveStr::Ascii("ubtebly"),
        dictgen::InsensitiveStr::Ascii("ubtedbly"),
        dictgen::InsensitiveStr::Ascii("ubtedy"),
        dictgen::InsensitiveStr::Ascii("ubtely"),
        dictgen::InsensitiveStr::Ascii("ubtetly"),
        dictgen::InsensitiveStr::Ascii("ubtley"),
    ],
    values: &[
        &["indoctrinated"],
        &["undocumented"],
        &["undo", "undone"],
        &["unorder"],
        &["unordered"],
        &["undoubtedly"],
        &["undoubtedly"],
        &["undoubtedly"],
        &["undoubtedly"],
        &["undoubtedly"],
        &["undoubtedly"],
        &["undoubtedly"],
        &["undoubtedly"],
        &["undoubtedly"],
    ],
    range: 2..=9,
};

static WORD_UNDI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNDI_CHILDREN),
    value: None,
};

pub static WORD_UNDI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("serable"),
        dictgen::InsensitiveStr::Ascii("stinghable"),
    ],
    values: &[&["undesirable"], &["indistinguishable"]],
    range: 7..=10,
};

static WORD_UNDF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNDF_CHILDREN),
    value: None,
};

pub static WORD_UNDF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ine"),
        dictgen::InsensitiveStr::Ascii("ined"),
        dictgen::InsensitiveStr::Ascii("ines"),
    ],
    values: &[&["undefine"], &["undefined"], &["undefines"]],
    range: 3..=4,
};

static WORD_UNDE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_UNDE_CHILDREN),
    value: None,
};

static WORD_UNDE_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    Some(&WORD_UNDEB_NODE),
    Some(&WORD_UNDEC_NODE),
    None,
    None,
    Some(&WORD_UNDEF_NODE),
    None,
    None,
    Some(&WORD_UNDEI_NODE),
    None,
    None,
    Some(&WORD_UNDEL_NODE),
    None,
    Some(&WORD_UNDEN_NODE),
    None,
    Some(&WORD_UNDEP_NODE),
    None,
    Some(&WORD_UNDER_NODE),
    Some(&WORD_UNDES_NODE),
    Some(&WORD_UNDET_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_UNDET_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNDET_CHILDREN),
    value: Some(&["under"]),
};

pub static WORD_UNDET_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ecable"),
        dictgen::InsensitiveStr::Ascii("stand"),
        dictgen::InsensitiveStr::Ascii("ware"),
        dictgen::InsensitiveStr::Ascii("water"),
    ],
    values: &[
        &["undetectable"],
        &["understand"],
        &["underwear"],
        &["underwater"],
    ],
    range: 4..=6,
};

static WORD_UNDES_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNDES_CHILDREN),
    value: None,
};

pub static WORD_UNDES_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("core"),
        dictgen::InsensitiveStr::Ascii("cored"),
        dictgen::InsensitiveStr::Ascii("cores"),
        dictgen::InsensitiveStr::Ascii("ireable"),
        dictgen::InsensitiveStr::Ascii("ireble"),
        dictgen::InsensitiveStr::Ascii("itable"),
        dictgen::InsensitiveStr::Ascii("riable"),
        dictgen::InsensitiveStr::Ascii("rtand"),
        dictgen::InsensitiveStr::Ascii("tand"),
        dictgen::InsensitiveStr::Ascii("tanding"),
        dictgen::InsensitiveStr::Ascii("tood"),
        dictgen::InsensitiveStr::Ascii("tructible"),
    ],
    values: &[
        &["underscore"],
        &["underscored"],
        &["underscores"],
        &["undesirable"],
        &["undesirable"],
        &["undesirable"],
        &["undesirable"],
        &["understands"],
        &["understand"],
        &["understanding"],
        &["understood"],
        &["indestructible"],
    ],
    range: 4..=9,
};

static WORD_UNDER_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_UNDER_CHILDREN),
    value: None,
};

static WORD_UNDER_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_UNDERA_NODE),
    Some(&WORD_UNDERB_NODE),
    Some(&WORD_UNDERC_NODE),
    Some(&WORD_UNDERD_NODE),
    Some(&WORD_UNDERE_NODE),
    Some(&WORD_UNDERF_NODE),
    Some(&WORD_UNDERG_NODE),
    Some(&WORD_UNDERH_NODE),
    None,
    None,
    None,
    Some(&WORD_UNDERL_NODE),
    Some(&WORD_UNDERM_NODE),
    Some(&WORD_UNDERN_NODE),
    Some(&WORD_UNDERO_NODE),
    Some(&WORD_UNDERP_NODE),
    None,
    Some(&WORD_UNDERR_NODE),
    Some(&WORD_UNDERS_NODE),
    Some(&WORD_UNDERT_NODE),
    Some(&WORD_UNDERU_NODE),
    None,
    Some(&WORD_UNDERW_NODE),
    None,
    Some(&WORD_UNDERY_NODE),
    None,
];

static WORD_UNDERY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNDERY_CHILDREN),
    value: None,
};

pub static WORD_UNDERY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("ling"),
    ],
    values: &[&["underlying"], &["underlying"]],
    range: 3..=4,
};

static WORD_UNDERW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNDERW_CHILDREN),
    value: None,
};

pub static WORD_UNDERW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aer"),
        dictgen::InsensitiveStr::Ascii("ager"),
        dictgen::InsensitiveStr::Ascii("ar"),
        dictgen::InsensitiveStr::Ascii("are"),
        dictgen::InsensitiveStr::Ascii("ares"),
        dictgen::InsensitiveStr::Ascii("arter"),
        dictgen::InsensitiveStr::Ascii("ealming"),
        dictgen::InsensitiveStr::Ascii("helimg"),
        dictgen::InsensitiveStr::Ascii("heling"),
        dictgen::InsensitiveStr::Ascii("hemling"),
        dictgen::InsensitiveStr::Ascii("hleming"),
        dictgen::InsensitiveStr::Ascii("ieght"),
        dictgen::InsensitiveStr::Ascii("olrd"),
        dictgen::InsensitiveStr::Ascii("oord"),
        dictgen::InsensitiveStr::Ascii("right"),
        dictgen::InsensitiveStr::Ascii("rold"),
    ],
    values: &[
        &["underwear"],
        &["underwater"],
        &["underwater"],
        &["underwear"],
        &["underwater"],
        &["underwater"],
        &["underwhelming"],
        &["underwhelming"],
        &["underwhelming"],
        &["underwhelming"],
        &["underwhelming"],
        &["underweight"],
        &["underworld"],
        &["underworld"],
        &["underweight"],
        &["underworld"],
    ],
    range: 2..=7,
};

static WORD_UNDERU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNDERU_CHILDREN),
    value: None,
};

pub static WORD_UNDERU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("n"),
        dictgen::InsensitiveStr::Ascii("ns"),
    ],
    values: &[&["underrun"], &["underruns"]],
    range: 1..=2,
};

static WORD_UNDERT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNDERT_CHILDREN),
    value: None,
};

pub static WORD_UNDERT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("able"),
        dictgen::InsensitiveStr::Ascii("acker"),
        dictgen::InsensitiveStr::Ascii("akeing"),
        dictgen::InsensitiveStr::Ascii("and"),
        dictgen::InsensitiveStr::Ascii("andable"),
        dictgen::InsensitiveStr::Ascii("anded"),
        dictgen::InsensitiveStr::Ascii("anding"),
        dictgen::InsensitiveStr::Ascii("ands"),
        dictgen::InsensitiveStr::Ascii("oe"),
        dictgen::InsensitiveStr::Ascii("oker"),
        dictgen::InsensitiveStr::Ascii("sand"),
        dictgen::InsensitiveStr::Ascii("sanding"),
        dictgen::InsensitiveStr::Ascii("sands"),
        dictgen::InsensitiveStr::Ascii("sood"),
        dictgen::InsensitiveStr::Ascii("stand"),
        dictgen::InsensitiveStr::Ascii("stands"),
        dictgen::InsensitiveStr::Ascii("unes"),
    ],
    values: &[
        &["understandable", "understand"],
        &["undertaker"],
        &["undertaking"],
        &["understand"],
        &["understandable"],
        &["understood"],
        &["understanding"],
        &["understands"],
        &["undertones"],
        &["undertaker"],
        &["understands", "understand"],
        &["understanding"],
        &["understands"],
        &["understood"],
        &["understand"],
        &["understands"],
        &["undertones"],
    ],
    range: 2..=7,
};

static WORD_UNDERS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNDERS_CHILDREN),
    value: None,
};

pub static WORD_UNDERS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("acn"),
        dictgen::InsensitiveStr::Ascii("atnd"),
        dictgen::InsensitiveStr::Ascii("etimate"),
        dictgen::InsensitiveStr::Ascii("etimated"),
        dictgen::InsensitiveStr::Ascii("og"),
        dictgen::InsensitiveStr::Ascii("tad"),
        dictgen::InsensitiveStr::Ascii("tadn"),
        dictgen::InsensitiveStr::Ascii("tadnable"),
        dictgen::InsensitiveStr::Ascii("tadning"),
        dictgen::InsensitiveStr::Ascii("tadns"),
        dictgen::InsensitiveStr::Ascii("tandablely"),
        dictgen::InsensitiveStr::Ascii("tandabley"),
        dictgen::InsensitiveStr::Ascii("tandble"),
        dictgen::InsensitiveStr::Ascii("tandbly"),
        dictgen::InsensitiveStr::Ascii("tandebly"),
        dictgen::InsensitiveStr::Ascii("tandible"),
        dictgen::InsensitiveStr::Ascii("tandibly"),
        dictgen::InsensitiveStr::Ascii("tandig"),
        dictgen::InsensitiveStr::Ascii("tannd"),
        dictgen::InsensitiveStr::Ascii("tans"),
        dictgen::InsensitiveStr::Ascii("tnad"),
        dictgen::InsensitiveStr::Ascii("toon"),
        dictgen::InsensitiveStr::Ascii("toud"),
        dictgen::InsensitiveStr::Ascii("tsand"),
        dictgen::InsensitiveStr::Ascii("tsnd"),
    ],
    values: &[
        &["underscan"],
        &["understands"],
        &["underestimate"],
        &["underestimated"],
        &["undergo"],
        &["understands"],
        &["understands", "understand"],
        &["understandable"],
        &["understanding"],
        &["understands"],
        &["understandably"],
        &["understandably"],
        &["understandable"],
        &["understandably"],
        &["understandably"],
        &["understandable"],
        &["understandably"],
        &["understanding"],
        &["understands"],
        &["understands"],
        &["understands"],
        &["understood"],
        &["understood"],
        &["understands"],
        &["understands"],
    ],
    range: 2..=10,
};

static WORD_UNDERR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNDERR_CHILDREN),
    value: None,
};

pub static WORD_UNDERR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aged"),
        dictgen::InsensitiveStr::Ascii("aker"),
        dictgen::InsensitiveStr::Ascii("ater"),
        dictgen::InsensitiveStr::Ascii("atted"),
        dictgen::InsensitiveStr::Ascii("run"),
    ],
    values: &[
        &["underrated"],
        &["undertaker"],
        &["undertaker"],
        &["underrated"],
        &["underrun"],
    ],
    range: 3..=5,
};

static WORD_UNDERP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNDERP_CHILDREN),
    value: None,
};

pub static WORD_UNDERP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ining"),
        dictgen::InsensitiveStr::Ascii("owed"),
        dictgen::InsensitiveStr::Ascii("owerd"),
        dictgen::InsensitiveStr::Ascii("owererd"),
        dictgen::InsensitiveStr::Ascii("owred"),
    ],
    values: &[
        &["undermining"],
        &["underpowered"],
        &["underpowered"],
        &["underpowered"],
        &["underpowered"],
    ],
    range: 4..=7,
};

static WORD_UNDERO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNDERO_CHILDREN),
    value: None,
};

pub static WORD_UNDERO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("g")],
    values: &[&["undergo"]],
    range: 1..=1,
};

static WORD_UNDERN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNDERN_CHILDREN),
    value: None,
};

pub static WORD_UNDERN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("earth"),
        dictgen::InsensitiveStr::Ascii("eeth"),
        dictgen::InsensitiveStr::Ascii("eight"),
        dictgen::InsensitiveStr::Ascii("eith"),
        dictgen::InsensitiveStr::Ascii("ieth"),
    ],
    values: &[
        &["underneath"],
        &["underneath"],
        &["underweight"],
        &["underneath"],
        &["underneath"],
    ],
    range: 4..=5,
};

static WORD_UNDERM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNDERM_CHILDREN),
    value: None,
};

pub static WORD_UNDERM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("imes"),
        dictgen::InsensitiveStr::Ascii("iming"),
        dictgen::InsensitiveStr::Ascii("inde"),
        dictgen::InsensitiveStr::Ascii("indes"),
        dictgen::InsensitiveStr::Ascii("inding"),
        dictgen::InsensitiveStr::Ascii("ineing"),
        dictgen::InsensitiveStr::Ascii("ineras"),
        dictgen::InsensitiveStr::Ascii("ineres"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("inging"),
        dictgen::InsensitiveStr::Ascii("inig"),
        dictgen::InsensitiveStr::Ascii("inining"),
        dictgen::InsensitiveStr::Ascii("inning"),
    ],
    values: &[
        &["undermines"],
        &["undermining"],
        &["undermines"],
        &["undermines"],
        &["undermining"],
        &["undermining"],
        &["undermines"],
        &["undermines"],
        &["undermining"],
        &["undermining"],
        &["undermining"],
        &["undermining"],
        &["undermining"],
    ],
    range: 3..=7,
};

static WORD_UNDERL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNDERL_CHILDREN),
    value: None,
};

pub static WORD_UNDERL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ayed"),
        dictgen::InsensitiveStr::Ascii("aying"),
        dictgen::InsensitiveStr::Ascii("flow"),
        dictgen::InsensitiveStr::Ascii("flowed"),
        dictgen::InsensitiveStr::Ascii("flowing"),
        dictgen::InsensitiveStr::Ascii("flows"),
        dictgen::InsensitiveStr::Ascii("fow"),
        dictgen::InsensitiveStr::Ascii("fowed"),
        dictgen::InsensitiveStr::Ascii("fowing"),
        dictgen::InsensitiveStr::Ascii("fows"),
        dictgen::InsensitiveStr::Ascii("ow"),
        dictgen::InsensitiveStr::Ascii("owed"),
        dictgen::InsensitiveStr::Ascii("owing"),
        dictgen::InsensitiveStr::Ascii("ows"),
        dictgen::InsensitiveStr::Ascii("yng"),
    ],
    values: &[
        &["underlaid"],
        &["underlying"],
        &["underflow"],
        &["underflowed"],
        &["underflowing"],
        &["underflows"],
        &["underflow"],
        &["underflowed"],
        &["underflowing"],
        &["underflows"],
        &["underflow"],
        &["underflowed"],
        &["underflowing"],
        &["underflows"],
        &["underlying"],
    ],
    range: 2..=7,
};

static WORD_UNDERH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNDERH_CHILDREN),
    value: None,
};

pub static WORD_UNDERH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eight"),
        dictgen::InsensitiveStr::Ascii("welming"),
        dictgen::InsensitiveStr::Ascii("wleming"),
    ],
    values: &[&["underweight"], &["underwhelming"], &["underwhelming"]],
    range: 5..=7,
};

static WORD_UNDERG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNDERG_CHILDREN),
    value: None,
};

pub static WORD_UNDERG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ard"),
        dictgen::InsensitiveStr::Ascii("ated"),
        dictgen::InsensitiveStr::Ascii("ating"),
        dictgen::InsensitiveStr::Ascii("lo"),
        dictgen::InsensitiveStr::Ascii("orund"),
        dictgen::InsensitiveStr::Ascii("radate"),
        dictgen::InsensitiveStr::Ascii("radute"),
        dictgen::InsensitiveStr::Ascii("rand"),
        dictgen::InsensitiveStr::Ascii("ratuate"),
        dictgen::InsensitiveStr::Ascii("roud"),
        dictgen::InsensitiveStr::Ascii("rund"),
    ],
    values: &[
        &["undergrad"],
        &["underrated"],
        &["undertaking"],
        &["undergo"],
        &["underground"],
        &["undergraduate"],
        &["undergraduate"],
        &["undergrad"],
        &["undergraduate"],
        &["underground"],
        &["underground"],
    ],
    range: 2..=7,
};

static WORD_UNDERF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNDERF_CHILDREN),
    value: None,
};

pub static WORD_UNDERF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aker"),
        dictgen::InsensitiveStr::Ascii("iend"),
        dictgen::InsensitiveStr::Ascii("ined"),
        dictgen::InsensitiveStr::Ascii("ow"),
        dictgen::InsensitiveStr::Ascii("owed"),
        dictgen::InsensitiveStr::Ascii("owing"),
        dictgen::InsensitiveStr::Ascii("ows"),
    ],
    values: &[
        &["undertaker"],
        &["undefined"],
        &["undefined"],
        &["underflow"],
        &["underflowed"],
        &["underflowing"],
        &["underflows"],
    ],
    range: 2..=5,
};

static WORD_UNDERE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNDERE_CHILDREN),
    value: None,
};

pub static WORD_UNDERE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("sitmate"),
        dictgen::InsensitiveStr::Ascii("stamate"),
        dictgen::InsensitiveStr::Ascii("stamated"),
        dictgen::InsensitiveStr::Ascii("stemate"),
        dictgen::InsensitiveStr::Ascii("stemated"),
        dictgen::InsensitiveStr::Ascii("stemating"),
        dictgen::InsensitiveStr::Ascii("stiamte"),
        dictgen::InsensitiveStr::Ascii("stimateing"),
        dictgen::InsensitiveStr::Ascii("stime"),
        dictgen::InsensitiveStr::Ascii("stimeted"),
    ],
    values: &[
        &["underestimated"],
        &["underestimate"],
        &["underestimated"],
        &["underestimate"],
        &["underestimated"],
        &["underestimating"],
        &["underestimated"],
        &["underestimating"],
        &["underestimate"],
        &["underestimated"],
    ],
    range: 5..=10,
};

static WORD_UNDERD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNDERD_CHILDREN),
    value: None,
};

pub static WORD_UNDERD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ong")],
    values: &[&["underdog"]],
    range: 3..=3,
};

static WORD_UNDERC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNDERC_CHILDREN),
    value: None,
};

pub static WORD_UNDERC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ling"),
        dictgen::InsensitiveStr::Ascii("unt"),
    ],
    values: &[&["underlying"], &["undercut"]],
    range: 3..=4,
};

static WORD_UNDERB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNDERB_CHILDREN),
    value: None,
};

pub static WORD_UNDERB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aker"),
        dictgen::InsensitiveStr::Ascii("og"),
    ],
    values: &[&["undertaker"], &["undergo"]],
    range: 2..=4,
};

static WORD_UNDERA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNDERA_CHILDREN),
    value: None,
};

pub static WORD_UNDERA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("stimate"),
        dictgen::InsensitiveStr::Ascii("stimated"),
        dictgen::InsensitiveStr::Ascii("stimating"),
    ],
    values: &[
        &["underestimate"],
        &["underestimated"],
        &["underestimating"],
    ],
    range: 7..=9,
};

static WORD_UNDEP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNDEP_CHILDREN),
    value: None,
};

pub static WORD_UNDEP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("endend")],
    values: &[&["independent", "nondependent"]],
    range: 6..=6,
};

static WORD_UNDEN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNDEN_CHILDREN),
    value: None,
};

pub static WORD_UNDEN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aible"),
        dictgen::InsensitiveStr::Ascii("aibly"),
        dictgen::InsensitiveStr::Ascii("iabely"),
        dictgen::InsensitiveStr::Ascii("iablely"),
        dictgen::InsensitiveStr::Ascii("iabley"),
        dictgen::InsensitiveStr::Ascii("iablly"),
        dictgen::InsensitiveStr::Ascii("ialbly"),
        dictgen::InsensitiveStr::Ascii("yable"),
        dictgen::InsensitiveStr::Ascii("yably"),
    ],
    values: &[
        &["undeniable"],
        &["undeniably"],
        &["undeniably"],
        &["undeniably"],
        &["undeniably"],
        &["undeniably"],
        &["undeniably"],
        &["undeniable"],
        &["undeniably"],
    ],
    range: 5..=7,
};

static WORD_UNDEL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNDEL_CHILDREN),
    value: None,
};

pub static WORD_UNDEL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ying")],
    values: &[&["underlying"]],
    range: 4..=4,
};

static WORD_UNDEI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNDEI_CHILDREN),
    value: None,
};

pub static WORD_UNDEI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("nable"),
        dictgen::InsensitiveStr::Ascii("nably"),
    ],
    values: &[&["undeniable"], &["undeniably"]],
    range: 5..=5,
};

static WORD_UNDEF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNDEF_CHILDREN),
    value: None,
};

pub static WORD_UNDEF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ied"),
        dictgen::InsensitiveStr::Ascii("ien"),
        dictgen::InsensitiveStr::Ascii("iend"),
        dictgen::InsensitiveStr::Ascii("inied"),
        dictgen::InsensitiveStr::Ascii("initely"),
        dictgen::InsensitiveStr::Ascii("low"),
        dictgen::InsensitiveStr::Ascii("lows"),
        dictgen::InsensitiveStr::Ascii("uned"),
    ],
    values: &[
        &["undefined"],
        &["undefine"],
        &["undefined"],
        &["undefined"],
        &["indefinitely"],
        &["underflow"],
        &["underflows"],
        &["undefined"],
    ],
    range: 3..=7,
};

static WORD_UNDEC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNDEC_CHILDREN),
    value: None,
};

pub static WORD_UNDEC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ideable")],
    values: &[&["undecidable"]],
    range: 7..=7,
};

static WORD_UNDEB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNDEB_CHILDREN),
    value: None,
};

pub static WORD_UNDEB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("iably")],
    values: &[&["undeniably"]],
    range: 5..=5,
};

static WORD_UNC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_UNC_CHILDREN),
    value: None,
};

static WORD_UNC_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_UNCA_NODE),
    None,
    None,
    None,
    Some(&WORD_UNCE_NODE),
    None,
    None,
    Some(&WORD_UNCH_NODE),
    None,
    None,
    None,
    Some(&WORD_UNCL_NODE),
    None,
    None,
    Some(&WORD_UNCO_NODE),
    None,
    None,
    Some(&WORD_UNCR_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_UNCR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNCR_CHILDREN),
    value: None,
};

pub static WORD_UNCR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ypted")],
    values: &[&["unencrypted"]],
    range: 5..=5,
};

static WORD_UNCO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_UNCO_CHILDREN),
    value: None,
};

static WORD_UNCO_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_UNCOG_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_UNCOM_NODE),
    Some(&WORD_UNCON_NODE),
    None,
    None,
    None,
    Some(&WORD_UNCOR_NODE),
    None,
    None,
    Some(&WORD_UNCOU_NODE),
    Some(&WORD_UNCOV_NODE),
    None,
    None,
    None,
    None,
];

static WORD_UNCOV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNCOV_CHILDREN),
    value: None,
};

pub static WORD_UNCOV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("erted")],
    values: &[&["unconverted"]],
    range: 5..=5,
};

static WORD_UNCOU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNCOU_CHILDREN),
    value: None,
};

pub static WORD_UNCOU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ncious"),
        dictgen::InsensitiveStr::Ascii("nciously"),
        dictgen::InsensitiveStr::Ascii("sciously"),
    ],
    values: &[&["unconscious"], &["unconsciously"], &["unconsciously"]],
    range: 6..=8,
};

static WORD_UNCOR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNCOR_CHILDREN),
    value: None,
};

pub static WORD_UNCOR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ectly"),
        dictgen::InsensitiveStr::Ascii("elated"),
        dictgen::InsensitiveStr::Ascii("rect"),
        dictgen::InsensitiveStr::Ascii("rectly"),
        dictgen::InsensitiveStr::Ascii("rolated"),
    ],
    values: &[
        &["incorrectly"],
        &["uncorrelated"],
        &["incorrect"],
        &["incorrectly"],
        &["uncorrelated"],
    ],
    range: 4..=7,
};

static WORD_UNCON_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_UNCON_CHILDREN),
    value: None,
};

static WORD_UNCON_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    Some(&WORD_UNCONC_NODE),
    Some(&WORD_UNCOND_NODE),
    None,
    Some(&WORD_UNCONF_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_UNCONS_NODE),
    Some(&WORD_UNCONT_NODE),
    None,
    Some(&WORD_UNCONV_NODE),
    None,
    None,
    None,
    None,
];

static WORD_UNCONV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNCONV_CHILDREN),
    value: None,
};

pub static WORD_UNCONV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ectional"),
        dictgen::InsensitiveStr::Ascii("encional"),
        dictgen::InsensitiveStr::Ascii("enient"),
        dictgen::InsensitiveStr::Ascii("ensional"),
        dictgen::InsensitiveStr::Ascii("ential"),
        dictgen::InsensitiveStr::Ascii("entianal"),
        dictgen::InsensitiveStr::Ascii("entinal"),
        dictgen::InsensitiveStr::Ascii("entionnal"),
    ],
    values: &[
        &["unconventional"],
        &["unconventional"],
        &["inconvenient"],
        &["unconventional"],
        &["unconventional"],
        &["unconventional"],
        &["unconventional"],
        &["unconventional"],
    ],
    range: 6..=9,
};

static WORD_UNCONT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNCONT_CHILDREN),
    value: None,
};

pub static WORD_UNCONT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("itutional"),
        dictgen::InsensitiveStr::Ascii("rained"),
        dictgen::InsensitiveStr::Ascii("rallable"),
        dictgen::InsensitiveStr::Ascii("rallably"),
        dictgen::InsensitiveStr::Ascii("rolable"),
        dictgen::InsensitiveStr::Ascii("rolablly"),
        dictgen::InsensitiveStr::Ascii("rollabe"),
        dictgen::InsensitiveStr::Ascii("rollablely"),
        dictgen::InsensitiveStr::Ascii("rollabley"),
        dictgen::InsensitiveStr::Ascii("rollablly"),
        dictgen::InsensitiveStr::Ascii("rollaby"),
    ],
    values: &[
        &["unconstitutional"],
        &["unconstrained"],
        &["uncontrollable"],
        &["uncontrollably"],
        &["uncontrollable"],
        &["uncontrollably"],
        &["uncontrollable"],
        &["uncontrollably"],
        &["uncontrollably"],
        &["uncontrollably"],
        &["uncontrollably"],
    ],
    range: 6..=10,
};

static WORD_UNCONS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNCONS_CHILDREN),
    value: None,
};

pub static WORD_UNCONS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ciosly"),
        dictgen::InsensitiveStr::Ascii("cioulsy"),
        dictgen::InsensitiveStr::Ascii("ciouly"),
        dictgen::InsensitiveStr::Ascii("ciouslly"),
        dictgen::InsensitiveStr::Ascii("cous"),
        dictgen::InsensitiveStr::Ascii("icous"),
        dictgen::InsensitiveStr::Ascii("icously"),
        dictgen::InsensitiveStr::Ascii("iderate"),
        dictgen::InsensitiveStr::Ascii("isntency"),
        dictgen::InsensitiveStr::Ascii("istent"),
        dictgen::InsensitiveStr::Ascii("tititional"),
        dictgen::InsensitiveStr::Ascii("tituional"),
        dictgen::InsensitiveStr::Ascii("titutionnal"),
    ],
    values: &[
        &["unconsciously"],
        &["unconsciously"],
        &["unconsciously"],
        &["unconsciously"],
        &["unconscious"],
        &["unconscious"],
        &["unconsciously"],
        &["inconsiderate"],
        &["inconsistency"],
        &["inconsistent"],
        &["unconstitutional"],
        &["unconstitutional"],
        &["unconstitutional"],
    ],
    range: 4..=11,
};

static WORD_UNCONF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNCONF_CHILDREN),
    value: None,
};

pub static WORD_UNCONF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("iged"),
        dictgen::InsensitiveStr::Ascii("ortability"),
        dictgen::InsensitiveStr::Ascii("ortable"),
        dictgen::InsensitiveStr::Ascii("ortably"),
    ],
    values: &[
        &["unconfigured"],
        &["discomfort"],
        &["uncomfortable"],
        &["uncomfortably"],
    ],
    range: 4..=10,
};

static WORD_UNCOND_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNCOND_CHILDREN),
    value: None,
};

pub static WORD_UNCOND_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("isional"),
        dictgen::InsensitiveStr::Ascii("isionaly"),
        dictgen::InsensitiveStr::Ascii("isionnal"),
        dictgen::InsensitiveStr::Ascii("isionnaly"),
        dictgen::InsensitiveStr::Ascii("itial"),
        dictgen::InsensitiveStr::Ascii("itially"),
        dictgen::InsensitiveStr::Ascii("itialy"),
        dictgen::InsensitiveStr::Ascii("itianal"),
        dictgen::InsensitiveStr::Ascii("itianally"),
        dictgen::InsensitiveStr::Ascii("itianaly"),
        dictgen::InsensitiveStr::Ascii("itinal"),
        dictgen::InsensitiveStr::Ascii("itinally"),
        dictgen::InsensitiveStr::Ascii("itinaly"),
        dictgen::InsensitiveStr::Ascii("itionable"),
        dictgen::InsensitiveStr::Ascii("itionaly"),
        dictgen::InsensitiveStr::Ascii("itionnal"),
        dictgen::InsensitiveStr::Ascii("itionnally"),
        dictgen::InsensitiveStr::Ascii("itionnaly"),
        dictgen::InsensitiveStr::Ascii("itonal"),
        dictgen::InsensitiveStr::Ascii("itonally"),
        dictgen::InsensitiveStr::Ascii("tional"),
        dictgen::InsensitiveStr::Ascii("tionally"),
    ],
    values: &[
        &["unconditional"],
        &["unconditionally"],
        &["unconditional"],
        &["unconditionally"],
        &["unconditional"],
        &["unconditionally"],
        &["unconditionally"],
        &["unconditional"],
        &["unconditionally"],
        &["unconditionally"],
        &["unconditional"],
        &["unconditionally"],
        &["unconditionally"],
        &["unconditional"],
        &["unconditionally"],
        &["unconditional"],
        &["unconditionally"],
        &["unconditionally"],
        &["unconditional"],
        &["unconditionally"],
        &["unconditional"],
        &["unconditionally"],
    ],
    range: 5..=10,
};

static WORD_UNCONC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNCONC_CHILDREN),
    value: None,
};

pub static WORD_UNCONC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ious"),
        dictgen::InsensitiveStr::Ascii("iousness"),
        dictgen::InsensitiveStr::Ascii("istencies"),
        dictgen::InsensitiveStr::Ascii("istency"),
        dictgen::InsensitiveStr::Ascii("istent"),
        dictgen::InsensitiveStr::Ascii("sious"),
        dictgen::InsensitiveStr::Ascii("siously"),
    ],
    values: &[
        &["unconscious"],
        &["unconsciousness"],
        &["inconsistencies"],
        &["inconsistency"],
        &["inconsistent"],
        &["unconscious"],
        &["unconsciously"],
    ],
    range: 4..=9,
};

static WORD_UNCOM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNCOM_CHILDREN),
    value: None,
};

pub static WORD_UNCOM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ent"),
        dictgen::InsensitiveStr::Ascii("ented"),
        dictgen::InsensitiveStr::Ascii("enting"),
        dictgen::InsensitiveStr::Ascii("ents"),
        dictgen::InsensitiveStr::Ascii("fertable"),
        dictgen::InsensitiveStr::Ascii("fertably"),
        dictgen::InsensitiveStr::Ascii("fortabel"),
        dictgen::InsensitiveStr::Ascii("fortablely"),
        dictgen::InsensitiveStr::Ascii("fortabley"),
        dictgen::InsensitiveStr::Ascii("fortablity"),
        dictgen::InsensitiveStr::Ascii("fortablly"),
        dictgen::InsensitiveStr::Ascii("foryable"),
        dictgen::InsensitiveStr::Ascii("frotable"),
        dictgen::InsensitiveStr::Ascii("frotably"),
        dictgen::InsensitiveStr::Ascii("ftorable"),
        dictgen::InsensitiveStr::Ascii("ftorably"),
        dictgen::InsensitiveStr::Ascii("ited"),
        dictgen::InsensitiveStr::Ascii("itted"),
        dictgen::InsensitiveStr::Ascii("mited"),
        dictgen::InsensitiveStr::Ascii("mment"),
        dictgen::InsensitiveStr::Ascii("mmented"),
        dictgen::InsensitiveStr::Ascii("mmenting"),
        dictgen::InsensitiveStr::Ascii("mments"),
        dictgen::InsensitiveStr::Ascii("mmitted"),
        dictgen::InsensitiveStr::Ascii("mmon"),
        dictgen::InsensitiveStr::Ascii("mpresed"),
        dictgen::InsensitiveStr::Ascii("mpresion"),
        dictgen::InsensitiveStr::Ascii("mpressd"),
        dictgen::InsensitiveStr::Ascii("mpressed"),
        dictgen::InsensitiveStr::Ascii("mpression"),
        dictgen::InsensitiveStr::Ascii("mtited"),
        dictgen::InsensitiveStr::Ascii("on"),
        dictgen::InsensitiveStr::Ascii("patible"),
        dictgen::InsensitiveStr::Ascii("petetive"),
        dictgen::InsensitiveStr::Ascii("petive"),
        dictgen::InsensitiveStr::Ascii("plete"),
        dictgen::InsensitiveStr::Ascii("pleteness"),
        dictgen::InsensitiveStr::Ascii("pletness"),
        dictgen::InsensitiveStr::Ascii("pres"),
        dictgen::InsensitiveStr::Ascii("presed"),
        dictgen::InsensitiveStr::Ascii("preses"),
        dictgen::InsensitiveStr::Ascii("presing"),
        dictgen::InsensitiveStr::Ascii("presor"),
        dictgen::InsensitiveStr::Ascii("presors"),
        dictgen::InsensitiveStr::Ascii("pressible"),
        dictgen::InsensitiveStr::Ascii("prss"),
    ],
    values: &[
        &["uncomment"],
        &["uncommented"],
        &["uncommenting"],
        &["uncomments"],
        &["uncomfortable"],
        &["uncomfortably"],
        &["uncomfortably"],
        &["uncomfortably"],
        &["uncomfortably"],
        &["uncomfortably"],
        &["uncomfortably"],
        &["uncomfortably"],
        &["uncomfortable"],
        &["uncomfortably"],
        &["uncomfortable"],
        &["uncomfortably"],
        &["uncommitted"],
        &["uncommitted"],
        &["uncommitted"],
        &["uncomment"],
        &["uncommented"],
        &["uncommenting"],
        &["uncomments"],
        &["uncommitted"],
        &["uncommon"],
        &["uncompressed"],
        &["uncompression"],
        &["uncompressed"],
        &["uncompressed"],
        &["uncompression"],
        &["uncommitted"],
        &["uncommon"],
        &["incompatible"],
        &["uncompetitive"],
        &["uncompetitive"],
        &["incomplete"],
        &["incompleteness"],
        &["incompleteness"],
        &["uncompress"],
        &["uncompressed"],
        &["uncompresses"],
        &["uncompressing"],
        &["uncompressor"],
        &["uncompressors"],
        &["incompressible"],
        &["uncompress"],
    ],
    range: 2..=10,
};

static WORD_UNCOG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNCOG_CHILDREN),
    value: None,
};

pub static WORD_UNCOG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("nized")],
    values: &[&["unrecognized"]],
    range: 5..=5,
};

static WORD_UNCL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNCL_CHILDREN),
    value: None,
};

pub static WORD_UNCL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("er")],
    values: &[&["uncle", "unclear", "uncles"]],
    range: 2..=2,
};

static WORD_UNCH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNCH_CHILDREN),
    value: None,
};

pub static WORD_UNCH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ache"),
        dictgen::InsensitiveStr::Ascii("ached"),
        dictgen::InsensitiveStr::Ascii("aged"),
        dictgen::InsensitiveStr::Ascii("ainged"),
        dictgen::InsensitiveStr::Ascii("allengable"),
        dictgen::InsensitiveStr::Ascii("aned"),
        dictgen::InsensitiveStr::Ascii("aneged"),
        dictgen::InsensitiveStr::Ascii("angable"),
        dictgen::InsensitiveStr::Ascii("angd"),
        dictgen::InsensitiveStr::Ascii("eked"),
        dictgen::InsensitiveStr::Ascii("enged"),
    ],
    values: &[
        &["uncache"],
        &["uncached"],
        &["unchanged"],
        &["unchanged"],
        &["unchallengeable"],
        &["unchanged"],
        &["unchanged"],
        &["unchangeable"],
        &["unchanged"],
        &["unchecked"],
        &["unchanged"],
    ],
    range: 4..=10,
};

static WORD_UNCE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNCE_CHILDREN),
    value: Some(&["once"]),
};

pub static WORD_UNCE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("hck"),
        dictgen::InsensitiveStr::Ascii("hcked"),
        dictgen::InsensitiveStr::Ascii("ncored"),
        dictgen::InsensitiveStr::Ascii("nsered"),
        dictgen::InsensitiveStr::Ascii("nsord"),
        dictgen::InsensitiveStr::Ascii("nsorred"),
        dictgen::InsensitiveStr::Ascii("rain"),
        dictgen::InsensitiveStr::Ascii("rainties"),
        dictgen::InsensitiveStr::Ascii("rainty"),
        dictgen::InsensitiveStr::Ascii("rsored"),
        dictgen::InsensitiveStr::Ascii("rtaincy"),
        dictgen::InsensitiveStr::Ascii("rtainities"),
        dictgen::InsensitiveStr::Ascii("rtainity"),
        dictgen::InsensitiveStr::Ascii("rtaintity"),
        dictgen::InsensitiveStr::Ascii("rtaintly"),
        dictgen::InsensitiveStr::Ascii("rtainy"),
        dictgen::InsensitiveStr::Ascii("rtanity"),
        dictgen::InsensitiveStr::Ascii("rtanty"),
        dictgen::InsensitiveStr::Ascii("rtianty"),
        dictgen::InsensitiveStr::Ascii("snored"),
        dictgen::InsensitiveStr::Ascii("ssarily"),
        dictgen::InsensitiveStr::Ascii("tain"),
        dictgen::InsensitiveStr::Ascii("tainties"),
        dictgen::InsensitiveStr::Ascii("tainty"),
    ],
    values: &[
        &["uncheck"],
        &["unchecked"],
        &["uncensored"],
        &["uncensored"],
        &["uncensored"],
        &["uncensored"],
        &["uncertain"],
        &["uncertainties"],
        &["uncertainty"],
        &["uncensored"],
        &["uncertainty"],
        &["uncertainties"],
        &["uncertainty"],
        &["uncertainty"],
        &["uncertainty"],
        &["uncertainty"],
        &["uncertainty"],
        &["uncertainty"],
        &["uncertainty"],
        &["uncensored"],
        &["unnecessarily"],
        &["uncertain"],
        &["uncertainties"],
        &["uncertainty"],
    ],
    range: 3..=10,
};

static WORD_UNCA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNCA_CHILDREN),
    value: None,
};

pub static WORD_UNCA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("hnged"),
        dictgen::InsensitiveStr::Ascii("lcualted"),
        dictgen::InsensitiveStr::Ascii("nney"),
        dictgen::InsensitiveStr::Ascii("nnny"),
        dictgen::InsensitiveStr::Ascii("talogued"),
    ],
    values: &[
        &["unchanged"],
        &["uncalculated"],
        &["uncanny"],
        &["uncanny"],
        &["uncataloged"],
    ],
    range: 4..=8,
};

static WORD_UNB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNB_CHILDREN),
    value: None,
};

pub static WORD_UNB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("alanaced"),
        dictgen::InsensitiveStr::Ascii("alenced"),
        dictgen::InsensitiveStr::Ascii("allance"),
        dictgen::InsensitiveStr::Ascii("alnaced"),
        dictgen::InsensitiveStr::Ascii("anend"),
        dictgen::InsensitiveStr::Ascii("annd"),
        dictgen::InsensitiveStr::Ascii("annend"),
        dictgen::InsensitiveStr::Ascii("areable"),
        dictgen::InsensitiveStr::Ascii("eakable"),
        dictgen::InsensitiveStr::Ascii("eareble"),
        dictgen::InsensitiveStr::Ascii("eatbale"),
        dictgen::InsensitiveStr::Ascii("eateble"),
        dictgen::InsensitiveStr::Ascii("eerable"),
        dictgen::InsensitiveStr::Ascii("eetable"),
        dictgen::InsensitiveStr::Ascii("eknowst"),
        dictgen::InsensitiveStr::Ascii("eleifable"),
        dictgen::InsensitiveStr::Ascii("eleivable"),
        dictgen::InsensitiveStr::Ascii("eleivably"),
        dictgen::InsensitiveStr::Ascii("eliavable"),
        dictgen::InsensitiveStr::Ascii("eliavably"),
        dictgen::InsensitiveStr::Ascii("eliebable"),
        dictgen::InsensitiveStr::Ascii("eliefable"),
        dictgen::InsensitiveStr::Ascii("elievablely"),
        dictgen::InsensitiveStr::Ascii("elievabley"),
        dictgen::InsensitiveStr::Ascii("elievablly"),
        dictgen::InsensitiveStr::Ascii("elieveble"),
        dictgen::InsensitiveStr::Ascii("elievibly"),
        dictgen::InsensitiveStr::Ascii("elivable"),
        dictgen::InsensitiveStr::Ascii("eliveable"),
        dictgen::InsensitiveStr::Ascii("eliveably"),
        dictgen::InsensitiveStr::Ascii("elivebly"),
        dictgen::InsensitiveStr::Ascii("elizeable"),
        dictgen::InsensitiveStr::Ascii("olievable"),
        dictgen::InsensitiveStr::Ascii("orned"),
        dictgen::InsensitiveStr::Ascii("ouind"),
        dictgen::InsensitiveStr::Ascii("ouinded"),
        dictgen::InsensitiveStr::Ascii("oun"),
        dictgen::InsensitiveStr::Ascii("ounad"),
        dictgen::InsensitiveStr::Ascii("ounaded"),
        dictgen::InsensitiveStr::Ascii("ouned"),
        dictgen::InsensitiveStr::Ascii("ounnd"),
        dictgen::InsensitiveStr::Ascii("ounnded"),
        dictgen::InsensitiveStr::Ascii("ouund"),
        dictgen::InsensitiveStr::Ascii("ouunded"),
        dictgen::InsensitiveStr::Ascii("raikable"),
        dictgen::InsensitiveStr::Ascii("rakeable"),
        dictgen::InsensitiveStr::Ascii("reakabie"),
        dictgen::InsensitiveStr::Ascii("reakabke"),
        dictgen::InsensitiveStr::Ascii("reakbale"),
        dictgen::InsensitiveStr::Ascii("reakble"),
        dictgen::InsensitiveStr::Ascii("reakeble"),
        dictgen::InsensitiveStr::Ascii("rearable"),
        dictgen::InsensitiveStr::Ascii("unded"),
    ],
    values: &[
        &["unbalanced"],
        &["unbalanced"],
        &["unbalance"],
        &["unbalanced"],
        &["unbanned"],
        &["unbanned"],
        &["unbanned"],
        &["unbearable"],
        &["unbeatable"],
        &["unbearable"],
        &["unbeatable"],
        &["unbeatable"],
        &["unbearable"],
        &["unbeatable"],
        &["unbeknownst"],
        &["unbelievable"],
        &["unbelievable"],
        &["unbelievably"],
        &["unbelievable"],
        &["unbelievably"],
        &["unbelievable"],
        &["unbelievable"],
        &["unbelievably"],
        &["unbelievably"],
        &["unbelievably"],
        &["unbelievable"],
        &["unbelievably"],
        &["unbelievable"],
        &["unbelievable"],
        &["unbelievably"],
        &["unbelievably"],
        &["unbelievable"],
        &["unbelievable"],
        &["unborn"],
        &["unbound"],
        &["unbounded"],
        &["unbound"],
        &["unbound"],
        &["unbounded"],
        &["unbounded"],
        &["unbound"],
        &["unbounded"],
        &["unbound"],
        &["unbounded"],
        &["unbreakable"],
        &["unbreakable"],
        &["unbreakable"],
        &["unbreakable"],
        &["unbreakable"],
        &["unbreakable"],
        &["unbreakable"],
        &["unbreakable"],
        &["unbundled", "unbounded"],
    ],
    range: 3..=11,
};

static WORD_UNA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_UNA_CHILDREN),
    value: None,
};

static WORD_UNA_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    Some(&WORD_UNAB_NODE),
    Some(&WORD_UNAC_NODE),
    Some(&WORD_UNAD_NODE),
    None,
    Some(&WORD_UNAF_NODE),
    None,
    Some(&WORD_UNAH_NODE),
    Some(&WORD_UNAI_NODE),
    None,
    None,
    Some(&WORD_UNAL_NODE),
    Some(&WORD_UNAM_NODE),
    Some(&WORD_UNAN_NODE),
    None,
    Some(&WORD_UNAP_NODE),
    Some(&WORD_UNAQ_NODE),
    Some(&WORD_UNAR_NODE),
    Some(&WORD_UNAS_NODE),
    Some(&WORD_UNAT_NODE),
    Some(&WORD_UNAU_NODE),
    Some(&WORD_UNAV_NODE),
    Some(&WORD_UNAW_NODE),
    None,
    None,
    None,
];

static WORD_UNAW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNAW_CHILDREN),
    value: None,
};

pub static WORD_UNAW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("nsered")],
    values: &[&["unanswered"]],
    range: 6..=6,
};

static WORD_UNAV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNAV_CHILDREN),
    value: None,
};

pub static WORD_UNAV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aiable"),
        dictgen::InsensitiveStr::Ascii("aialable"),
        dictgen::InsensitiveStr::Ascii("aialbale"),
        dictgen::InsensitiveStr::Ascii("aialbe"),
        dictgen::InsensitiveStr::Ascii("aialbel"),
        dictgen::InsensitiveStr::Ascii("aialbility"),
        dictgen::InsensitiveStr::Ascii("aialble"),
        dictgen::InsensitiveStr::Ascii("aible"),
        dictgen::InsensitiveStr::Ascii("ailabe"),
        dictgen::InsensitiveStr::Ascii("ailabel"),
        dictgen::InsensitiveStr::Ascii("ailablility"),
        dictgen::InsensitiveStr::Ascii("ailble"),
        dictgen::InsensitiveStr::Ascii("ailiability"),
        dictgen::InsensitiveStr::Ascii("ailible"),
        dictgen::InsensitiveStr::Ascii("aliable"),
        dictgen::InsensitiveStr::Ascii("aoidable"),
        dictgen::InsensitiveStr::Ascii("ilable"),
        dictgen::InsensitiveStr::Ascii("iodable"),
        dictgen::InsensitiveStr::Ascii("oidble"),
    ],
    values: &[
        &["unavailable"],
        &["unavailable"],
        &["unavailable"],
        &["unavailable"],
        &["unavailable"],
        &["unavailability"],
        &["unavailable"],
        &["unavailable"],
        &["unavailable"],
        &["unavailable"],
        &["unavailability"],
        &["unavailable"],
        &["unavailability"],
        &["unavailable"],
        &["unavailable"],
        &["unavoidable"],
        &["unavailable"],
        &["unavoidable"],
        &["unavoidable"],
    ],
    range: 5..=11,
};

static WORD_UNAU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNAU_CHILDREN),
    value: None,
};

pub static WORD_UNAU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("thenicated"),
        dictgen::InsensitiveStr::Ascii("thenticed"),
        dictgen::InsensitiveStr::Ascii("therized"),
        dictgen::InsensitiveStr::Ascii("thoried"),
        dictgen::InsensitiveStr::Ascii("throized"),
    ],
    values: &[
        &["unauthenticated"],
        &["unauthenticated"],
        &["unauthorized"],
        &["unauthorized"],
        &["unauthorized"],
    ],
    range: 7..=10,
};

static WORD_UNAT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNAT_CHILDREN),
    value: None,
};

pub static WORD_UNAT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("henticated"),
        dictgen::InsensitiveStr::Ascii("horised"),
        dictgen::InsensitiveStr::Ascii("horized"),
        dictgen::InsensitiveStr::Ascii("tanded"),
        dictgen::InsensitiveStr::Ascii("teded"),
        dictgen::InsensitiveStr::Ascii("tendend"),
        dictgen::InsensitiveStr::Ascii("teneded"),
        dictgen::InsensitiveStr::Ascii("tented"),
        dictgen::InsensitiveStr::Ascii("tracive"),
        dictgen::InsensitiveStr::Ascii("tractice"),
    ],
    values: &[
        &["unauthenticated"],
        &["unauthorised"],
        &["unauthorized"],
        &["unattended"],
        &["unattended"],
        &["unattended"],
        &["unattended"],
        &["unattended"],
        &["unattractive"],
        &["unattractive"],
    ],
    range: 5..=10,
};

static WORD_UNAS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNAS_CHILDREN),
    value: None,
};

pub static WORD_UNAS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("nwered"),
        dictgen::InsensitiveStr::Ascii("sing"),
        dictgen::InsensitiveStr::Ascii("singed"),
        dictgen::InsensitiveStr::Ascii("singing"),
        dictgen::InsensitiveStr::Ascii("sings"),
    ],
    values: &[
        &["unanswered"],
        &["unassign"],
        &["unassigned"],
        &["unassigning"],
        &["unassigns"],
    ],
    range: 4..=7,
};

static WORD_UNAR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNAR_CHILDREN),
    value: None,
};

pub static WORD_UNAR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("chving")],
    values: &[&["unarchiving"]],
    range: 6..=6,
};

static WORD_UNAQ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNAQ_CHILDREN),
    value: None,
};

pub static WORD_UNAQ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("uired")],
    values: &[&["unacquired"]],
    range: 5..=5,
};

static WORD_UNAP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNAP_CHILDREN),
    value: None,
};

pub static WORD_UNAP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("pealling"),
        dictgen::InsensitiveStr::Ascii("peasing"),
        dictgen::InsensitiveStr::Ascii("peeling"),
        dictgen::InsensitiveStr::Ascii("pretiated"),
        dictgen::InsensitiveStr::Ascii("pretiative"),
        dictgen::InsensitiveStr::Ascii("prieciated"),
        dictgen::InsensitiveStr::Ascii("prieciative"),
        dictgen::InsensitiveStr::Ascii("propriate"),
        dictgen::InsensitiveStr::Ascii("propriately"),
        dictgen::InsensitiveStr::Ascii("retiated"),
        dictgen::InsensitiveStr::Ascii("retiative"),
    ],
    values: &[
        &["unappealing"],
        &["unappealing"],
        &["unappealing"],
        &["unappreciated"],
        &["unappreciative"],
        &["unappreciated"],
        &["unappreciative"],
        &["inappropriate"],
        &["inappropriately"],
        &["unappreciated"],
        &["unappreciative"],
    ],
    range: 7..=11,
};

static WORD_UNAN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNAN_CHILDREN),
    value: None,
};

pub static WORD_UNAN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("imoulsy"),
        dictgen::InsensitiveStr::Ascii("imuous"),
        dictgen::InsensitiveStr::Ascii("imuously"),
        dictgen::InsensitiveStr::Ascii("mious"),
        dictgen::InsensitiveStr::Ascii("nimous"),
        dictgen::InsensitiveStr::Ascii("nimously"),
        dictgen::InsensitiveStr::Ascii("nomous"),
        dictgen::InsensitiveStr::Ascii("nomously"),
        dictgen::InsensitiveStr::Ascii("nomus"),
        dictgen::InsensitiveStr::Ascii("nomusly"),
        dictgen::InsensitiveStr::Ascii("omous"),
        dictgen::InsensitiveStr::Ascii("omously"),
        dictgen::InsensitiveStr::Ascii("omus"),
        dictgen::InsensitiveStr::Ascii("omusly"),
        dictgen::InsensitiveStr::Ascii("swerd"),
        dictgen::InsensitiveStr::Ascii("wsered"),
        dictgen::InsensitiveStr::Ascii("ymous"),
        dictgen::InsensitiveStr::Ascii("ymously"),
    ],
    values: &[
        &["unanimous"],
        &["unanimous"],
        &["unanimously"],
        &["unanimous"],
        &["unanimous"],
        &["unanimously"],
        &["unanimous"],
        &["unanimously"],
        &["unanimous"],
        &["unanimously"],
        &["unanimous"],
        &["unanimously"],
        &["unanimous"],
        &["unanimously"],
        &["unanswered"],
        &["unanswered"],
        &["unanimous"],
        &["unanimously"],
    ],
    range: 4..=8,
};

static WORD_UNAM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNAM_CHILDREN),
    value: None,
};

pub static WORD_UNAM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("bigious"),
        dictgen::InsensitiveStr::Ascii("bigous"),
        dictgen::InsensitiveStr::Ascii("bigously"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("inous"),
    ],
    values: &[
        &["unambiguous"],
        &["unambiguous"],
        &["unambiguously"],
        &["unnamed"],
        &["unanimous"],
    ],
    range: 2..=8,
};

static WORD_UNAL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNAL_CHILDREN),
    value: None,
};

pub static WORD_UNAL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("be"),
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("llowed"),
    ],
    values: &[&["unable"], &["unable"], &["unallowed"]],
    range: 1..=6,
};

static WORD_UNAI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNAI_CHILDREN),
    value: None,
};

pub static WORD_UNAI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("valable")],
    values: &[&["unavailable"]],
    range: 7..=7,
};

static WORD_UNAH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNAH_CHILDREN),
    value: None,
};

pub static WORD_UNAH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ppy")],
    values: &[&["unhappy"]],
    range: 3..=3,
};

static WORD_UNAF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNAF_CHILDREN),
    value: None,
};

pub static WORD_UNAF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ected")],
    values: &[&["unaffected"]],
    range: 5..=5,
};

static WORD_UNAD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNAD_CHILDREN),
    value: None,
};

pub static WORD_UNAD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("vertantly"),
        dictgen::InsensitiveStr::Ascii("vertedly"),
        dictgen::InsensitiveStr::Ascii("vertent"),
        dictgen::InsensitiveStr::Ascii("vertently"),
    ],
    values: &[
        &["inadvertently"],
        &["inadvertently"],
        &["inadvertent"],
        &["inadvertently"],
    ],
    range: 7..=9,
};

static WORD_UNAC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNAC_CHILDREN),
    value: None,
};

pub static WORD_UNAC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("captable"),
        dictgen::InsensitiveStr::Ascii("ceptible"),
        dictgen::InsensitiveStr::Ascii("cesible"),
        dictgen::InsensitiveStr::Ascii("cessable"),
        dictgen::InsensitiveStr::Ascii("cpetable"),
        dictgen::InsensitiveStr::Ascii("knowleged"),
        dictgen::InsensitiveStr::Ascii("ompanied"),
    ],
    values: &[
        &["unacceptable"],
        &["unacceptable"],
        &["unaccessible", "inaccessible"],
        &["inaccessible"],
        &["unacceptable"],
        &["unacknowledged"],
        &["unaccompanied"],
    ],
    range: 7..=9,
};

static WORD_UNAB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UNAB_CHILDREN),
    value: None,
};

pub static WORD_UNAB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ailable"),
        dictgen::InsensitiveStr::Ascii("ale"),
        dictgen::InsensitiveStr::Ascii("el"),
        dictgen::InsensitiveStr::Ascii("let"),
        dictgen::InsensitiveStr::Ascii("nned"),
    ],
    values: &[
        &["unavailable"],
        &["unable"],
        &["unable"],
        &["unable"],
        &["unbanned"],
    ],
    range: 2..=7,
};

static WORD_UM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UM_CHILDREN),
    value: None,
};

pub static WORD_UM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ambiguous"),
        dictgen::InsensitiveStr::Ascii("ark"),
        dictgen::InsensitiveStr::Ascii("arked"),
        dictgen::InsensitiveStr::Ascii("believable"),
        dictgen::InsensitiveStr::Ascii("berlla"),
        dictgen::InsensitiveStr::Ascii("brealla"),
        dictgen::InsensitiveStr::Ascii("brela"),
        dictgen::InsensitiveStr::Ascii("brellla"),
        dictgen::InsensitiveStr::Ascii("comfortable"),
        dictgen::InsensitiveStr::Ascii("comfortably"),
        dictgen::InsensitiveStr::Ascii("employment"),
        dictgen::InsensitiveStr::Ascii("inportant"),
        dictgen::InsensitiveStr::Ascii("it"),
        dictgen::InsensitiveStr::Ascii("less"),
        dictgen::InsensitiveStr::Ascii("mark"),
        dictgen::InsensitiveStr::Ascii("outn"),
        dictgen::InsensitiveStr::Ascii("predictable"),
    ],
    values: &[
        &["unambiguous"],
        &["unmark"],
        &["unmarked"],
        &["unbelievable"],
        &["umbrella"],
        &["umbrella"],
        &["umbrella"],
        &["umbrella"],
        &["uncomfortable"],
        &["uncomfortably"],
        &["unemployment"],
        &["unimportant"],
        &["unit"],
        &["unless"],
        &["unmark"],
        &["umount"],
        &["unpredictable"],
    ],
    range: 2..=11,
};

static WORD_UL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UL_CHILDREN),
    value: None,
};

pub static WORD_UL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ess"),
        dictgen::InsensitiveStr::Ascii("imited"),
        dictgen::InsensitiveStr::Ascii("itmate"),
        dictgen::InsensitiveStr::Ascii("itmately"),
        dictgen::InsensitiveStr::Ascii("itmatum"),
        dictgen::InsensitiveStr::Ascii("tamite"),
        dictgen::InsensitiveStr::Ascii("ter"),
        dictgen::InsensitiveStr::Ascii("teration"),
        dictgen::InsensitiveStr::Ascii("terations"),
        dictgen::InsensitiveStr::Ascii("tered"),
        dictgen::InsensitiveStr::Ascii("tering"),
        dictgen::InsensitiveStr::Ascii("terioara"),
        dictgen::InsensitiveStr::Ascii("terioare"),
        dictgen::InsensitiveStr::Ascii("teriour"),
        dictgen::InsensitiveStr::Ascii("ters"),
        dictgen::InsensitiveStr::Ascii("tiamte"),
        dictgen::InsensitiveStr::Ascii("timae"),
        dictgen::InsensitiveStr::Ascii("timatelly"),
        dictgen::InsensitiveStr::Ascii("timative"),
        dictgen::InsensitiveStr::Ascii("timatley"),
        dictgen::InsensitiveStr::Ascii("timatly"),
        dictgen::InsensitiveStr::Ascii("timatuum"),
        dictgen::InsensitiveStr::Ascii("timely"),
        dictgen::InsensitiveStr::Ascii("trason"),
    ],
    values: &[
        &["unless"],
        &["unlimited"],
        &["ultimate"],
        &["ultimately"],
        &["ultimatum"],
        &["ultimate"],
        &["alter"],
        &["alteration"],
        &["alterations"],
        &["altered"],
        &["altering"],
        &["ulterior"],
        &["ulterior"],
        &["ulterior"],
        &["alters"],
        &["ultimate"],
        &["ultimate"],
        &["ultimately"],
        &["ultimate"],
        &["ultimately"],
        &["ultimately"],
        &["ultimatum"],
        &["ultimately"],
        &["ultrasound"],
    ],
    range: 3..=9,
};

static WORD_UK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UK_CHILDREN),
    value: None,
};

pub static WORD_UK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("arine"),
        dictgen::InsensitiveStr::Ascii("nown"),
        dictgen::InsensitiveStr::Ascii("nowns"),
        dictgen::InsensitiveStr::Ascii("owns"),
        dictgen::InsensitiveStr::Ascii("rainain"),
        dictgen::InsensitiveStr::Ascii("rainains"),
        dictgen::InsensitiveStr::Ascii("raineans"),
        dictgen::InsensitiveStr::Ascii("rainias"),
        dictgen::InsensitiveStr::Ascii("rainie"),
        dictgen::InsensitiveStr::Ascii("rainiens"),
        dictgen::InsensitiveStr::Ascii("rainin"),
        dictgen::InsensitiveStr::Ascii("rainina"),
        dictgen::InsensitiveStr::Ascii("raininans"),
        dictgen::InsensitiveStr::Ascii("raininas"),
        dictgen::InsensitiveStr::Ascii("rainisn"),
        dictgen::InsensitiveStr::Ascii("ranian"),
        dictgen::InsensitiveStr::Ascii("ranie"),
        dictgen::InsensitiveStr::Ascii("riane"),
        dictgen::InsensitiveStr::Ascii("rianian"),
        dictgen::InsensitiveStr::Ascii("rianians"),
    ],
    values: &[
        &["ukraine"],
        &["unknown"],
        &["unknowns"],
        &["unknowns", "unknown"],
        &["ukrainian"],
        &["ukrainians"],
        &["ukrainians"],
        &["ukrainians"],
        &["ukraine"],
        &["ukrainians"],
        &["ukrainian"],
        &["ukrainian"],
        &["ukrainians"],
        &["ukrainians"],
        &["ukrainians"],
        &["ukrainian"],
        &["ukraine"],
        &["ukraine"],
        &["ukrainian"],
        &["ukrainians"],
    ],
    range: 4..=9,
};

static WORD_UI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UI_CHILDREN),
    value: None,
};

pub static WORD_UI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("que"),
        dictgen::InsensitiveStr::Ascii("se"),
        dictgen::InsensitiveStr::Ascii("sng"),
        dictgen::InsensitiveStr::Ascii("te"),
        dictgen::InsensitiveStr::Ascii("tes"),
    ],
    values: &[
        &["unique"],
        &["use"],
        &["using"],
        &["suite", "unite"],
        &["suites"],
    ],
    range: 2..=3,
};

static WORD_UG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UG_CHILDREN),
    value: None,
};

pub static WORD_UG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("gly"),
        dictgen::InsensitiveStr::Ascii("glyness"),
        dictgen::InsensitiveStr::Ascii("lyness"),
        dictgen::InsensitiveStr::Ascii("prade"),
        dictgen::InsensitiveStr::Ascii("praded"),
        dictgen::InsensitiveStr::Ascii("prades"),
        dictgen::InsensitiveStr::Ascii("prading"),
    ],
    values: &[
        &["ugly"],
        &["ugliness"],
        &["ugliness"],
        &["upgrade"],
        &["upgraded"],
        &["upgrades"],
        &["upgrading"],
    ],
    range: 3..=7,
};

static WORD_UF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UF_CHILDREN),
    value: None,
};

pub static WORD_UF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("fer"),
        dictgen::InsensitiveStr::Ascii("fered"),
        dictgen::InsensitiveStr::Ascii("fering"),
        dictgen::InsensitiveStr::Ascii("fers"),
    ],
    values: &[&["buffer"], &["buffered"], &["buffering"], &["buffers"]],
    range: 3..=6,
};

static WORD_UE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UE_CHILDREN),
    value: Some(&["use", "due"]),
};

pub static WORD_UE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ful"),
        dictgen::InsensitiveStr::Ascii("gister"),
        dictgen::InsensitiveStr::Ascii("s"),
        dictgen::InsensitiveStr::Ascii("sd"),
        dictgen::InsensitiveStr::Ascii("ses"),
        dictgen::InsensitiveStr::Ascii("sful"),
        dictgen::InsensitiveStr::Ascii("sfull"),
        dictgen::InsensitiveStr::Ascii("sfulness"),
        dictgen::InsensitiveStr::Ascii("sless"),
        dictgen::InsensitiveStr::Ascii("slessness"),
        dictgen::InsensitiveStr::Ascii("st"),
        dictgen::InsensitiveStr::Ascii("sts"),
    ],
    values: &[
        &["useful"],
        &["unregister"],
        &["use", "yes"],
        &["used"],
        &["uses"],
        &["useful"],
        &["useful"],
        &["usefulness"],
        &["useless"],
        &["uselessness"],
        &["quest"],
        &["quests"],
    ],
    range: 1..=9,
};

static WORD_UD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UD_CHILDREN),
    value: None,
};

pub static WORD_UD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ate"),
        dictgen::InsensitiveStr::Ascii("ated"),
        dictgen::InsensitiveStr::Ascii("ateed"),
        dictgen::InsensitiveStr::Ascii("ater"),
        dictgen::InsensitiveStr::Ascii("ates"),
        dictgen::InsensitiveStr::Ascii("ating"),
        dictgen::InsensitiveStr::Ascii("id"),
        dictgen::InsensitiveStr::Ascii("loaded"),
        dictgen::InsensitiveStr::Ascii("nercut"),
        dictgen::InsensitiveStr::Ascii("nerdog"),
        dictgen::InsensitiveStr::Ascii("nerestimate"),
        dictgen::InsensitiveStr::Ascii("nerpowered"),
        dictgen::InsensitiveStr::Ascii("no"),
        dictgen::InsensitiveStr::Ascii("o"),
        dictgen::InsensitiveStr::Ascii("patable"),
        dictgen::InsensitiveStr::Ascii("pate"),
        dictgen::InsensitiveStr::Ascii("pated"),
        dictgen::InsensitiveStr::Ascii("pater"),
        dictgen::InsensitiveStr::Ascii("pates"),
        dictgen::InsensitiveStr::Ascii("pating"),
    ],
    values: &[
        &["update"],
        &["updated", "dated"],
        &["updated"],
        &["updater", "dater"],
        &["updates"],
        &["updating", "dating"],
        &["uuid"],
        &["unloaded"],
        &["undercut"],
        &["underdog"],
        &["underestimated"],
        &["underpowered"],
        &["undo", "uno"],
        &["ado", "judo", "sudo", "udon", "ufo", "undo"],
        &["updatable"],
        &["update"],
        &["updated"],
        &["updater"],
        &["updates"],
        &["updating"],
    ],
    range: 1..=11,
};

static WORD_UB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_UB_CHILDREN),
    value: None,
};

pub static WORD_UB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("elieveble"),
        dictgen::InsensitiveStr::Ascii("elievebly"),
        dictgen::InsensitiveStr::Ascii("ernetes"),
        dictgen::InsensitiveStr::Ascii("iqituous"),
        dictgen::InsensitiveStr::Ascii("iquitious"),
        dictgen::InsensitiveStr::Ascii("iquitos"),
        dictgen::InsensitiveStr::Ascii("iquituous"),
        dictgen::InsensitiveStr::Ascii("iquituously"),
        dictgen::InsensitiveStr::Ascii("iquotous"),
        dictgen::InsensitiveStr::Ascii("iquoutous"),
        dictgen::InsensitiveStr::Ascii("iqutious"),
        dictgen::InsensitiveStr::Ascii("itquitous"),
        dictgen::InsensitiveStr::Ascii("lisher"),
        dictgen::InsensitiveStr::Ascii("subscribed"),
        dictgen::InsensitiveStr::Ascii("substantiated"),
        dictgen::InsensitiveStr::Ascii("unut"),
        dictgen::InsensitiveStr::Ascii("unutu"),
        dictgen::InsensitiveStr::Ascii("utu"),
        dictgen::InsensitiveStr::Ascii("utunu"),
    ],
    values: &[
        &["unbelievable"],
        &["unbelievably"],
        &["kubernetes"],
        &["ubiquitous"],
        &["ubiquitous"],
        &["ubiquitous"],
        &["ubiquitous"],
        &["ubiquitously"],
        &["ubiquitous"],
        &["ubiquitous"],
        &["ubiquitous"],
        &["ubiquitous"],
        &["publisher"],
        &["unsubscribed"],
        &["unsubstantiated"],
        &["ubuntu"],
        &["ubuntu"],
        &["ubuntu"],
        &["ubuntu"],
    ],
    range: 3..=13,
};

static WORD_T_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_T_CHILDREN),
    value: None,
};

static WORD_T_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_TA_NODE),
    Some(&WORD_TB_NODE),
    Some(&WORD_TC_NODE),
    Some(&WORD_TD_NODE),
    Some(&WORD_TE_NODE),
    None,
    Some(&WORD_TG_NODE),
    Some(&WORD_TH_NODE),
    Some(&WORD_TI_NODE),
    Some(&WORD_TJ_NODE),
    Some(&WORD_TK_NODE),
    Some(&WORD_TL_NODE),
    Some(&WORD_TM_NODE),
    Some(&WORD_TN_NODE),
    Some(&WORD_TO_NODE),
    Some(&WORD_TP_NODE),
    None,
    Some(&WORD_TR_NODE),
    Some(&WORD_TS_NODE),
    Some(&WORD_TT_NODE),
    Some(&WORD_TU_NODE),
    None,
    Some(&WORD_TW_NODE),
    None,
    Some(&WORD_TY_NODE),
    None,
];

static WORD_TY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TY_CHILDREN),
    value: None,
};

pub static WORD_TY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("elnol"),
        dictgen::InsensitiveStr::Ascii("ep"),
        dictgen::InsensitiveStr::Ascii("epof"),
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("hat"),
        dictgen::InsensitiveStr::Ascii("he"),
        dictgen::InsensitiveStr::Ascii("ies"),
        dictgen::InsensitiveStr::Ascii("lenool"),
        dictgen::InsensitiveStr::Ascii("mecode"),
        dictgen::InsensitiveStr::Ascii("oe"),
        dictgen::InsensitiveStr::Ascii("ope"),
        dictgen::InsensitiveStr::Ascii("pcast"),
        dictgen::InsensitiveStr::Ascii("pcasting"),
        dictgen::InsensitiveStr::Ascii("pcasts"),
        dictgen::InsensitiveStr::Ascii("pcial"),
        dictgen::InsensitiveStr::Ascii("pcially"),
        dictgen::InsensitiveStr::Ascii("pdef"),
        dictgen::InsensitiveStr::Ascii("pechek"),
        dictgen::InsensitiveStr::Ascii("pecheking"),
        dictgen::InsensitiveStr::Ascii("pesrript"),
        dictgen::InsensitiveStr::Ascii("pess"),
        dictgen::InsensitiveStr::Ascii("picall"),
        dictgen::InsensitiveStr::Ascii("picallly"),
        dictgen::InsensitiveStr::Ascii("picaly"),
        dictgen::InsensitiveStr::Ascii("picially"),
        dictgen::InsensitiveStr::Ascii("ple"),
        dictgen::InsensitiveStr::Ascii("ples"),
        dictgen::InsensitiveStr::Ascii("poe"),
        dictgen::InsensitiveStr::Ascii("poes"),
        dictgen::InsensitiveStr::Ascii("pographc"),
        dictgen::InsensitiveStr::Ascii("popgrahic"),
        dictgen::InsensitiveStr::Ascii("popgrahical"),
        dictgen::InsensitiveStr::Ascii("ppe"),
        dictgen::InsensitiveStr::Ascii("pped"),
        dictgen::InsensitiveStr::Ascii("ppes"),
        dictgen::InsensitiveStr::Ascii("ppical"),
        dictgen::InsensitiveStr::Ascii("ppically"),
        dictgen::InsensitiveStr::Ascii("ranies"),
        dictgen::InsensitiveStr::Ascii("rannia"),
        dictgen::InsensitiveStr::Ascii("rantical"),
        dictgen::InsensitiveStr::Ascii("rany"),
        dictgen::InsensitiveStr::Ascii("rhard"),
        dictgen::InsensitiveStr::Ascii("ring"),
        dictgen::InsensitiveStr::Ascii("rranies"),
        dictgen::InsensitiveStr::Ascii("rrany"),
    ],
    values: &[
        &["type", "tie"],
        &["tylenol"],
        &["type"],
        &["typeof"],
        &["types", "ties"],
        &["that"],
        &["they", "the", "type"],
        &["tries"],
        &["tylenol"],
        &["timecode"],
        &["type", "toe", "toey"],
        &["type"],
        &["typecast"],
        &["typecasting"],
        &["typecasts"],
        &["typical"],
        &["typically"],
        &["typed", "typedef"],
        &["typecheck"],
        &["typechecking"],
        &["typescript"],
        &["types"],
        &["typically", "typical"],
        &["typically"],
        &["typically"],
        &["typically"],
        &["tuple"],
        &["tuples"],
        &["typo", "type", "types"],
        &["typos", "types"],
        &["typographic"],
        &["typographic"],
        &["typographical"],
        &["type"],
        &["typed"],
        &["types"],
        &["typical"],
        &["typically"],
        &["tyrannies"],
        &["tyrannical"],
        &["tyrannical"],
        &["tyranny"],
        &["tryhard"],
        &["trying"],
        &["tyrannies"],
        &["tyranny"],
    ],
    range: 1..=11,
};

static WORD_TW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TW_CHILDREN),
    value: None,
};

pub static WORD_TW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eek"),
        dictgen::InsensitiveStr::Ascii("eeked"),
        dictgen::InsensitiveStr::Ascii("eeking"),
        dictgen::InsensitiveStr::Ascii("eeks"),
        dictgen::InsensitiveStr::Ascii("eleve"),
        dictgen::InsensitiveStr::Ascii("elth"),
        dictgen::InsensitiveStr::Ascii("ilgiht"),
        dictgen::InsensitiveStr::Ascii("iligt"),
        dictgen::InsensitiveStr::Ascii("on"),
        dictgen::InsensitiveStr::Ascii("oo"),
        dictgen::InsensitiveStr::Ascii("osday"),
        dictgen::InsensitiveStr::Ascii("po"),
    ],
    values: &[
        &["tweak"],
        &["tweaked"],
        &["tweaking"],
        &["tweaks"],
        &["twelve"],
        &["twelfth"],
        &["twilight"],
        &["twilight"],
        &["town"],
        &["two", "too"],
        &["tuesday"],
        &["two"],
    ],
    range: 2..=6,
};

static WORD_TU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_TU_CHILDREN),
    value: None,
};

static WORD_TU_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    Some(&WORD_TUC_NODE),
    None,
    Some(&WORD_TUE_NODE),
    Some(&WORD_TUF_NODE),
    None,
    Some(&WORD_TUH_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_TUN_NODE),
    Some(&WORD_TUO_NODE),
    Some(&WORD_TUP_NODE),
    None,
    Some(&WORD_TUR_NODE),
    Some(&WORD_TUS_NODE),
    Some(&WORD_TUT_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_TUT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TUT_CHILDREN),
    value: None,
};

pub static WORD_TUT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ion"),
        dictgen::InsensitiveStr::Ascii("oriales"),
        dictgen::InsensitiveStr::Ascii("oriel"),
        dictgen::InsensitiveStr::Ascii("oriels"),
        dictgen::InsensitiveStr::Ascii("orual"),
        dictgen::InsensitiveStr::Ascii("rles"),
    ],
    values: &[
        &["tuition"],
        &["tutorials"],
        &["tutorial"],
        &["tutorials"],
        &["tutorial"],
        &["turtles"],
    ],
    range: 3..=7,
};

static WORD_TUS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TUS_CHILDREN),
    value: None,
};

pub static WORD_TUS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("con"),
        dictgen::InsensitiveStr::Ascii("day"),
        dictgen::InsensitiveStr::Ascii("eday"),
        dictgen::InsensitiveStr::Ascii("edays"),
        dictgen::InsensitiveStr::Ascii("nami"),
        dictgen::InsensitiveStr::Ascii("t"),
    ],
    values: &[
        &["tucson"],
        &["tuesday"],
        &["tuesday"],
        &["tuesdays"],
        &["tsunami"],
        &["trust"],
    ],
    range: 1..=5,
};

static WORD_TUR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TUR_CHILDREN),
    value: None,
};

pub static WORD_TUR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ain"),
        dictgen::InsensitiveStr::Ascii("ains"),
        dictgen::InsensitiveStr::Ascii("bins"),
        dictgen::InsensitiveStr::Ascii("coise"),
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("kisch"),
        dictgen::InsensitiveStr::Ascii("koise"),
        dictgen::InsensitiveStr::Ascii("ksih"),
        dictgen::InsensitiveStr::Ascii("le"),
        dictgen::InsensitiveStr::Ascii("ltes"),
        dictgen::InsensitiveStr::Ascii("ly"),
        dictgen::InsensitiveStr::Ascii("napound"),
        dictgen::InsensitiveStr::Ascii("naroud"),
        dictgen::InsensitiveStr::Ascii("nk"),
        dictgen::InsensitiveStr::Ascii("ntabe"),
        dictgen::InsensitiveStr::Ascii("ntabel"),
        dictgen::InsensitiveStr::Ascii("orial"),
        dictgen::InsensitiveStr::Ascii("orials"),
        dictgen::InsensitiveStr::Ascii("rain"),
        dictgen::InsensitiveStr::Ascii("rains"),
        dictgen::InsensitiveStr::Ascii("rest"),
        dictgen::InsensitiveStr::Ascii("retts"),
        dictgen::InsensitiveStr::Ascii("stworthy"),
        dictgen::InsensitiveStr::Ascii("tels"),
        dictgen::InsensitiveStr::Ascii("thfully"),
        dictgen::InsensitiveStr::Ascii("tleh"),
        dictgen::InsensitiveStr::Ascii("tlehs"),
        dictgen::InsensitiveStr::Ascii("torial"),
        dictgen::InsensitiveStr::Ascii("torials"),
    ],
    values: &[
        &["terrain"],
        &["terrains"],
        &["turbines"],
        &["turquoise"],
        &["true", "pure"],
        &["turkish"],
        &["turquoise"],
        &["turkish"],
        &["turtle"],
        &["turtles"],
        &["truly"],
        &["turnaround"],
        &["turnaround"],
        &["trunk", "turnkey", "turn"],
        &["turntable"],
        &["turntable"],
        &["tutorial"],
        &["tutorials"],
        &["terrain"],
        &["terrains"],
        &["turrets"],
        &["turrets"],
        &["trustworthy"],
        &["turtles"],
        &["truthfully"],
        &["turtle"],
        &["turtles"],
        &["tutorial"],
        &["tutorials"],
    ],
    range: 1..=8,
};

static WORD_TUP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TUP_CHILDREN),
    value: None,
};

pub static WORD_TUP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("el"),
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("less"),
        dictgen::InsensitiveStr::Ascii("parware"),
        dictgen::InsensitiveStr::Ascii("perwears"),
        dictgen::InsensitiveStr::Ascii("ple"),
        dictgen::InsensitiveStr::Ascii("ples"),
    ],
    values: &[
        &["tuple"],
        &["tuples"],
        &["tuples"],
        &["tupperware"],
        &["tupperware"],
        &["tuple"],
        &["tuples"],
    ],
    range: 2..=8,
};

static WORD_TUO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TUO_CHILDREN),
    value: None,
};

pub static WORD_TUO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("tiral"),
        dictgen::InsensitiveStr::Ascii("tirals"),
    ],
    values: &[&["tutorial"], &["tutorials"]],
    range: 5..=6,
};

static WORD_TUN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TUN_CHILDREN),
    value: None,
};

pub static WORD_TUN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("elled"),
        dictgen::InsensitiveStr::Ascii("elling"),
        dictgen::InsensitiveStr::Ascii("g"),
        dictgen::InsensitiveStr::Ascii("ges"),
        dictgen::InsensitiveStr::Ascii("gs"),
        dictgen::InsensitiveStr::Ascii("gues"),
        dictgen::InsensitiveStr::Ascii("ned"),
        dictgen::InsensitiveStr::Ascii("nell"),
        dictgen::InsensitiveStr::Ascii("nells"),
        dictgen::InsensitiveStr::Ascii("ning"),
        dictgen::InsensitiveStr::Ascii("nles"),
        dictgen::InsensitiveStr::Ascii("raround"),
        dictgen::InsensitiveStr::Ascii("rtable"),
    ],
    values: &[
        &["tunnelled"],
        &["tunnelling"],
        &["tongue"],
        &["tongues"],
        &["tongues"],
        &["tongues"],
        &["tuned"],
        &["tunnel"],
        &["tunnels"],
        &["tuning", "running"],
        &["tunnels"],
        &["turnaround"],
        &["turntable"],
    ],
    range: 1..=7,
};

static WORD_TUH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TUH_CHILDREN),
    value: None,
};

pub static WORD_TUH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("mbnail")],
    values: &[&["thumbnail"]],
    range: 6..=6,
};

static WORD_TUF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TUF_CHILDREN),
    value: None,
};

pub static WORD_TUF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ure")],
    values: &[&["future"]],
    range: 3..=3,
};

static WORD_TUE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TUE_CHILDREN),
    value: None,
};

pub static WORD_TUE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("sdey"),
        dictgen::InsensitiveStr::Ascii("sdsay"),
        dictgen::InsensitiveStr::Ascii("sdsy"),
    ],
    values: &[&["tuesday"], &["tuesdays"], &["tuesdays", "tuesday"]],
    range: 4..=5,
};

static WORD_TUC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TUC_CHILDREN),
    value: None,
};

pub static WORD_TUC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("an"),
        dictgen::InsensitiveStr::Ascii("ans"),
    ],
    values: &[&["toucan"], &["toucans"]],
    range: 2..=3,
};

static WORD_TT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TT_CHILDREN),
    value: None,
};

pub static WORD_TT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ests"),
        dictgen::InsensitiveStr::Ascii("hat"),
        dictgen::InsensitiveStr::Ascii("he"),
    ],
    values: &[&["tests"], &["that"], &["the"]],
    range: 2..=4,
};

static WORD_TS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TS_CHILDREN),
    value: None,
};

pub static WORD_TS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("amina"),
        dictgen::InsensitiveStr::Ascii("nuami"),
        dictgen::InsensitiveStr::Ascii("uanmi"),
        dictgen::InsensitiveStr::Ascii("unamai"),
        dictgen::InsensitiveStr::Ascii("unmai"),
    ],
    values: &[
        &["stamina"],
        &["tsunami"],
        &["tsunami"],
        &["tsunami"],
        &["tsunami"],
    ],
    range: 5..=6,
};

static WORD_TR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_TR_CHILDREN),
    value: None,
};

static WORD_TR_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_TRA_NODE),
    None,
    None,
    None,
    Some(&WORD_TRE_NODE),
    None,
    Some(&WORD_TRG_NODE),
    Some(&WORD_TRH_NODE),
    Some(&WORD_TRI_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_TRN_NODE),
    Some(&WORD_TRO_NODE),
    Some(&WORD_TRP_NODE),
    None,
    Some(&WORD_TRR_NODE),
    None,
    None,
    Some(&WORD_TRU_NODE),
    None,
    None,
    None,
    Some(&WORD_TRY_NODE),
    None,
];

static WORD_TRY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TRY_CHILDREN),
    value: None,
};

pub static WORD_TRY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ahrd"),
        dictgen::InsensitiveStr::Ascii("annical"),
        dictgen::InsensitiveStr::Ascii("avon"),
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("ig"),
        dictgen::InsensitiveStr::Ascii("inng"),
        dictgen::InsensitiveStr::Ascii("s"),
        dictgen::InsensitiveStr::Ascii("ying"),
    ],
    values: &[
        &["tryhard"],
        &["tyrannical"],
        &["trayvon"],
        &["true", "try"],
        &["tried"],
        &["tries"],
        &["trying"],
        &["trying"],
        &["tries"],
        &["trying"],
    ],
    range: 1..=7,
};

static WORD_TRU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TRU_CHILDREN),
    value: None,
};

pub static WORD_TRU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("amatic"),
        dictgen::InsensitiveStr::Ascii("amatized"),
        dictgen::InsensitiveStr::Ascii("bador"),
        dictgen::InsensitiveStr::Ascii("badors"),
        dictgen::InsensitiveStr::Ascii("badour"),
        dictgen::InsensitiveStr::Ascii("badours"),
        dictgen::InsensitiveStr::Ascii("bble"),
        dictgen::InsensitiveStr::Ascii("bbled"),
        dictgen::InsensitiveStr::Ascii("bbles"),
        dictgen::InsensitiveStr::Ascii("binal"),
        dictgen::InsensitiveStr::Ascii("bines"),
        dictgen::InsensitiveStr::Ascii("ble"),
        dictgen::InsensitiveStr::Ascii("bled"),
        dictgen::InsensitiveStr::Ascii("bles"),
        dictgen::InsensitiveStr::Ascii("bling"),
        dictgen::InsensitiveStr::Ascii("cate"),
        dictgen::InsensitiveStr::Ascii("cated"),
        dictgen::InsensitiveStr::Ascii("cates"),
        dictgen::InsensitiveStr::Ascii("cating"),
        dictgen::InsensitiveStr::Ascii("cnate"),
        dictgen::InsensitiveStr::Ascii("cnated"),
        dictgen::InsensitiveStr::Ascii("cnating"),
        dictgen::InsensitiveStr::Ascii("ct"),
        dictgen::InsensitiveStr::Ascii("dnle"),
        dictgen::InsensitiveStr::Ascii("elly"),
        dictgen::InsensitiveStr::Ascii("ely"),
        dictgen::InsensitiveStr::Ascii("ged"),
        dictgen::InsensitiveStr::Ascii("gged"),
        dictgen::InsensitiveStr::Ascii("ging"),
        dictgen::InsensitiveStr::Ascii("ied"),
        dictgen::InsensitiveStr::Ascii("imph"),
        dictgen::InsensitiveStr::Ascii("kish"),
        dictgen::InsensitiveStr::Ascii("lly"),
        dictgen::InsensitiveStr::Ascii("mendously"),
        dictgen::InsensitiveStr::Ascii("n"),
        dictgen::InsensitiveStr::Ascii("nacted"),
        dictgen::InsensitiveStr::Ascii("ncat"),
        dictgen::InsensitiveStr::Ascii("nctate"),
        dictgen::InsensitiveStr::Ascii("nctated"),
        dictgen::InsensitiveStr::Ascii("nctating"),
        dictgen::InsensitiveStr::Ascii("nctation"),
        dictgen::InsensitiveStr::Ascii("ncted"),
        dictgen::InsensitiveStr::Ascii("ndel"),
        dictgen::InsensitiveStr::Ascii("ned"),
        dictgen::InsensitiveStr::Ascii("nlde"),
        dictgen::InsensitiveStr::Ascii("ns"),
        dictgen::InsensitiveStr::Ascii("shworthy"),
        dictgen::InsensitiveStr::Ascii("stowrthy"),
        dictgen::InsensitiveStr::Ascii("stwhorty"),
        dictgen::InsensitiveStr::Ascii("stworhty"),
        dictgen::InsensitiveStr::Ascii("stworhy"),
        dictgen::InsensitiveStr::Ascii("stworthly"),
        dictgen::InsensitiveStr::Ascii("stworthyness"),
        dictgen::InsensitiveStr::Ascii("stworty"),
        dictgen::InsensitiveStr::Ascii("stwortyness"),
        dictgen::InsensitiveStr::Ascii("stwothy"),
        dictgen::InsensitiveStr::Ascii("thfullly"),
        dictgen::InsensitiveStr::Ascii("thfuly"),
        dictgen::InsensitiveStr::Ascii("w"),
    ],
    values: &[
        &["traumatic"],
        &["traumatized"],
        &["troubadour"],
        &["troubadours"],
        &["troubadour"],
        &["troubadours"],
        &["trouble"],
        &["troubled"],
        &["troubles"],
        &["tribunal"],
        &["turbines"],
        &["trouble"],
        &["troubled"],
        &["troubles"],
        &["troubling"],
        &["truncate"],
        &["truncated"],
        &["truncates"],
        &["truncating"],
        &["truncate"],
        &["truncated"],
        &["truncating"],
        &["struct"],
        &["trundle"],
        &["truly"],
        &["truly"],
        &["trudged"],
        &["trudged", "tugged"],
        &["trudging"],
        &["tried"],
        &["triumph"],
        &["turkish"],
        &["truly"],
        &["tremendously"],
        &["turn"],
        &["truncated"],
        &["truncate"],
        &["truncate"],
        &["truncated"],
        &["truncating"],
        &["truncation"],
        &["truncated"],
        &["trundle"],
        &["turned"],
        &["trundle"],
        &["turns"],
        &["trustworthy"],
        &["trustworthy"],
        &["trustworthy"],
        &["trustworthy"],
        &["trustworthy"],
        &["trustworthy"],
        &["trustworthiness"],
        &["trustworthy"],
        &["trustworthiness"],
        &["trustworthy"],
        &["truthfully"],
        &["truthfully"],
        &["true"],
    ],
    range: 1..=12,
};

static WORD_TRR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TRR_CHILDREN),
    value: None,
};

pub static WORD_TRR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("iger"),
        dictgen::InsensitiveStr::Ascii("igered"),
        dictgen::InsensitiveStr::Ascii("igering"),
        dictgen::InsensitiveStr::Ascii("igers"),
        dictgen::InsensitiveStr::Ascii("igger"),
        dictgen::InsensitiveStr::Ascii("iggered"),
        dictgen::InsensitiveStr::Ascii("iggering"),
        dictgen::InsensitiveStr::Ascii("iggers"),
    ],
    values: &[
        &["trigger"],
        &["triggered"],
        &["triggering"],
        &["triggers"],
        &["trigger"],
        &["triggered"],
        &["triggering"],
        &["triggers"],
    ],
    range: 4..=8,
};

static WORD_TRP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TRP_CHILDREN),
    value: None,
};

pub static WORD_TRP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("oical")],
    values: &[&["tropical"]],
    range: 5..=5,
};

static WORD_TRO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_TRO_CHILDREN),
    value: None,
};

static WORD_TRO_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    Some(&WORD_TROC_NODE),
    None,
    None,
    None,
    Some(&WORD_TROG_NODE),
    Some(&WORD_TROH_NODE),
    None,
    None,
    None,
    Some(&WORD_TROL_NODE),
    None,
    Some(&WORD_TRON_NODE),
    Some(&WORD_TROO_NODE),
    Some(&WORD_TROP_NODE),
    None,
    None,
    None,
    Some(&WORD_TROT_NODE),
    Some(&WORD_TROU_NODE),
    None,
    Some(&WORD_TROW_NODE),
    None,
    None,
    None,
];

static WORD_TROW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TROW_CHILDREN),
    value: None,
};

pub static WORD_TROW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("n")],
    values: &[&["thrown"]],
    range: 1..=1,
};

static WORD_TROU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TROU_CHILDREN),
    value: None,
};

pub static WORD_TROU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("bador"),
        dictgen::InsensitiveStr::Ascii("badors"),
        dictgen::InsensitiveStr::Ascii("belshoot"),
        dictgen::InsensitiveStr::Ascii("belshooting"),
        dictgen::InsensitiveStr::Ascii("belsome"),
        dictgen::InsensitiveStr::Ascii("beshoot"),
        dictgen::InsensitiveStr::Ascii("beshooted"),
        dictgen::InsensitiveStr::Ascii("beshooter"),
        dictgen::InsensitiveStr::Ascii("beshooting"),
        dictgen::InsensitiveStr::Ascii("beshoots"),
        dictgen::InsensitiveStr::Ascii("blehshoot"),
        dictgen::InsensitiveStr::Ascii("blehshooting"),
        dictgen::InsensitiveStr::Ascii("blehsoot"),
        dictgen::InsensitiveStr::Ascii("blehsooting"),
        dictgen::InsensitiveStr::Ascii("bleshooot"),
        dictgen::InsensitiveStr::Ascii("bleshotting"),
        dictgen::InsensitiveStr::Ascii("blshoot"),
        dictgen::InsensitiveStr::Ascii("blshooting"),
        dictgen::InsensitiveStr::Ascii("ghout"),
        dictgen::InsensitiveStr::Ascii("ghput"),
        dictgen::InsensitiveStr::Ascii("ght"),
        dictgen::InsensitiveStr::Ascii("p"),
        dictgen::InsensitiveStr::Ascii("ps"),
    ],
    values: &[
        &["troubadour"],
        &["troubadours"],
        &["troubleshoot"],
        &["troubleshooting"],
        &["troublesome"],
        &["troubleshoot"],
        &["troubleshooted"],
        &["troubleshooter"],
        &["troubleshooting"],
        &["troubleshoots"],
        &["troubleshoot"],
        &["troubleshooting"],
        &["troubleshoot"],
        &["troubleshooting"],
        &["troubleshoot"],
        &["troubleshooting"],
        &["troubleshoot"],
        &["troubleshooting"],
        &["throughout", "throughput"],
        &["throughput", "throughout"],
        &["through"],
        &["troupe"],
        &["troupes", "troops"],
    ],
    range: 1..=12,
};

static WORD_TROT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TROT_CHILDREN),
    value: None,
};

pub static WORD_TROT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("illa"),
        dictgen::InsensitiveStr::Ascii("ski"),
        dictgen::InsensitiveStr::Ascii("skism"),
        dictgen::InsensitiveStr::Ascii("skist"),
        dictgen::InsensitiveStr::Ascii("skists"),
        dictgen::InsensitiveStr::Ascii("skyite"),
        dictgen::InsensitiveStr::Ascii("skyites"),
        dictgen::InsensitiveStr::Ascii("tle"),
        dictgen::InsensitiveStr::Ascii("tled"),
        dictgen::InsensitiveStr::Ascii("tling"),
        dictgen::InsensitiveStr::Ascii("zki"),
        dictgen::InsensitiveStr::Ascii("zkism"),
        dictgen::InsensitiveStr::Ascii("zkist"),
        dictgen::InsensitiveStr::Ascii("zkists"),
        dictgen::InsensitiveStr::Ascii("zky"),
        dictgen::InsensitiveStr::Ascii("zkyism"),
        dictgen::InsensitiveStr::Ascii("zkyist"),
        dictgen::InsensitiveStr::Ascii("zkyists"),
        dictgen::InsensitiveStr::Ascii("zkyite"),
        dictgen::InsensitiveStr::Ascii("zkyites"),
    ],
    values: &[
        &["tortilla"],
        &["trotsky"],
        &["trotskyism"],
        &["trotskyist"],
        &["trotskyists"],
        &["trotskyist"],
        &["trotskyists"],
        &["throttle"],
        &["throttled", "trotted"],
        &["throttling", "trotting"],
        &["trotsky"],
        &["trotskyism"],
        &["trotskyist"],
        &["trotskyists"],
        &["trotsky"],
        &["trotskyism"],
        &["trotskyist"],
        &["trotskyists"],
        &["trotskyist"],
        &["trotskyists"],
    ],
    range: 3..=7,
};

static WORD_TROP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TROP_CHILDREN),
    value: None,
};

pub static WORD_TROP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cial"),
        dictgen::InsensitiveStr::Ascii("edo"),
    ],
    values: &[&["tropical"], &["torpedo"]],
    range: 3..=4,
};

static WORD_TROO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TROO_CHILDREN),
    value: None,
};

pub static WORD_TROO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("so"),
        dictgen::InsensitiveStr::Ascii("sos"),
        dictgen::InsensitiveStr::Ascii("sso"),
        dictgen::InsensitiveStr::Ascii("ssos"),
    ],
    values: &[
        &["trousseau"],
        &["trousseaus", "trousseaux"],
        &["trousseau"],
        &["trousseaus", "trousseaux"],
    ],
    range: 2..=4,
};

static WORD_TRON_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TRON_CHILDREN),
    value: None,
};

pub static WORD_TRON_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ado")],
    values: &[&["tornado"]],
    range: 3..=3,
};

static WORD_TROL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TROL_CHILDREN),
    value: None,
};

pub static WORD_TROL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eld"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("lade"),
        dictgen::InsensitiveStr::Ascii("lys"),
    ],
    values: &[&["trolled"], &["trolling"], &["trolled"], &["trolleys"]],
    range: 3..=4,
};

static WORD_TROH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TROH_CHILDREN),
    value: None,
};

pub static WORD_TROH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("pies")],
    values: &[&["trophies"]],
    range: 4..=4,
};

static WORD_TROG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TROG_CHILDREN),
    value: None,
};

pub static WORD_TROG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ladite"),
        dictgen::InsensitiveStr::Ascii("ladites"),
        dictgen::InsensitiveStr::Ascii("laditic"),
        dictgen::InsensitiveStr::Ascii("laditical"),
        dictgen::InsensitiveStr::Ascii("laditism"),
        dictgen::InsensitiveStr::Ascii("lidite"),
        dictgen::InsensitiveStr::Ascii("lidites"),
        dictgen::InsensitiveStr::Ascii("liditic"),
        dictgen::InsensitiveStr::Ascii("liditical"),
        dictgen::InsensitiveStr::Ascii("liditism"),
        dictgen::InsensitiveStr::Ascii("lodite"),
        dictgen::InsensitiveStr::Ascii("lodites"),
        dictgen::InsensitiveStr::Ascii("loditic"),
        dictgen::InsensitiveStr::Ascii("loditical"),
        dictgen::InsensitiveStr::Ascii("loditism"),
    ],
    values: &[
        &["troglodyte"],
        &["troglodytes"],
        &["troglodytic"],
        &["troglodytical"],
        &["troglodytism"],
        &["troglodyte"],
        &["troglodytes"],
        &["troglodytic"],
        &["troglodytical"],
        &["troglodytism"],
        &["troglodyte"],
        &["troglodytes"],
        &["troglodytic"],
        &["troglodytical"],
        &["troglodytism"],
    ],
    range: 6..=9,
};

static WORD_TROC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TROC_CHILDREN),
    value: None,
};

pub static WORD_TROC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("hlight")],
    values: &[&["torchlight"]],
    range: 6..=6,
};

static WORD_TRN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TRN_CHILDREN),
    value: None,
};

pub static WORD_TRN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("asfers"),
        dictgen::InsensitiveStr::Ascii("asmit"),
        dictgen::InsensitiveStr::Ascii("asmited"),
        dictgen::InsensitiveStr::Ascii("asmits"),
        dictgen::InsensitiveStr::Ascii("sfer"),
        dictgen::InsensitiveStr::Ascii("sfered"),
        dictgen::InsensitiveStr::Ascii("sfers"),
    ],
    values: &[
        &["transfers"],
        &["transmit"],
        &["transmitted"],
        &["transmits"],
        &["transfer"],
        &["transferred"],
        &["transfers"],
    ],
    range: 4..=7,
};

static WORD_TRI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_TRI_CHILDREN),
    value: None,
};

static WORD_TRI_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_TRIA_NODE),
    Some(&WORD_TRIB_NODE),
    Some(&WORD_TRIC_NODE),
    Some(&WORD_TRID_NODE),
    None,
    None,
    Some(&WORD_TRIG_NODE),
    None,
    None,
    None,
    Some(&WORD_TRIK_NODE),
    Some(&WORD_TRIL_NODE),
    Some(&WORD_TRIM_NODE),
    Some(&WORD_TRIN_NODE),
    Some(&WORD_TRIO_NODE),
    Some(&WORD_TRIP_NODE),
    None,
    None,
    Some(&WORD_TRIS_NODE),
    None,
    Some(&WORD_TRIU_NODE),
    Some(&WORD_TRIV_NODE),
    None,
    None,
    None,
    None,
];

static WORD_TRIV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TRIV_CHILDREN),
    value: None,
};

pub static WORD_TRIV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("al"),
        dictgen::InsensitiveStr::Ascii("ally"),
        dictgen::InsensitiveStr::Ascii("ias"),
        dictgen::InsensitiveStr::Ascii("ival"),
    ],
    values: &[&["trivial"], &["trivially"], &["trivia"], &["trivial"]],
    range: 2..=4,
};

static WORD_TRIU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TRIU_CHILDREN),
    value: None,
};

pub static WORD_TRIU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("angulate"),
        dictgen::InsensitiveStr::Ascii("mpth"),
    ],
    values: &[&["triangulate"], &["triumph"]],
    range: 4..=8,
};

static WORD_TRIS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TRIS_CHILDREN),
    value: None,
};

pub static WORD_TRIS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cadecafobia"),
        dictgen::InsensitiveStr::Ascii("cadecaphobia"),
        dictgen::InsensitiveStr::Ascii("caidecafobia"),
        dictgen::InsensitiveStr::Ascii("caidecaphobia"),
        dictgen::InsensitiveStr::Ascii("caidekafobia"),
        dictgen::InsensitiveStr::Ascii("caidekaphobia"),
        dictgen::InsensitiveStr::Ascii("kadecafobia"),
        dictgen::InsensitiveStr::Ascii("kadecaphobia"),
        dictgen::InsensitiveStr::Ascii("kadekafobia"),
        dictgen::InsensitiveStr::Ascii("kadekaphobia"),
    ],
    values: &[
        &["triskaidekaphobia"],
        &["triskaidekaphobia"],
        &["triskaidekaphobia"],
        &["triskaidekaphobia"],
        &["triskaidekaphobia"],
        &["triskaidekaphobia"],
        &["triskaidekaphobia"],
        &["triskaidekaphobia"],
        &["triskaidekaphobia"],
        &["triskaidekaphobia"],
    ],
    range: 11..=13,
};

static WORD_TRIP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TRIP_CHILDREN),
    value: None,
};

pub static WORD_TRIP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("el"),
        dictgen::InsensitiveStr::Ascii("eld"),
        dictgen::InsensitiveStr::Ascii("els"),
        dictgen::InsensitiveStr::Ascii("ple"),
        dictgen::InsensitiveStr::Ascii("tick"),
        dictgen::InsensitiveStr::Ascii("tickes"),
        dictgen::InsensitiveStr::Ascii("ticks"),
        dictgen::InsensitiveStr::Ascii("tish"),
        dictgen::InsensitiveStr::Ascii("tishes"),
        dictgen::InsensitiveStr::Ascii("tishs"),
    ],
    values: &[
        &["triple"],
        &["tripled"],
        &["triples"],
        &["triple"],
        &["triptych"],
        &["triptychs"],
        &["triptychs"],
        &["triptych"],
        &["triptychs"],
        &["triptychs"],
    ],
    range: 2..=6,
};

static WORD_TRIO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TRIO_CHILDREN),
    value: None,
};

pub static WORD_TRIO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("lgy"),
        dictgen::InsensitiveStr::Ascii("logy"),
    ],
    values: &[&["trilogy"], &["trilogy"]],
    range: 3..=4,
};

static WORD_TRIN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TRIN_CHILDREN),
    value: None,
};

pub static WORD_TRIN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("agle"),
        dictgen::InsensitiveStr::Ascii("agles"),
        dictgen::InsensitiveStr::Ascii("ekts"),
        dictgen::InsensitiveStr::Ascii("g"),
        dictgen::InsensitiveStr::Ascii("gale"),
        dictgen::InsensitiveStr::Ascii("gket"),
        dictgen::InsensitiveStr::Ascii("gkets"),
        dictgen::InsensitiveStr::Ascii("gs"),
        dictgen::InsensitiveStr::Ascii("itiy"),
        dictgen::InsensitiveStr::Ascii("iy"),
        dictgen::InsensitiveStr::Ascii("kes"),
        dictgen::InsensitiveStr::Ascii("kst"),
        dictgen::InsensitiveStr::Ascii("tiy"),
    ],
    values: &[
        &["triangle"],
        &["triangles"],
        &["trinkets"],
        &["trying", "string", "ring"],
        &["triangle"],
        &["trinket"],
        &["trinkets"],
        &["strings", "rings"],
        &["trinity"],
        &["trinity"],
        &["trinkets"],
        &["trinkets"],
        &["trinity"],
    ],
    range: 1..=5,
};

static WORD_TRIM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TRIM_CHILDREN),
    value: None,
};

pub static WORD_TRIM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("mng"),
        dictgen::InsensitiveStr::Ascii("uph"),
    ],
    values: &[
        &["trimmed"],
        &["trimming", "timing"],
        &["trimming"],
        &["triumph"],
    ],
    range: 2..=3,
};

static WORD_TRIL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TRIL_CHILDREN),
    value: None,
};

pub static WORD_TRIL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("inar"),
        dictgen::InsensitiveStr::Ascii("ineal"),
        dictgen::InsensitiveStr::Ascii("ogoy"),
    ],
    values: &[&["trilinear", "trillionaire"], &["trilinear"], &["trilogy"]],
    range: 4..=5,
};

static WORD_TRIK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TRIK_CHILDREN),
    value: Some(&["trick", "trike"]),
};

pub static WORD_TRIK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("ery"),
        dictgen::InsensitiveStr::Ascii("s"),
        dictgen::InsensitiveStr::Ascii("y"),
    ],
    values: &[
        &["tricked"],
        &["trickery"],
        &["tricks", "trikes"],
        &["tricky"],
    ],
    range: 1..=3,
};

static WORD_TRIG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TRIG_CHILDREN),
    value: None,
};

pub static WORD_TRIG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("er"),
        dictgen::InsensitiveStr::Ascii("ered"),
        dictgen::InsensitiveStr::Ascii("erred"),
        dictgen::InsensitiveStr::Ascii("erring"),
        dictgen::InsensitiveStr::Ascii("ers"),
        dictgen::InsensitiveStr::Ascii("ged"),
        dictgen::InsensitiveStr::Ascii("gerd"),
        dictgen::InsensitiveStr::Ascii("gereing"),
        dictgen::InsensitiveStr::Ascii("geres"),
        dictgen::InsensitiveStr::Ascii("gern"),
        dictgen::InsensitiveStr::Ascii("gerred"),
        dictgen::InsensitiveStr::Ascii("gerring"),
        dictgen::InsensitiveStr::Ascii("gerrs"),
        dictgen::InsensitiveStr::Ascii("gger"),
        dictgen::InsensitiveStr::Ascii("nametric"),
        dictgen::InsensitiveStr::Ascii("nametry"),
        dictgen::InsensitiveStr::Ascii("nometric"),
        dictgen::InsensitiveStr::Ascii("nometry"),
        dictgen::InsensitiveStr::Ascii("uered"),
    ],
    values: &[
        &["trigger", "tiger"],
        &["triggered"],
        &["triggered"],
        &["triggering"],
        &["triggers"],
        &["triggered"],
        &["triggered"],
        &["triggering"],
        &["triggers"],
        &["triggering"],
        &["triggered"],
        &["triggering"],
        &["triggers"],
        &["trigger"],
        &["trigonometric"],
        &["trigonometry"],
        &["trigonometric"],
        &["trigonometry"],
        &["triggered"],
    ],
    range: 2..=8,
};

static WORD_TRID_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TRID_CHILDREN),
    value: None,
};

pub static WORD_TRID_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("net")],
    values: &[&["trident"]],
    range: 3..=3,
};

static WORD_TRIC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TRIC_CHILDREN),
    value: None,
};

pub static WORD_TRIC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("key"),
        dictgen::InsensitiveStr::Ascii("kyer"),
    ],
    values: &[&["trickery"], &["trickery"]],
    range: 3..=4,
};

static WORD_TRIB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TRIB_CHILDREN),
    value: None,
};

pub static WORD_TRIB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("uanl"),
        dictgen::InsensitiveStr::Ascii("unaal"),
    ],
    values: &[&["tribunal"], &["tribunal"]],
    range: 4..=5,
};

static WORD_TRIA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TRIA_CHILDREN),
    value: None,
};

pub static WORD_TRIA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ler"),
        dictgen::InsensitiveStr::Ascii("lers"),
        dictgen::InsensitiveStr::Ascii("n"),
        dictgen::InsensitiveStr::Ascii("ncle"),
        dictgen::InsensitiveStr::Ascii("ncles"),
        dictgen::InsensitiveStr::Ascii("ned"),
        dictgen::InsensitiveStr::Ascii("ners"),
        dictgen::InsensitiveStr::Ascii("nge"),
        dictgen::InsensitiveStr::Ascii("ngel"),
        dictgen::InsensitiveStr::Ascii("ngels"),
        dictgen::InsensitiveStr::Ascii("ngls"),
        dictgen::InsensitiveStr::Ascii("nglular"),
        dictgen::InsensitiveStr::Ascii("nglutaion"),
        dictgen::InsensitiveStr::Ascii("ngulataion"),
        dictgen::InsensitiveStr::Ascii("ngultaion"),
        dictgen::InsensitiveStr::Ascii("ning"),
        dictgen::InsensitiveStr::Ascii("nlge"),
        dictgen::InsensitiveStr::Ascii("nlges"),
        dictgen::InsensitiveStr::Ascii("ns"),
        dictgen::InsensitiveStr::Ascii("nwreck"),
        dictgen::InsensitiveStr::Ascii("thalon"),
        dictgen::InsensitiveStr::Ascii("thalons"),
        dictgen::InsensitiveStr::Ascii("tor"),
        dictgen::InsensitiveStr::Ascii("tors"),
    ],
    values: &[
        &["trailer"],
        &["trailers"],
        &["train", "trial"],
        &["triangle"],
        &["triangles"],
        &["trained"],
        &["trainers"],
        &["triangle"],
        &["triangle"],
        &["triangles"],
        &["triangles"],
        &["triangular"],
        &["triangulation"],
        &["triangulation"],
        &["triangulation"],
        &["training"],
        &["triangle"],
        &["triangles"],
        &["trains"],
        &["trainwreck"],
        &["triathlon"],
        &["triathlons"],
        &["traitor"],
        &["traitors"],
    ],
    range: 1..=10,
};

static WORD_TRH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TRH_CHILDREN),
    value: None,
};

pub static WORD_TRH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("illing"),
        dictgen::InsensitiveStr::Ascii("ough"),
        dictgen::InsensitiveStr::Ascii("usters"),
    ],
    values: &[&["the"], &["thrilling"], &["through"], &["thrusters"]],
    range: 1..=6,
};

static WORD_TRG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TRG_CHILDREN),
    value: None,
};

pub static WORD_TRG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("istration")],
    values: &[&["registration"]],
    range: 9..=9,
};

static WORD_TRE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TRE_CHILDREN),
    value: Some(&["tree"]),
};

pub static WORD_TRE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("adet"),
        dictgen::InsensitiveStr::Ascii("aeted"),
        dictgen::InsensitiveStr::Ascii("ak"),
        dictgen::InsensitiveStr::Ascii("asue"),
        dictgen::InsensitiveStr::Ascii("asuers"),
        dictgen::InsensitiveStr::Ascii("asurery"),
        dictgen::InsensitiveStr::Ascii("asurey"),
        dictgen::InsensitiveStr::Ascii("asurs"),
        dictgen::InsensitiveStr::Ascii("ate"),
        dictgen::InsensitiveStr::Ascii("atement"),
        dictgen::InsensitiveStr::Ascii("atements"),
        dictgen::InsensitiveStr::Ascii("ates"),
        dictgen::InsensitiveStr::Ascii("atis"),
        dictgen::InsensitiveStr::Ascii("atmens"),
        dictgen::InsensitiveStr::Ascii("atmet"),
        dictgen::InsensitiveStr::Ascii("atsie"),
        dictgen::InsensitiveStr::Ascii("ausre"),
        dictgen::InsensitiveStr::Ascii("ausres"),
        dictgen::InsensitiveStr::Ascii("dning"),
        dictgen::InsensitiveStr::Ascii("melo"),
        dictgen::InsensitiveStr::Ascii("melos"),
        dictgen::InsensitiveStr::Ascii("memdous"),
        dictgen::InsensitiveStr::Ascii("memdously"),
        dictgen::InsensitiveStr::Ascii("mendeous"),
        dictgen::InsensitiveStr::Ascii("mendious"),
        dictgen::InsensitiveStr::Ascii("mendos"),
        dictgen::InsensitiveStr::Ascii("mendoulsy"),
        dictgen::InsensitiveStr::Ascii("menduous"),
        dictgen::InsensitiveStr::Ascii("mondous"),
        dictgen::InsensitiveStr::Ascii("mondously"),
        dictgen::InsensitiveStr::Ascii("mpoline"),
        dictgen::InsensitiveStr::Ascii("ndig"),
        dictgen::InsensitiveStr::Ascii("shhold"),
        dictgen::InsensitiveStr::Ascii("shold"),
        dictgen::InsensitiveStr::Ascii("spasing"),
        dictgen::InsensitiveStr::Ascii("spessing"),
        dictgen::InsensitiveStr::Ascii("ssle"),
        dictgen::InsensitiveStr::Ascii("sspasing"),
        dictgen::InsensitiveStr::Ascii("suary"),
        dictgen::InsensitiveStr::Ascii("sure"),
        dictgen::InsensitiveStr::Ascii("sured"),
        dictgen::InsensitiveStr::Ascii("surer"),
        dictgen::InsensitiveStr::Ascii("sures"),
        dictgen::InsensitiveStr::Ascii("suring"),
        dictgen::InsensitiveStr::Ascii("ting"),
        dictgen::InsensitiveStr::Ascii("w"),
        dictgen::InsensitiveStr::Ascii("wthful"),
        dictgen::InsensitiveStr::Ascii("wthfully"),
    ],
    values: &[
        &["treated", "threaded", "treaded"],
        &["treated"],
        &["treat", "tweak"],
        &["treasure"],
        &["treasures"],
        &["treasury"],
        &["treasury"],
        &["treasures"],
        &["treat"],
        &["treatment"],
        &["treatments"],
        &["treats"],
        &["treaties"],
        &["treatments"],
        &["treatments"],
        &["treaties"],
        &["treasure"],
        &["treasures"],
        &["trending"],
        &["tremolo"],
        &["tremolos"],
        &["tremendous"],
        &["tremendously"],
        &["tremendous"],
        &["tremendous"],
        &["tremendous"],
        &["tremendously"],
        &["tremendous"],
        &["tremendous"],
        &["tremendously"],
        &["trampoline"],
        &["trending"],
        &["threshold"],
        &["threshold"],
        &["trespassing"],
        &["trespassing"],
        &["trestle"],
        &["trespassing"],
        &["treasury"],
        &["treasure"],
        &["treasured"],
        &["treasurer"],
        &["treasures"],
        &["treasuring"],
        &["treating"],
        &["threw", "true"],
        &["truthful"],
        &["truthfully"],
    ],
    range: 1..=9,
};

static WORD_TRA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_TRA_CHILDREN),
    value: None,
};

static WORD_TRA_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    Some(&WORD_TRAB_NODE),
    Some(&WORD_TRAC_NODE),
    Some(&WORD_TRAD_NODE),
    None,
    Some(&WORD_TRAF_NODE),
    Some(&WORD_TRAG_NODE),
    None,
    Some(&WORD_TRAI_NODE),
    None,
    Some(&WORD_TRAK_NODE),
    Some(&WORD_TRAL_NODE),
    Some(&WORD_TRAM_NODE),
    Some(&WORD_TRAN_NODE),
    None,
    Some(&WORD_TRAP_NODE),
    None,
    None,
    Some(&WORD_TRAS_NODE),
    Some(&WORD_TRAT_NODE),
    Some(&WORD_TRAU_NODE),
    Some(&WORD_TRAV_NODE),
    None,
    None,
    None,
    None,
];

static WORD_TRAV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TRAV_CHILDREN),
    value: None,
};

pub static WORD_TRAV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("eersal"),
        dictgen::InsensitiveStr::Ascii("eerse"),
        dictgen::InsensitiveStr::Ascii("eersed"),
        dictgen::InsensitiveStr::Ascii("eerses"),
        dictgen::InsensitiveStr::Ascii("eersing"),
        dictgen::InsensitiveStr::Ascii("eld"),
        dictgen::InsensitiveStr::Ascii("eleres"),
        dictgen::InsensitiveStr::Ascii("eles"),
        dictgen::InsensitiveStr::Ascii("ellerhd"),
        dictgen::InsensitiveStr::Ascii("ellodge"),
        dictgen::InsensitiveStr::Ascii("elodge"),
        dictgen::InsensitiveStr::Ascii("eral"),
        dictgen::InsensitiveStr::Ascii("ercal"),
        dictgen::InsensitiveStr::Ascii("erce"),
        dictgen::InsensitiveStr::Ascii("erced"),
        dictgen::InsensitiveStr::Ascii("erces"),
        dictgen::InsensitiveStr::Ascii("ercing"),
        dictgen::InsensitiveStr::Ascii("ere"),
        dictgen::InsensitiveStr::Ascii("ered"),
        dictgen::InsensitiveStr::Ascii("eres"),
        dictgen::InsensitiveStr::Ascii("eresal"),
        dictgen::InsensitiveStr::Ascii("erese"),
        dictgen::InsensitiveStr::Ascii("eresed"),
        dictgen::InsensitiveStr::Ascii("ereses"),
        dictgen::InsensitiveStr::Ascii("eresing"),
        dictgen::InsensitiveStr::Ascii("ering"),
        dictgen::InsensitiveStr::Ascii("erlers"),
        dictgen::InsensitiveStr::Ascii("erls"),
        dictgen::InsensitiveStr::Ascii("ersare"),
        dictgen::InsensitiveStr::Ascii("ersie"),
        dictgen::InsensitiveStr::Ascii("ersier"),
        dictgen::InsensitiveStr::Ascii("erssal"),
        dictgen::InsensitiveStr::Ascii("esal"),
        dictgen::InsensitiveStr::Ascii("ese"),
        dictgen::InsensitiveStr::Ascii("esed"),
        dictgen::InsensitiveStr::Ascii("eses"),
        dictgen::InsensitiveStr::Ascii("esing"),
        dictgen::InsensitiveStr::Ascii("estry"),
        dictgen::InsensitiveStr::Ascii("esy"),
        dictgen::InsensitiveStr::Ascii("les"),
    ],
    values: &[
        &["traversed"],
        &["traversal"],
        &["traverse"],
        &["traversed"],
        &["traverses"],
        &["traversing"],
        &["traveled"],
        &["travelers"],
        &["travels"],
        &["travelled"],
        &["travelled"],
        &["traveled"],
        &["traversal"],
        &["traversal"],
        &["traverse"],
        &["traversed"],
        &["traverses"],
        &["traversing"],
        &["traverse"],
        &["traversed"],
        &["traverse"],
        &["traversal"],
        &["traverse", "traverses"],
        &["traversed"],
        &["traverses"],
        &["traversing"],
        &["traversing"],
        &["traverse"],
        &["travels", "traversals"],
        &["traverse"],
        &["traverse"],
        &["traverse"],
        &["traversal"],
        &["traversal"],
        &["traverse"],
        &["traversed"],
        &["traverses"],
        &["traversing"],
        &["travesty"],
        &["travesty"],
        &["travels"],
    ],
    range: 2..=7,
};

static WORD_TRAU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TRAU_CHILDREN),
    value: None,
};

pub static WORD_TRAU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("matisch"),
        dictgen::InsensitiveStr::Ascii("metized"),
        dictgen::InsensitiveStr::Ascii("mitized"),
    ],
    values: &[&["traumatic"], &["traumatized"], &["traumatized"]],
    range: 7..=7,
};

static WORD_TRAT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TRAT_CHILDREN),
    value: None,
};

pub static WORD_TRAT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ior"),
        dictgen::InsensitiveStr::Ascii("iors"),
    ],
    values: &[&["traitor"], &["traitors"]],
    range: 3..=4,
};

static WORD_TRAS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_TRAS_CHILDREN),
    value: None,
};

static WORD_TRAS_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_TRASA_NODE),
    None,
    Some(&WORD_TRASC_NODE),
    None,
    None,
    Some(&WORD_TRASF_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_TRASL_NODE),
    Some(&WORD_TRASM_NODE),
    Some(&WORD_TRASN_NODE),
    None,
    Some(&WORD_TRASP_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_TRASP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TRASP_CHILDREN),
    value: None,
};

pub static WORD_TRASP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("arency"),
        dictgen::InsensitiveStr::Ascii("arent"),
        dictgen::InsensitiveStr::Ascii("arently"),
        dictgen::InsensitiveStr::Ascii("ort"),
        dictgen::InsensitiveStr::Ascii("ortable"),
        dictgen::InsensitiveStr::Ascii("orted"),
        dictgen::InsensitiveStr::Ascii("orter"),
        dictgen::InsensitiveStr::Ascii("orts"),
        dictgen::InsensitiveStr::Ascii("ose"),
        dictgen::InsensitiveStr::Ascii("osed"),
        dictgen::InsensitiveStr::Ascii("osing"),
        dictgen::InsensitiveStr::Ascii("osition"),
        dictgen::InsensitiveStr::Ascii("ositions"),
    ],
    values: &[
        &["transparency"],
        &["transparent"],
        &["transparently"],
        &["transport"],
        &["transportable"],
        &["transported"],
        &["transporter"],
        &["transports"],
        &["transpose"],
        &["transposed"],
        &["transposing"],
        &["transposition"],
        &["transpositions"],
    ],
    range: 3..=8,
};

static WORD_TRASN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TRASN_CHILDREN),
    value: None,
};

pub static WORD_TRASN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("action"),
        dictgen::InsensitiveStr::Ascii("coding"),
        dictgen::InsensitiveStr::Ascii("cript"),
        dictgen::InsensitiveStr::Ascii("cripts"),
        dictgen::InsensitiveStr::Ascii("fer"),
        dictgen::InsensitiveStr::Ascii("fered"),
        dictgen::InsensitiveStr::Ascii("ferred"),
        dictgen::InsensitiveStr::Ascii("ferring"),
        dictgen::InsensitiveStr::Ascii("fers"),
        dictgen::InsensitiveStr::Ascii("form"),
        dictgen::InsensitiveStr::Ascii("formation"),
        dictgen::InsensitiveStr::Ascii("formed"),
        dictgen::InsensitiveStr::Ascii("former"),
        dictgen::InsensitiveStr::Ascii("formers"),
        dictgen::InsensitiveStr::Ascii("forming"),
        dictgen::InsensitiveStr::Ascii("forms"),
        dictgen::InsensitiveStr::Ascii("gender"),
        dictgen::InsensitiveStr::Ascii("gendered"),
        dictgen::InsensitiveStr::Ascii("late"),
        dictgen::InsensitiveStr::Ascii("lated"),
        dictgen::InsensitiveStr::Ascii("lation"),
        dictgen::InsensitiveStr::Ascii("lations"),
        dictgen::InsensitiveStr::Ascii("lator"),
        dictgen::InsensitiveStr::Ascii("mission"),
        dictgen::InsensitiveStr::Ascii("mitted"),
        dictgen::InsensitiveStr::Ascii("mitter"),
        dictgen::InsensitiveStr::Ascii("parencies"),
        dictgen::InsensitiveStr::Ascii("parency"),
        dictgen::InsensitiveStr::Ascii("parent"),
        dictgen::InsensitiveStr::Ascii("phobic"),
        dictgen::InsensitiveStr::Ascii("plant"),
        dictgen::InsensitiveStr::Ascii("port"),
        dictgen::InsensitiveStr::Ascii("portation"),
        dictgen::InsensitiveStr::Ascii("ported"),
        dictgen::InsensitiveStr::Ascii("porter"),
        dictgen::InsensitiveStr::Ascii("porting"),
        dictgen::InsensitiveStr::Ascii("ports"),
        dictgen::InsensitiveStr::Ascii("smit"),
    ],
    values: &[
        &["transaction"],
        &["transcoding"],
        &["transcript"],
        &["transcripts"],
        &["transfer"],
        &["transferred"],
        &["transferred"],
        &["transferring"],
        &["transfers"],
        &["transform"],
        &["transformation"],
        &["transformed"],
        &["transformer"],
        &["transformers"],
        &["transforming"],
        &["transforms"],
        &["transgender"],
        &["transgendered"],
        &["translate"],
        &["translated"],
        &["translation"],
        &["translations"],
        &["translator"],
        &["transmissions"],
        &["transmitted"],
        &["transmitter"],
        &["transparencies"],
        &["transparency"],
        &["transparent"],
        &["transphobic"],
        &["transplant"],
        &["transport"],
        &["transportation"],
        &["transported"],
        &["transporter"],
        &["transporting"],
        &["transports"],
        &["transmit"],
    ],
    range: 3..=9,
};

static WORD_TRASM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TRASM_CHILDREN),
    value: None,
};

pub static WORD_TRASM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ission"),
        dictgen::InsensitiveStr::Ascii("it"),
    ],
    values: &[&["transmission"], &["transmit"]],
    range: 2..=6,
};

static WORD_TRASL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TRASL_CHILDREN),
    value: None,
};

pub static WORD_TRASL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("alate"),
        dictgen::InsensitiveStr::Ascii("alated"),
        dictgen::InsensitiveStr::Ascii("alating"),
        dictgen::InsensitiveStr::Ascii("alation"),
        dictgen::InsensitiveStr::Ascii("alations"),
        dictgen::InsensitiveStr::Ascii("ate"),
        dictgen::InsensitiveStr::Ascii("ated"),
        dictgen::InsensitiveStr::Ascii("ates"),
        dictgen::InsensitiveStr::Ascii("ating"),
        dictgen::InsensitiveStr::Ascii("ation"),
        dictgen::InsensitiveStr::Ascii("ations"),
        dictgen::InsensitiveStr::Ascii("ucency"),
    ],
    values: &[
        &["translate"],
        &["translated"],
        &["translating"],
        &["translation"],
        &["translations"],
        &["translate"],
        &["translated"],
        &["translates"],
        &["translating"],
        &["translation"],
        &["translations"],
        &["translucency"],
    ],
    range: 3..=8,
};

static WORD_TRASF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TRASF_CHILDREN),
    value: None,
};

pub static WORD_TRASF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("er"),
        dictgen::InsensitiveStr::Ascii("erred"),
        dictgen::InsensitiveStr::Ascii("ers"),
        dictgen::InsensitiveStr::Ascii("orm"),
        dictgen::InsensitiveStr::Ascii("ormable"),
        dictgen::InsensitiveStr::Ascii("ormation"),
        dictgen::InsensitiveStr::Ascii("ormations"),
        dictgen::InsensitiveStr::Ascii("ormative"),
        dictgen::InsensitiveStr::Ascii("ormed"),
        dictgen::InsensitiveStr::Ascii("ormer"),
        dictgen::InsensitiveStr::Ascii("ormers"),
        dictgen::InsensitiveStr::Ascii("orming"),
        dictgen::InsensitiveStr::Ascii("orms"),
    ],
    values: &[
        &["transfer"],
        &["transferred"],
        &["transfers"],
        &["transform"],
        &["transformable"],
        &["transformation"],
        &["transformations"],
        &["transformative"],
        &["transformed"],
        &["transformer"],
        &["transformers"],
        &["transforming"],
        &["transforms"],
    ],
    range: 2..=9,
};

static WORD_TRASC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TRASC_CHILDREN),
    value: None,
};

pub static WORD_TRASC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ation"),
        dictgen::InsensitiveStr::Ascii("ription"),
    ],
    values: &[&["transaction"], &["transcription"]],
    range: 5..=7,
};

static WORD_TRASA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TRASA_CHILDREN),
    value: None,
};

pub static WORD_TRASA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ction")],
    values: &[&["transaction"]],
    range: 5..=5,
};

static WORD_TRAP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TRAP_CHILDREN),
    value: None,
};

pub static WORD_TRAP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eziod"),
        dictgen::InsensitiveStr::Ascii("eziodal"),
    ],
    values: &[&["trapezoid"], &["trapezoidal"]],
    range: 5..=7,
};

static WORD_TRAN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_TRAN_CHILDREN),
    value: None,
};

static WORD_TRAN_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_TRANA_NODE),
    None,
    Some(&WORD_TRANC_NODE),
    Some(&WORD_TRAND_NODE),
    None,
    Some(&WORD_TRANF_NODE),
    None,
    None,
    Some(&WORD_TRANI_NODE),
    None,
    None,
    Some(&WORD_TRANL_NODE),
    Some(&WORD_TRANM_NODE),
    Some(&WORD_TRANN_NODE),
    None,
    Some(&WORD_TRANP_NODE),
    None,
    None,
    Some(&WORD_TRANS_NODE),
    None,
    None,
    Some(&WORD_TRANV_NODE),
    None,
    None,
    None,
    Some(&WORD_TRANZ_NODE),
];

static WORD_TRANZ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TRANZ_CHILDREN),
    value: None,
};

pub static WORD_TRANZ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("former"),
        dictgen::InsensitiveStr::Ascii("istor"),
        dictgen::InsensitiveStr::Ascii("itions"),
        dictgen::InsensitiveStr::Ascii("porter"),
    ],
    values: &[
        &["transformer"],
        &["transistor"],
        &["transitions"],
        &["transporter"],
    ],
    range: 5..=6,
};

static WORD_TRANV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TRANV_CHILDREN),
    value: None,
};

pub static WORD_TRANV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ersal"),
        dictgen::InsensitiveStr::Ascii("erse"),
        dictgen::InsensitiveStr::Ascii("ersing"),
    ],
    values: &[
        &["transversal", "traversal"],
        &["transverse", "traverse"],
        &["traversing"],
    ],
    range: 4..=6,
};

static WORD_TRANS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_TRANS_CHILDREN),
    value: None,
};

static WORD_TRANS_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_TRANSA_NODE),
    None,
    Some(&WORD_TRANSC_NODE),
    None,
    Some(&WORD_TRANSE_NODE),
    Some(&WORD_TRANSF_NODE),
    Some(&WORD_TRANSG_NODE),
    Some(&WORD_TRANSH_NODE),
    Some(&WORD_TRANSI_NODE),
    None,
    Some(&WORD_TRANSK_NODE),
    Some(&WORD_TRANSL_NODE),
    Some(&WORD_TRANSM_NODE),
    None,
    Some(&WORD_TRANSO_NODE),
    Some(&WORD_TRANSP_NODE),
    None,
    None,
    Some(&WORD_TRANSS_NODE),
    Some(&WORD_TRANST_NODE),
    Some(&WORD_TRANSU_NODE),
    Some(&WORD_TRANSV_NODE),
    None,
    None,
    Some(&WORD_TRANSY_NODE),
    None,
];

static WORD_TRANSY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TRANSY_CHILDREN),
    value: None,
};

pub static WORD_TRANSY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("lmania"),
        dictgen::InsensitiveStr::Ascii("lvanai"),
        dictgen::InsensitiveStr::Ascii("lvannia"),
        dictgen::InsensitiveStr::Ascii("lvnia"),
    ],
    values: &[
        &["transylvania"],
        &["transylvania"],
        &["transylvania"],
        &["transylvania"],
    ],
    range: 5..=7,
};

static WORD_TRANSV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TRANSV_CHILDREN),
    value: None,
};

pub static WORD_TRANSV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("orm"),
        dictgen::InsensitiveStr::Ascii("ormation"),
        dictgen::InsensitiveStr::Ascii("ormed"),
        dictgen::InsensitiveStr::Ascii("orming"),
        dictgen::InsensitiveStr::Ascii("orms"),
    ],
    values: &[
        &["transform"],
        &["transformation"],
        &["transformed"],
        &["transforming"],
        &["transforms"],
    ],
    range: 3..=8,
};

static WORD_TRANSU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TRANSU_CHILDREN),
    value: None,
};

pub static WORD_TRANSU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("lcent")],
    values: &[&["translucent"]],
    range: 5..=5,
};

static WORD_TRANST_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TRANST_CHILDREN),
    value: None,
};

pub static WORD_TRANST_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ator"),
        dictgen::InsensitiveStr::Ascii("ion"),
        dictgen::InsensitiveStr::Ascii("ioned"),
        dictgen::InsensitiveStr::Ascii("ioning"),
        dictgen::InsensitiveStr::Ascii("ions"),
        dictgen::InsensitiveStr::Ascii("ition"),
        dictgen::InsensitiveStr::Ascii("itioned"),
        dictgen::InsensitiveStr::Ascii("itioning"),
        dictgen::InsensitiveStr::Ascii("itions"),
        dictgen::InsensitiveStr::Ascii("orm"),
        dictgen::InsensitiveStr::Ascii("ormed"),
    ],
    values: &[
        &["translator"],
        &["transition"],
        &["transitioned"],
        &["transitioning"],
        &["transitions"],
        &["transition"],
        &["transitioned"],
        &["transitioning"],
        &["transitions"],
        &["transform"],
        &["transformed"],
    ],
    range: 3..=8,
};

static WORD_TRANSS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TRANSS_CHILDREN),
    value: None,
};

pub static WORD_TRANSS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("end"),
        dictgen::InsensitiveStr::Ascii("euxal"),
        dictgen::InsensitiveStr::Ascii("exal"),
        dictgen::InsensitiveStr::Ascii("exaul"),
        dictgen::InsensitiveStr::Ascii("exuel"),
        dictgen::InsensitiveStr::Ascii("exuella"),
        dictgen::InsensitiveStr::Ascii("mision"),
    ],
    values: &[
        &["transcend"],
        &["transsexual"],
        &["transsexual"],
        &["transsexual"],
        &["transsexual"],
        &["transsexual"],
        &["transmissions"],
    ],
    range: 3..=7,
};

static WORD_TRANSP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_TRANSP_CHILDREN),
    value: None,
};

static WORD_TRANSP_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_TRANSPA_NODE),
    None,
    None,
    None,
    Some(&WORD_TRANSPE_NODE),
    None,
    None,
    Some(&WORD_TRANSPH_NODE),
    None,
    None,
    None,
    Some(&WORD_TRANSPL_NODE),
    None,
    None,
    Some(&WORD_TRANSPO_NODE),
    None,
    None,
    Some(&WORD_TRANSPR_NODE),
    Some(&WORD_TRANSPS_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_TRANSPS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TRANSPS_CHILDREN),
    value: None,
};

pub static WORD_TRANSPS_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[dictgen::InsensitiveStr::Ascii("ition")],
        values: &[&["transposition"]],
        range: 5..=5,
    };

static WORD_TRANSPR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TRANSPR_CHILDREN),
    value: None,
};

pub static WORD_TRANSPR_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("encies"),
            dictgen::InsensitiveStr::Ascii("ency"),
            dictgen::InsensitiveStr::Ascii("ent"),
            dictgen::InsensitiveStr::Ascii("ently"),
            dictgen::InsensitiveStr::Ascii("ot"),
            dictgen::InsensitiveStr::Ascii("oted"),
            dictgen::InsensitiveStr::Ascii("oting"),
            dictgen::InsensitiveStr::Ascii("ots"),
            dictgen::InsensitiveStr::Ascii("t"),
            dictgen::InsensitiveStr::Ascii("ted"),
            dictgen::InsensitiveStr::Ascii("ting"),
            dictgen::InsensitiveStr::Ascii("ts"),
        ],
        values: &[
            &["transparencies"],
            &["transparency"],
            &["transparent"],
            &["transparently"],
            &["transport"],
            &["transported"],
            &["transporting"],
            &["transports"],
            &["transport"],
            &["transported"],
            &["transporting"],
            &["transports"],
        ],
        range: 1..=6,
    };

static WORD_TRANSPO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TRANSPO_CHILDREN),
    value: None,
};

pub static WORD_TRANSPO_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("der"),
            dictgen::InsensitiveStr::Ascii("ration"),
            dictgen::InsensitiveStr::Ascii("rder"),
            dictgen::InsensitiveStr::Ascii("ring"),
            dictgen::InsensitiveStr::Ascii("rtaion"),
            dictgen::InsensitiveStr::Ascii("rtar"),
            dictgen::InsensitiveStr::Ascii("rtarme"),
            dictgen::InsensitiveStr::Ascii("rtarse"),
            dictgen::InsensitiveStr::Ascii("rtarte"),
            dictgen::InsensitiveStr::Ascii("rtatin"),
            dictgen::InsensitiveStr::Ascii("rteur"),
            dictgen::InsensitiveStr::Ascii("rteurs"),
            dictgen::InsensitiveStr::Ascii("rtion"),
            dictgen::InsensitiveStr::Ascii("rtng"),
            dictgen::InsensitiveStr::Ascii("rtor"),
            dictgen::InsensitiveStr::Ascii("rtr"),
            dictgen::InsensitiveStr::Ascii("t"),
            dictgen::InsensitiveStr::Ascii("tting"),
        ],
        values: &[
            &["transported"],
            &["transportation"],
            &["transporter"],
            &["transporting"],
            &["transportation"],
            &["transporter"],
            &["transporter"],
            &["transporter"],
            &["transporter"],
            &["transportation"],
            &["transporter"],
            &["transporter"],
            &["transporting"],
            &["transporting"],
            &["transporter"],
            &["transporter"],
            &["transport"],
            &["transporting"],
        ],
        range: 1..=6,
    };

static WORD_TRANSPL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TRANSPL_CHILDREN),
    value: None,
};

pub static WORD_TRANSPL_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("ain"),
            dictgen::InsensitiveStr::Ascii("anet"),
            dictgen::InsensitiveStr::Ascii("antees"),
            dictgen::InsensitiveStr::Ascii("antes"),
            dictgen::InsensitiveStr::Ascii("at"),
            dictgen::InsensitiveStr::Ascii("ate"),
            dictgen::InsensitiveStr::Ascii("ats"),
        ],
        values: &[
            &["transplant"],
            &["transplant"],
            &["transplants"],
            &["transplants"],
            &["transplant"],
            &["transplant"],
            &["transplants"],
        ],
        range: 2..=6,
    };

static WORD_TRANSPH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TRANSPH_CHILDREN),
    value: None,
};

pub static WORD_TRANSPH_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("oic"),
            dictgen::InsensitiveStr::Ascii("onic"),
            dictgen::InsensitiveStr::Ascii("opic"),
        ],
        values: &[&["transphobic"], &["transphobic"], &["transphobic"]],
        range: 3..=4,
    };

static WORD_TRANSPE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TRANSPE_CHILDREN),
    value: None,
};

pub static WORD_TRANSPE_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("ncies"),
            dictgen::InsensitiveStr::Ascii("ncy"),
            dictgen::InsensitiveStr::Ascii("orted"),
            dictgen::InsensitiveStr::Ascii("rancies"),
            dictgen::InsensitiveStr::Ascii("rancy"),
            dictgen::InsensitiveStr::Ascii("rant"),
            dictgen::InsensitiveStr::Ascii("rantly"),
            dictgen::InsensitiveStr::Ascii("rencies"),
            dictgen::InsensitiveStr::Ascii("rency"),
            dictgen::InsensitiveStr::Ascii("rent"),
            dictgen::InsensitiveStr::Ascii("rently"),
        ],
        values: &[
            &["transparencies"],
            &["transparency"],
            &["transported"],
            &["transparencies"],
            &["transparency"],
            &["transparent"],
            &["transparently"],
            &["transparencies"],
            &["transparency"],
            &["transparent"],
            &["transparently"],
        ],
        range: 3..=7,
    };

static WORD_TRANSPA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TRANSPA_CHILDREN),
    value: None,
};

pub static WORD_TRANSPA_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("ble"),
            dictgen::InsensitiveStr::Ascii("cencies"),
            dictgen::InsensitiveStr::Ascii("cency"),
            dictgen::InsensitiveStr::Ascii("ernt"),
            dictgen::InsensitiveStr::Ascii("erntly"),
            dictgen::InsensitiveStr::Ascii("lnt"),
            dictgen::InsensitiveStr::Ascii("ncies"),
            dictgen::InsensitiveStr::Ascii("ncy"),
            dictgen::InsensitiveStr::Ascii("nt"),
            dictgen::InsensitiveStr::Ascii("raent"),
            dictgen::InsensitiveStr::Ascii("raently"),
            dictgen::InsensitiveStr::Ascii("ranceies"),
            dictgen::InsensitiveStr::Ascii("rancey"),
            dictgen::InsensitiveStr::Ascii("rancies"),
            dictgen::InsensitiveStr::Ascii("rancy"),
            dictgen::InsensitiveStr::Ascii("ranet"),
            dictgen::InsensitiveStr::Ascii("ranetly"),
            dictgen::InsensitiveStr::Ascii("ranies"),
            dictgen::InsensitiveStr::Ascii("rant"),
            dictgen::InsensitiveStr::Ascii("rantie"),
            dictgen::InsensitiveStr::Ascii("rantly"),
            dictgen::InsensitiveStr::Ascii("rany"),
            dictgen::InsensitiveStr::Ascii("rarent"),
            dictgen::InsensitiveStr::Ascii("rarently"),
            dictgen::InsensitiveStr::Ascii("rcencies"),
            dictgen::InsensitiveStr::Ascii("rcency"),
            dictgen::InsensitiveStr::Ascii("rcenies"),
            dictgen::InsensitiveStr::Ascii("rceny"),
            dictgen::InsensitiveStr::Ascii("recy"),
            dictgen::InsensitiveStr::Ascii("rentcy"),
            dictgen::InsensitiveStr::Ascii("renty"),
            dictgen::InsensitiveStr::Ascii("reny"),
            dictgen::InsensitiveStr::Ascii("rities"),
            dictgen::InsensitiveStr::Ascii("rity"),
            dictgen::InsensitiveStr::Ascii("rnecies"),
            dictgen::InsensitiveStr::Ascii("rnecy"),
            dictgen::InsensitiveStr::Ascii("rnt"),
            dictgen::InsensitiveStr::Ascii("rntly"),
            dictgen::InsensitiveStr::Ascii("rren"),
            dictgen::InsensitiveStr::Ascii("rrenly"),
            dictgen::InsensitiveStr::Ascii("rrent"),
            dictgen::InsensitiveStr::Ascii("rrently"),
            dictgen::InsensitiveStr::Ascii("rt"),
            dictgen::InsensitiveStr::Ascii("rts"),
            dictgen::InsensitiveStr::Ascii("trent"),
            dictgen::InsensitiveStr::Ascii("trently"),
        ],
        values: &[
            &["transposable"],
            &["transparencies"],
            &["transparency"],
            &["transparent"],
            &["transparently"],
            &["transplants"],
            &["transparencies"],
            &["transparency"],
            &["transplant"],
            &["transparent"],
            &["transparently"],
            &["transparencies"],
            &["transparency"],
            &["transparencies"],
            &["transparency"],
            &["transparent"],
            &["transparently"],
            &["transparencies"],
            &["transparent"],
            &["transparent"],
            &["transparently"],
            &["transparency"],
            &["transparent"],
            &["transparently"],
            &["transparencies"],
            &["transparency"],
            &["transparencies"],
            &["transparency"],
            &["transparency"],
            &["transparency"],
            &["transparency"],
            &["transparency"],
            &["transparencies"],
            &["transparency"],
            &["transparencies"],
            &["transparency"],
            &["transparent"],
            &["transparently"],
            &["transparent"],
            &["transparently"],
            &["transparent"],
            &["transparently"],
            &["transport"],
            &["transports"],
            &["transparent"],
            &["transparently"],
        ],
        range: 2..=8,
    };

static WORD_TRANSO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TRANSO_CHILDREN),
    value: None,
};

pub static WORD_TRANSO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cde"),
        dictgen::InsensitiveStr::Ascii("cded"),
        dictgen::InsensitiveStr::Ascii("cder"),
        dictgen::InsensitiveStr::Ascii("cders"),
        dictgen::InsensitiveStr::Ascii("cdes"),
        dictgen::InsensitiveStr::Ascii("cding"),
        dictgen::InsensitiveStr::Ascii("cdings"),
        dictgen::InsensitiveStr::Ascii("frm"),
        dictgen::InsensitiveStr::Ascii("frmation"),
        dictgen::InsensitiveStr::Ascii("frmations"),
        dictgen::InsensitiveStr::Ascii("frmed"),
        dictgen::InsensitiveStr::Ascii("frmer"),
        dictgen::InsensitiveStr::Ascii("frmers"),
        dictgen::InsensitiveStr::Ascii("frming"),
        dictgen::InsensitiveStr::Ascii("frms"),
        dictgen::InsensitiveStr::Ascii("hobic"),
        dictgen::InsensitiveStr::Ascii("late"),
        dictgen::InsensitiveStr::Ascii("lated"),
        dictgen::InsensitiveStr::Ascii("lates"),
        dictgen::InsensitiveStr::Ascii("lating"),
        dictgen::InsensitiveStr::Ascii("lation"),
        dictgen::InsensitiveStr::Ascii("lations"),
        dictgen::InsensitiveStr::Ascii("rm"),
        dictgen::InsensitiveStr::Ascii("rmed"),
        dictgen::InsensitiveStr::Ascii("rming"),
        dictgen::InsensitiveStr::Ascii("rms"),
    ],
    values: &[
        &["transcode"],
        &["transcoded"],
        &["transcoder"],
        &["transcoders"],
        &["transcodes"],
        &["transcoding"],
        &["transcodings"],
        &["transform"],
        &["transformation"],
        &["transformations"],
        &["transformed"],
        &["transformer"],
        &["transformers"],
        &["transforming"],
        &["transforms"],
        &["transphobic"],
        &["translate"],
        &["translated"],
        &["translates"],
        &["translating"],
        &["translation"],
        &["translations"],
        &["transform"],
        &["transformed"],
        &["transforming"],
        &["transforms"],
    ],
    range: 2..=9,
};

static WORD_TRANSM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TRANSM_CHILDREN),
    value: None,
};

pub static WORD_TRANSM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("atter"),
        dictgen::InsensitiveStr::Ascii("ision"),
        dictgen::InsensitiveStr::Ascii("isions"),
        dictgen::InsensitiveStr::Ascii("isison"),
        dictgen::InsensitiveStr::Ascii("isisons"),
        dictgen::InsensitiveStr::Ascii("isive"),
        dictgen::InsensitiveStr::Ascii("issable"),
        dictgen::InsensitiveStr::Ascii("issin"),
        dictgen::InsensitiveStr::Ascii("issione"),
        dictgen::InsensitiveStr::Ascii("isson"),
        dictgen::InsensitiveStr::Ascii("issons"),
        dictgen::InsensitiveStr::Ascii("isssion"),
        dictgen::InsensitiveStr::Ascii("ist"),
        dictgen::InsensitiveStr::Ascii("ited"),
        dictgen::InsensitiveStr::Ascii("iter"),
        dictgen::InsensitiveStr::Ascii("iters"),
        dictgen::InsensitiveStr::Ascii("iting"),
        dictgen::InsensitiveStr::Ascii("ition"),
        dictgen::InsensitiveStr::Ascii("itirte"),
        dictgen::InsensitiveStr::Ascii("itor"),
        dictgen::InsensitiveStr::Ascii("itsion"),
        dictgen::InsensitiveStr::Ascii("ittd"),
        dictgen::InsensitiveStr::Ascii("ittion"),
        dictgen::InsensitiveStr::Ascii("ittor"),
        dictgen::InsensitiveStr::Ascii("itts"),
        dictgen::InsensitiveStr::Ascii("ittted"),
        dictgen::InsensitiveStr::Ascii("mit"),
        dictgen::InsensitiveStr::Ascii("orfers"),
        dictgen::InsensitiveStr::Ascii("orged"),
        dictgen::InsensitiveStr::Ascii("orgs"),
        dictgen::InsensitiveStr::Ascii("utter"),
    ],
    values: &[
        &["transmitter"],
        &["transmission"],
        &["transmission"],
        &["transmission"],
        &["transmissions"],
        &["transmissive"],
        &["transmissible"],
        &["transmissions"],
        &["transmission"],
        &["transmission"],
        &["transmissions"],
        &["transmissions"],
        &["transmit"],
        &["transmitted"],
        &["transmitter"],
        &["transmitters"],
        &["transmitting"],
        &["transmission"],
        &["transmitter"],
        &["transistor"],
        &["transmission"],
        &["transmitted"],
        &["transmission"],
        &["transmitter"],
        &["transmits"],
        &["transmitted"],
        &["transmit"],
        &["transformer"],
        &["transformed"],
        &["transforms"],
        &["transmitter"],
    ],
    range: 3..=7,
};

static WORD_TRANSL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TRANSL_CHILDREN),
    value: None,
};

pub static WORD_TRANSL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("astion"),
        dictgen::InsensitiveStr::Ascii("ateing"),
        dictgen::InsensitiveStr::Ascii("ater"),
        dictgen::InsensitiveStr::Ascii("aters"),
        dictgen::InsensitiveStr::Ascii("atied"),
        dictgen::InsensitiveStr::Ascii("atin"),
        dictgen::InsensitiveStr::Ascii("atio"),
        dictgen::InsensitiveStr::Ascii("ationg"),
        dictgen::InsensitiveStr::Ascii("atoin"),
        dictgen::InsensitiveStr::Ascii("atoins"),
        dictgen::InsensitiveStr::Ascii("atron"),
        dictgen::InsensitiveStr::Ascii("pant"),
        dictgen::InsensitiveStr::Ascii("teration"),
        dictgen::InsensitiveStr::Ascii("ucient"),
        dictgen::InsensitiveStr::Ascii("uent"),
        dictgen::InsensitiveStr::Ascii("usent"),
        dictgen::InsensitiveStr::Ascii("yvania"),
        dictgen::InsensitiveStr::Ascii("yvanian"),
    ],
    values: &[
        &["translations"],
        &["translating"],
        &["translator"],
        &["translators"],
        &["translated"],
        &["translations"],
        &["translator"],
        &["translating"],
        &["translation"],
        &["translations"],
        &["translation"],
        &["transplants"],
        &["transliteration"],
        &["translucent"],
        &["translucent"],
        &["translucent"],
        &["transylvania"],
        &["transylvania"],
    ],
    range: 4..=8,
};

static WORD_TRANSK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TRANSK_CHILDREN),
    value: None,
};

pub static WORD_TRANSK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ript"),
        dictgen::InsensitiveStr::Ascii("ription"),
    ],
    values: &[&["transcript"], &["transcription"]],
    range: 4..=7,
};

static WORD_TRANSI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TRANSI_CHILDREN),
    value: None,
};

pub static WORD_TRANSI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cion"),
        dictgen::InsensitiveStr::Ascii("cional"),
        dictgen::InsensitiveStr::Ascii("et"),
        dictgen::InsensitiveStr::Ascii("ets"),
        dictgen::InsensitiveStr::Ascii("lvania"),
        dictgen::InsensitiveStr::Ascii("mssion"),
        dictgen::InsensitiveStr::Ascii("sion"),
        dictgen::InsensitiveStr::Ascii("sioned"),
        dictgen::InsensitiveStr::Ascii("sioning"),
        dictgen::InsensitiveStr::Ascii("sions"),
        dictgen::InsensitiveStr::Ascii("sition"),
        dictgen::InsensitiveStr::Ascii("sitioned"),
        dictgen::InsensitiveStr::Ascii("sitioning"),
        dictgen::InsensitiveStr::Ascii("sitions"),
        dictgen::InsensitiveStr::Ascii("sitor"),
        dictgen::InsensitiveStr::Ascii("ster"),
        dictgen::InsensitiveStr::Ascii("stion"),
        dictgen::InsensitiveStr::Ascii("stioned"),
        dictgen::InsensitiveStr::Ascii("stioning"),
        dictgen::InsensitiveStr::Ascii("stions"),
        dictgen::InsensitiveStr::Ascii("stior"),
        dictgen::InsensitiveStr::Ascii("ten"),
        dictgen::InsensitiveStr::Ascii("tin"),
        dictgen::InsensitiveStr::Ascii("tionable"),
        dictgen::InsensitiveStr::Ascii("tionals"),
        dictgen::InsensitiveStr::Ascii("tiond"),
        dictgen::InsensitiveStr::Ascii("tiong"),
        dictgen::InsensitiveStr::Ascii("tionnal"),
        dictgen::InsensitiveStr::Ascii("tionned"),
        dictgen::InsensitiveStr::Ascii("tionning"),
        dictgen::InsensitiveStr::Ascii("tionns"),
        dictgen::InsensitiveStr::Ascii("to"),
        dictgen::InsensitiveStr::Ascii("ton"),
        dictgen::InsensitiveStr::Ascii("toning"),
        dictgen::InsensitiveStr::Ascii("tons"),
        dictgen::InsensitiveStr::Ascii("tor"),
        dictgen::InsensitiveStr::Ascii("tors"),
    ],
    values: &[
        &["transition"],
        &["transitional"],
        &["transient"],
        &["transients"],
        &["transylvania"],
        &["transmissions"],
        &["transition"],
        &["transitioned"],
        &["transitioning"],
        &["transitions"],
        &["transition"],
        &["transitioned"],
        &["transitioning"],
        &["transitions"],
        &["transistor"],
        &["transistor"],
        &["transition"],
        &["transitioned"],
        &["transitioning"],
        &["transitions"],
        &["transistor"],
        &["transient"],
        &["transitions"],
        &["transitional"],
        &["transitions"],
        &["transitioned"],
        &["transitioning"],
        &["transitional"],
        &["transitioned"],
        &["transitioning"],
        &["transitions"],
        &["transition"],
        &["transition"],
        &["transitioning"],
        &["transitions"],
        &["transistor"],
        &["transistor", "transistors"],
    ],
    range: 2..=9,
};

static WORD_TRANSH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TRANSH_CHILDREN),
    value: None,
};

pub static WORD_TRANSH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("pobic")],
    values: &[&["transphobic"]],
    range: 5..=5,
};

static WORD_TRANSG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TRANSG_CHILDREN),
    value: None,
};

pub static WORD_TRANSG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eder"),
        dictgen::InsensitiveStr::Ascii("emder"),
        dictgen::InsensitiveStr::Ascii("ended"),
        dictgen::InsensitiveStr::Ascii("enderd"),
        dictgen::InsensitiveStr::Ascii("endred"),
        dictgen::InsensitiveStr::Ascii("ener"),
        dictgen::InsensitiveStr::Ascii("enered"),
        dictgen::InsensitiveStr::Ascii("enger"),
        dictgen::InsensitiveStr::Ascii("engered"),
        dictgen::InsensitiveStr::Ascii("enres"),
    ],
    values: &[
        &["transgender"],
        &["transgender"],
        &["transgender"],
        &["transgendered"],
        &["transgendered"],
        &["transgender"],
        &["transgendered"],
        &["transgender"],
        &["transgendered"],
        &["transgender"],
    ],
    range: 4..=7,
};

static WORD_TRANSF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TRANSF_CHILDREN),
    value: None,
};

pub static WORD_TRANSF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("armers"),
        dictgen::InsensitiveStr::Ascii("arring"),
        dictgen::InsensitiveStr::Ascii("ender"),
        dictgen::InsensitiveStr::Ascii("erd"),
        dictgen::InsensitiveStr::Ascii("ere"),
        dictgen::InsensitiveStr::Ascii("ered"),
        dictgen::InsensitiveStr::Ascii("erer"),
        dictgen::InsensitiveStr::Ascii("erers"),
        dictgen::InsensitiveStr::Ascii("eres"),
        dictgen::InsensitiveStr::Ascii("ering"),
        dictgen::InsensitiveStr::Ascii("errd"),
        dictgen::InsensitiveStr::Ascii("errred"),
        dictgen::InsensitiveStr::Ascii("errring"),
        dictgen::InsensitiveStr::Ascii("errs"),
        dictgen::InsensitiveStr::Ascii("ersom"),
        dictgen::InsensitiveStr::Ascii("ert"),
        dictgen::InsensitiveStr::Ascii("erts"),
        dictgen::InsensitiveStr::Ascii("om"),
        dictgen::InsensitiveStr::Ascii("omation"),
        dictgen::InsensitiveStr::Ascii("omational"),
        dictgen::InsensitiveStr::Ascii("omations"),
        dictgen::InsensitiveStr::Ascii("omed"),
        dictgen::InsensitiveStr::Ascii("omer"),
        dictgen::InsensitiveStr::Ascii("omers"),
        dictgen::InsensitiveStr::Ascii("omm"),
        dictgen::InsensitiveStr::Ascii("oprmation"),
        dictgen::InsensitiveStr::Ascii("oration"),
        dictgen::InsensitiveStr::Ascii("orations"),
        dictgen::InsensitiveStr::Ascii("ored"),
        dictgen::InsensitiveStr::Ascii("ormacion"),
        dictgen::InsensitiveStr::Ascii("ormare"),
        dictgen::InsensitiveStr::Ascii("ormarea"),
        dictgen::InsensitiveStr::Ascii("ormarem"),
        dictgen::InsensitiveStr::Ascii("ormarse"),
        dictgen::InsensitiveStr::Ascii("ormas"),
        dictgen::InsensitiveStr::Ascii("ormase"),
        dictgen::InsensitiveStr::Ascii("ormated"),
        dictgen::InsensitiveStr::Ascii("ormates"),
        dictgen::InsensitiveStr::Ascii("ormaton"),
        dictgen::InsensitiveStr::Ascii("ormatted"),
        dictgen::InsensitiveStr::Ascii("orme"),
        dictgen::InsensitiveStr::Ascii("ormees"),
        dictgen::InsensitiveStr::Ascii("ormered"),
        dictgen::InsensitiveStr::Ascii("ormes"),
        dictgen::InsensitiveStr::Ascii("ormis"),
        dictgen::InsensitiveStr::Ascii("ormus"),
        dictgen::InsensitiveStr::Ascii("orners"),
        dictgen::InsensitiveStr::Ascii("ors"),
        dictgen::InsensitiveStr::Ascii("orums"),
        dictgen::InsensitiveStr::Ascii("os"),
        dictgen::InsensitiveStr::Ascii("rom"),
        dictgen::InsensitiveStr::Ascii("romate"),
        dictgen::InsensitiveStr::Ascii("romation"),
        dictgen::InsensitiveStr::Ascii("romations"),
        dictgen::InsensitiveStr::Ascii("romed"),
        dictgen::InsensitiveStr::Ascii("romer"),
        dictgen::InsensitiveStr::Ascii("romers"),
        dictgen::InsensitiveStr::Ascii("roming"),
        dictgen::InsensitiveStr::Ascii("roms"),
    ],
    values: &[
        &["transformers"],
        &["transferring"],
        &["transgender"],
        &["transferred"],
        &["transferred"],
        &["transferred"],
        &["transferred"],
        &["transfers"],
        &["transfers"],
        &["transferring"],
        &["transferred"],
        &["transferred"],
        &["transferring"],
        &["transfers"],
        &["transforms"],
        &["transfer", "transferred"],
        &["transfers"],
        &["transform"],
        &["transformation"],
        &["transformational"],
        &["transformations"],
        &["transformed"],
        &["transformer"],
        &["transforms"],
        &["transform"],
        &["transformation"],
        &["transformation"],
        &["transformations"],
        &["transformed"],
        &["transformation"],
        &["transformers"],
        &["transformer"],
        &["transformer"],
        &["transformers"],
        &["transforms"],
        &["transforms"],
        &["transformed"],
        &["transforms"],
        &["transformation"],
        &["transformed"],
        &["transfer", "transformed", "transformer", "transform"],
        &["transforms"],
        &["transformed"],
        &["transformers"],
        &["transforms"],
        &["transforms"],
        &["transformers"],
        &["transforms"],
        &["transforms"],
        &["transforms"],
        &["transform"],
        &["transform", "transformed"],
        &["transformation"],
        &["transformations"],
        &["transformed"],
        &["transformers", "transformer"],
        &["transformers"],
        &["transforming"],
        &["transforms"],
    ],
    range: 2..=9,
};

static WORD_TRANSE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TRANSE_CHILDREN),
    value: None,
};

pub static WORD_TRANSE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("at"),
        dictgen::InsensitiveStr::Ascii("int"),
        dictgen::InsensitiveStr::Ascii("nding"),
        dictgen::InsensitiveStr::Ascii("r"),
        dictgen::InsensitiveStr::Ascii("sxuals"),
    ],
    values: &[
        &["translates"],
        &["transient"],
        &["transcending"],
        &["transfer"],
        &["transsexuals"],
    ],
    range: 1..=6,
};

static WORD_TRANSC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TRANSC_CHILDREN),
    value: None,
};

pub static WORD_TRANSC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ation"),
        dictgen::InsensitiveStr::Ascii("ations"),
        dictgen::InsensitiveStr::Ascii("dig"),
        dictgen::InsensitiveStr::Ascii("endance"),
        dictgen::InsensitiveStr::Ascii("endant"),
        dictgen::InsensitiveStr::Ascii("endentational"),
        dictgen::InsensitiveStr::Ascii("evier"),
        dictgen::InsensitiveStr::Ascii("iever"),
        dictgen::InsensitiveStr::Ascii("ievers"),
        dictgen::InsensitiveStr::Ascii("iprt"),
        dictgen::InsensitiveStr::Ascii("irpt"),
        dictgen::InsensitiveStr::Ascii("iver"),
        dictgen::InsensitiveStr::Ascii("luent"),
        dictgen::InsensitiveStr::Ascii("ocde"),
        dictgen::InsensitiveStr::Ascii("ocded"),
        dictgen::InsensitiveStr::Ascii("ocder"),
        dictgen::InsensitiveStr::Ascii("ocders"),
        dictgen::InsensitiveStr::Ascii("ocdes"),
        dictgen::InsensitiveStr::Ascii("ocding"),
        dictgen::InsensitiveStr::Ascii("ocdings"),
        dictgen::InsensitiveStr::Ascii("onde"),
        dictgen::InsensitiveStr::Ascii("onded"),
        dictgen::InsensitiveStr::Ascii("onder"),
        dictgen::InsensitiveStr::Ascii("onders"),
        dictgen::InsensitiveStr::Ascii("ondes"),
        dictgen::InsensitiveStr::Ascii("onding"),
        dictgen::InsensitiveStr::Ascii("ondings"),
        dictgen::InsensitiveStr::Ascii("orde"),
        dictgen::InsensitiveStr::Ascii("orded"),
        dictgen::InsensitiveStr::Ascii("order"),
        dictgen::InsensitiveStr::Ascii("orders"),
        dictgen::InsensitiveStr::Ascii("ordes"),
        dictgen::InsensitiveStr::Ascii("ording"),
        dictgen::InsensitiveStr::Ascii("ordings"),
        dictgen::InsensitiveStr::Ascii("oser"),
        dictgen::InsensitiveStr::Ascii("osers"),
        dictgen::InsensitiveStr::Ascii("ribtion"),
        dictgen::InsensitiveStr::Ascii("ripcion"),
        dictgen::InsensitiveStr::Ascii("rips"),
        dictgen::InsensitiveStr::Ascii("ripting"),
        dictgen::InsensitiveStr::Ascii("ripto"),
        dictgen::InsensitiveStr::Ascii("ripton"),
        dictgen::InsensitiveStr::Ascii("riptus"),
        dictgen::InsensitiveStr::Ascii("ris"),
        dictgen::InsensitiveStr::Ascii("rit"),
        dictgen::InsensitiveStr::Ascii("rito"),
        dictgen::InsensitiveStr::Ascii("rits"),
        dictgen::InsensitiveStr::Ascii("rpit"),
        dictgen::InsensitiveStr::Ascii("tion"),
        dictgen::InsensitiveStr::Ascii("tions"),
        dictgen::InsensitiveStr::Ascii("ulent"),
    ],
    values: &[
        &["transaction"],
        &["transactions"],
        &["transcoding"],
        &["transcendence"],
        &["transcendent"],
        &["transcendental"],
        &["transceiver"],
        &["transceiver"],
        &["transceivers"],
        &["transcripts"],
        &["transcripts"],
        &["transceiver"],
        &["translucent"],
        &["transcode"],
        &["transcoded"],
        &["transcoder"],
        &["transcoders"],
        &["transcodes"],
        &["transcoding"],
        &["transcodings"],
        &["transcode"],
        &["transcoded"],
        &["transcoder"],
        &["transcoders"],
        &["transcodes"],
        &["transcoding"],
        &["transcodings"],
        &["transcode"],
        &["transcoded"],
        &["transcoder"],
        &["transcoders"],
        &["transcodes"],
        &["transcoding"],
        &["transcodings"],
        &["transcoder"],
        &["transcoders"],
        &["transcription"],
        &["transcription"],
        &["transcripts"],
        &["transcribing", "transcription"],
        &["transcription"],
        &["transcription"],
        &["transcripts"],
        &["transcripts"],
        &["transcript"],
        &["transcript"],
        &["transcripts"],
        &["transcript"],
        &["transaction"],
        &["transitions", "transactions"],
        &["translucent"],
    ],
    range: 3..=13,
};

static WORD_TRANSA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TRANSA_CHILDREN),
    value: None,
};

pub static WORD_TRANSA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ccion"),
        dictgen::InsensitiveStr::Ascii("cion"),
        dictgen::InsensitiveStr::Ascii("cions"),
        dictgen::InsensitiveStr::Ascii("citon"),
        dictgen::InsensitiveStr::Ascii("citons"),
        dictgen::InsensitiveStr::Ascii("crtion"),
        dictgen::InsensitiveStr::Ascii("crtions"),
        dictgen::InsensitiveStr::Ascii("ctiona"),
        dictgen::InsensitiveStr::Ascii("ctoin"),
        dictgen::InsensitiveStr::Ascii("ctoins"),
        dictgen::InsensitiveStr::Ascii("ition"),
        dictgen::InsensitiveStr::Ascii("itions"),
        dictgen::InsensitiveStr::Ascii("lation"),
        dictgen::InsensitiveStr::Ascii("lations"),
        dictgen::InsensitiveStr::Ascii("lt"),
        dictgen::InsensitiveStr::Ascii("lte"),
        dictgen::InsensitiveStr::Ascii("lted"),
        dictgen::InsensitiveStr::Ascii("ltes"),
        dictgen::InsensitiveStr::Ascii("lting"),
        dictgen::InsensitiveStr::Ascii("ltion"),
        dictgen::InsensitiveStr::Ascii("ltions"),
        dictgen::InsensitiveStr::Ascii("ltor"),
        dictgen::InsensitiveStr::Ascii("ltors"),
        dictgen::InsensitiveStr::Ascii("prency"),
        dictgen::InsensitiveStr::Ascii("tion"),
        dictgen::InsensitiveStr::Ascii("tional"),
        dictgen::InsensitiveStr::Ascii("tions"),
    ],
    values: &[
        &["transaction"],
        &["transaction"],
        &["transactions"],
        &["transactions", "transaction"],
        &["transactions"],
        &["transaction"],
        &["transactions"],
        &["transactional", "transactions"],
        &["transaction"],
        &["transactions"],
        &["translation", "transition", "transaction"],
        &["translations", "transitions", "transactions"],
        &["translation"],
        &["translations"],
        &["translate"],
        &["translate"],
        &["translated"],
        &["translates"],
        &["translating"],
        &["translation"],
        &["translations"],
        &["translator"],
        &["translators"],
        &["transparency"],
        &["transition", "transaction", "translation"],
        &["transitional"],
        &["transitions", "transactions", "translations"],
    ],
    range: 2..=7,
};

static WORD_TRANP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TRANP_CHILDREN),
    value: None,
};

pub static WORD_TRANP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("arent"),
        dictgen::InsensitiveStr::Ascii("arently"),
        dictgen::InsensitiveStr::Ascii("ort"),
        dictgen::InsensitiveStr::Ascii("orted"),
        dictgen::InsensitiveStr::Ascii("orting"),
        dictgen::InsensitiveStr::Ascii("orts"),
        dictgen::InsensitiveStr::Ascii("ose"),
        dictgen::InsensitiveStr::Ascii("osed"),
        dictgen::InsensitiveStr::Ascii("oses"),
        dictgen::InsensitiveStr::Ascii("osing"),
        dictgen::InsensitiveStr::Ascii("shobic"),
    ],
    values: &[
        &["transparent"],
        &["transparently"],
        &["transport"],
        &["transported"],
        &["transporting"],
        &["transports"],
        &["transpose"],
        &["transposed"],
        &["transposes"],
        &["transposing"],
        &["transphobic"],
    ],
    range: 3..=7,
};

static WORD_TRANN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TRANN_CHILDREN),
    value: None,
};

pub static WORD_TRANN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("sexual")],
    values: &[&["transsexual"]],
    range: 6..=6,
};

static WORD_TRANM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TRANM_CHILDREN),
    value: None,
};

pub static WORD_TRANM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ission"),
        dictgen::InsensitiveStr::Ascii("ist"),
        dictgen::InsensitiveStr::Ascii("itted"),
        dictgen::InsensitiveStr::Ascii("itting"),
        dictgen::InsensitiveStr::Ascii("sission"),
    ],
    values: &[
        &["transmission"],
        &["transmit"],
        &["transmitted"],
        &["transmitting"],
        &["transmissions"],
    ],
    range: 3..=7,
};

static WORD_TRANL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TRANL_CHILDREN),
    value: None,
};

pub static WORD_TRANL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("astion"),
        dictgen::InsensitiveStr::Ascii("atable"),
        dictgen::InsensitiveStr::Ascii("ate"),
        dictgen::InsensitiveStr::Ascii("ated"),
        dictgen::InsensitiveStr::Ascii("ates"),
        dictgen::InsensitiveStr::Ascii("ating"),
        dictgen::InsensitiveStr::Ascii("ation"),
        dictgen::InsensitiveStr::Ascii("ations"),
        dictgen::InsensitiveStr::Ascii("sate"),
        dictgen::InsensitiveStr::Ascii("sated"),
        dictgen::InsensitiveStr::Ascii("sating"),
        dictgen::InsensitiveStr::Ascii("sation"),
        dictgen::InsensitiveStr::Ascii("sations"),
        dictgen::InsensitiveStr::Ascii("uscent"),
    ],
    values: &[
        &["translations"],
        &["translatable"],
        &["translate"],
        &["translated"],
        &["translates"],
        &["translating"],
        &["translation"],
        &["translations"],
        &["translate"],
        &["translated"],
        &["translating"],
        &["translation"],
        &["translations"],
        &["translucent"],
    ],
    range: 3..=7,
};

static WORD_TRANI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TRANI_CHILDREN),
    value: None,
};

pub static WORD_TRANI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ent"),
        dictgen::InsensitiveStr::Ascii("ents"),
        dictgen::InsensitiveStr::Ascii("stion"),
        dictgen::InsensitiveStr::Ascii("stional"),
        dictgen::InsensitiveStr::Ascii("stioned"),
        dictgen::InsensitiveStr::Ascii("stioning"),
        dictgen::InsensitiveStr::Ascii("stions"),
        dictgen::InsensitiveStr::Ascii("tion"),
        dictgen::InsensitiveStr::Ascii("tioned"),
        dictgen::InsensitiveStr::Ascii("tioning"),
        dictgen::InsensitiveStr::Ascii("tions"),
    ],
    values: &[
        &["transient"],
        &["transients"],
        &["transition"],
        &["transitional"],
        &["transitioned"],
        &["transitioning"],
        &["transitions"],
        &["transition"],
        &["transitioned"],
        &["transitioning"],
        &["transitions"],
    ],
    range: 3..=8,
};

static WORD_TRANF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TRANF_CHILDREN),
    value: None,
};

pub static WORD_TRANF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("er"),
        dictgen::InsensitiveStr::Ascii("ered"),
        dictgen::InsensitiveStr::Ascii("ering"),
        dictgen::InsensitiveStr::Ascii("erred"),
        dictgen::InsensitiveStr::Ascii("ers"),
        dictgen::InsensitiveStr::Ascii("orm"),
        dictgen::InsensitiveStr::Ascii("ormable"),
        dictgen::InsensitiveStr::Ascii("ormation"),
        dictgen::InsensitiveStr::Ascii("ormations"),
        dictgen::InsensitiveStr::Ascii("ormative"),
        dictgen::InsensitiveStr::Ascii("ormed"),
        dictgen::InsensitiveStr::Ascii("ormer"),
        dictgen::InsensitiveStr::Ascii("orming"),
        dictgen::InsensitiveStr::Ascii("orms"),
    ],
    values: &[
        &["transfer"],
        &["transferred"],
        &["transferring"],
        &["transferred"],
        &["transfers"],
        &["transform"],
        &["transformable"],
        &["transformation"],
        &["transformations"],
        &["transformative"],
        &["transformed"],
        &["transformer"],
        &["transforming"],
        &["transforms"],
    ],
    range: 2..=9,
};

static WORD_TRAND_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TRAND_CHILDREN),
    value: None,
};

pub static WORD_TRAND_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("gender"),
        dictgen::InsensitiveStr::Ascii("ional"),
        dictgen::InsensitiveStr::Ascii("itional"),
        dictgen::InsensitiveStr::Ascii("itions"),
    ],
    values: &[
        &["transgender"],
        &["traditional"],
        &["transitional"],
        &["transitions"],
    ],
    range: 5..=7,
};

static WORD_TRANC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TRANC_CHILDREN),
    value: None,
};

pub static WORD_TRANC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eiver"),
        dictgen::InsensitiveStr::Ascii("eivers"),
        dictgen::InsensitiveStr::Ascii("endent"),
        dictgen::InsensitiveStr::Ascii("ending"),
        dictgen::InsensitiveStr::Ascii("late"),
        dictgen::InsensitiveStr::Ascii("lucent"),
    ],
    values: &[
        &["transceiver"],
        &["transceivers"],
        &["transcendent"],
        &["transcending"],
        &["translate"],
        &["translucent"],
    ],
    range: 4..=6,
};

static WORD_TRANA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TRANA_CHILDREN),
    value: None,
};

pub static WORD_TRANA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ction"),
        dictgen::InsensitiveStr::Ascii("ctional"),
        dictgen::InsensitiveStr::Ascii("ctions"),
        dictgen::InsensitiveStr::Ascii("lating"),
        dictgen::InsensitiveStr::Ascii("lation"),
        dictgen::InsensitiveStr::Ascii("lations"),
        dictgen::InsensitiveStr::Ascii("sction"),
        dictgen::InsensitiveStr::Ascii("sctions"),
    ],
    values: &[
        &["transaction"],
        &["transactional"],
        &["transactions"],
        &["translating"],
        &["translation"],
        &["translations"],
        &["transaction"],
        &["transactions"],
    ],
    range: 5..=7,
};

static WORD_TRAM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TRAM_CHILDREN),
    value: None,
};

pub static WORD_TRAM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("a"),
        dictgen::InsensitiveStr::Ascii("as"),
        dictgen::InsensitiveStr::Ascii("autic"),
        dictgen::InsensitiveStr::Ascii("autized"),
        dictgen::InsensitiveStr::Ascii("boline"),
        dictgen::InsensitiveStr::Ascii("endously"),
        dictgen::InsensitiveStr::Ascii("ploine"),
        dictgen::InsensitiveStr::Ascii("polene"),
        dictgen::InsensitiveStr::Ascii("sformers"),
        dictgen::InsensitiveStr::Ascii("sforming"),
        dictgen::InsensitiveStr::Ascii("smit"),
        dictgen::InsensitiveStr::Ascii("smits"),
        dictgen::InsensitiveStr::Ascii("smitted"),
        dictgen::InsensitiveStr::Ascii("smitting"),
        dictgen::InsensitiveStr::Ascii("uatized"),
    ],
    values: &[
        &["trauma", "tram", "trams"],
        &["trams", "traumas"],
        &["traumatic"],
        &["traumatized"],
        &["trampoline"],
        &["tremendously"],
        &["trampoline"],
        &["trampoline"],
        &["transformers"],
        &["transforming"],
        &["transmit"],
        &["transmits"],
        &["transmitted"],
        &["transmitting"],
        &["traumatized"],
    ],
    range: 1..=8,
};

static WORD_TRAL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TRAL_CHILDREN),
    value: Some(&["trail", "trial"]),
};

pub static WORD_TRAL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("ier"),
        dictgen::InsensitiveStr::Ascii("iers"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("led"),
        dictgen::InsensitiveStr::Ascii("ling"),
        dictgen::InsensitiveStr::Ascii("s"),
    ],
    values: &[
        &[
            "traced", "traded", "trailed", "traveled", "trawled", "trialed",
        ],
        &["trailer"],
        &["trailers"],
        &[
            "trailing",
            "trialing",
            "tracing",
            "trading",
            "traveling",
            "trawling",
        ],
        &[
            "trailed",
            "travelled",
            "trawled",
            "trialled",
            "trilled",
            "trolled",
        ],
        &[
            "thralling",
            "trailing",
            "travelling",
            "trialling",
            "trilling",
            "trolling",
        ],
        &["trails", "trials"],
    ],
    range: 1..=4,
};

static WORD_TRAK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TRAK_CHILDREN),
    value: None,
};

pub static WORD_TRAK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cers"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("er"),
        dictgen::InsensitiveStr::Ascii("ers"),
        dictgen::InsensitiveStr::Ascii("ing"),
    ],
    values: &[
        &["trackers"],
        &["tracked"],
        &["tracker"],
        &["trackers"],
        &["tracking"],
    ],
    range: 2..=4,
};

static WORD_TRAI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TRAI_CHILDREN),
    value: None,
};

pub static WORD_TRAI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ds"),
        dictgen::InsensitiveStr::Ascii("ge"),
        dictgen::InsensitiveStr::Ascii("ger"),
        dictgen::InsensitiveStr::Ascii("gers"),
        dictgen::InsensitiveStr::Ascii("ges"),
        dictgen::InsensitiveStr::Ascii("ging"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("leras"),
        dictgen::InsensitiveStr::Ascii("les"),
        dictgen::InsensitiveStr::Ascii("lins"),
        dictgen::InsensitiveStr::Ascii("lling"),
        dictgen::InsensitiveStr::Ascii("nes"),
        dictgen::InsensitiveStr::Ascii("ng"),
        dictgen::InsensitiveStr::Ascii("ngle"),
        dictgen::InsensitiveStr::Ascii("ngles"),
        dictgen::InsensitiveStr::Ascii("ngular"),
        dictgen::InsensitiveStr::Ascii("ngulate"),
        dictgen::InsensitiveStr::Ascii("ngulated"),
        dictgen::InsensitiveStr::Ascii("ngulates"),
        dictgen::InsensitiveStr::Ascii("ngulating"),
        dictgen::InsensitiveStr::Ascii("ngulation"),
        dictgen::InsensitiveStr::Ascii("ngulations"),
        dictgen::InsensitiveStr::Ascii("nig"),
        dictgen::InsensitiveStr::Ascii("nigs"),
        dictgen::InsensitiveStr::Ascii("nling"),
        dictgen::InsensitiveStr::Ascii("nng"),
        dictgen::InsensitiveStr::Ascii("nngs"),
        dictgen::InsensitiveStr::Ascii("nwreak"),
        dictgen::InsensitiveStr::Ascii("nwrek"),
        dictgen::InsensitiveStr::Ascii("toris"),
        dictgen::InsensitiveStr::Ascii("torus"),
        dictgen::InsensitiveStr::Ascii("tour"),
    ],
    values: &[
        &["traits", "triads"],
        &["triage"],
        &["triager"],
        &["triagers"],
        &["triages"],
        &["triaging"],
        &["trailing", "training"],
        &["trailers"],
        &["trailers"],
        &["trailing"],
        &["trailing", "trialling", "trilling"],
        &["trainers"],
        &["training"],
        &["triangle"],
        &["triangles"],
        &["triangular"],
        &["triangulate"],
        &["triangulated"],
        &["triangulates"],
        &["triangulating"],
        &["triangulation"],
        &["triangulations"],
        &["training"],
        &["training"],
        &["trailing", "training"],
        &["training"],
        &["training"],
        &["trainwreck"],
        &["trainwreck"],
        &["traitors"],
        &["traitors"],
        &["traitor"],
    ],
    range: 2..=10,
};

static WORD_TRAG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TRAG_CHILDREN),
    value: None,
};

pub static WORD_TRAG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ectory"),
        dictgen::InsensitiveStr::Ascii("et"),
        dictgen::InsensitiveStr::Ascii("eted"),
        dictgen::InsensitiveStr::Ascii("eting"),
        dictgen::InsensitiveStr::Ascii("ets"),
        dictgen::InsensitiveStr::Ascii("icallly"),
        dictgen::InsensitiveStr::Ascii("icaly"),
    ],
    values: &[
        &["trajectory"],
        &["target"],
        &["targeted"],
        &["targeting"],
        &["targets"],
        &["tragically"],
        &["tragically"],
    ],
    range: 2..=7,
};

static WORD_TRAF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TRAF_CHILDREN),
    value: None,
};

pub static WORD_TRAF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("fice"),
        dictgen::InsensitiveStr::Ascii("ficed"),
        dictgen::InsensitiveStr::Ascii("ficing"),
        dictgen::InsensitiveStr::Ascii("ic"),
    ],
    values: &[
        &["traffic"],
        &["trafficked"],
        &["trafficking"],
        &["traffic"],
    ],
    range: 2..=6,
};

static WORD_TRAD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TRAD_CHILDREN),
    value: None,
};

pub static WORD_TRAD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("dition"),
        dictgen::InsensitiveStr::Ascii("ditional"),
        dictgen::InsensitiveStr::Ascii("ditions"),
        dictgen::InsensitiveStr::Ascii("gic"),
        dictgen::InsensitiveStr::Ascii("icional"),
        dictgen::InsensitiveStr::Ascii("ionally"),
        dictgen::InsensitiveStr::Ascii("isional"),
        dictgen::InsensitiveStr::Ascii("itilnal"),
        dictgen::InsensitiveStr::Ascii("itiona"),
        dictgen::InsensitiveStr::Ascii("itionaly"),
        dictgen::InsensitiveStr::Ascii("itionel"),
        dictgen::InsensitiveStr::Ascii("itionnal"),
        dictgen::InsensitiveStr::Ascii("itionnally"),
        dictgen::InsensitiveStr::Ascii("itition"),
        dictgen::InsensitiveStr::Ascii("tional"),
        dictgen::InsensitiveStr::Ascii("tionally"),
    ],
    values: &[
        &["tradition"],
        &["traditional"],
        &["traditions"],
        &["tragic"],
        &["traditional"],
        &["traditionally"],
        &["traditional"],
        &["traditional"],
        &["traditional"],
        &["traditionally"],
        &["traditional"],
        &["traditional"],
        &["traditionally"],
        &["tradition"],
        &["traditional"],
        &["traditionally"],
    ],
    range: 3..=10,
};

static WORD_TRAC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TRAC_CHILDREN),
    value: None,
};

pub static WORD_TRAC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eablity"),
        dictgen::InsensitiveStr::Ascii("kes"),
        dictgen::InsensitiveStr::Ascii("kign"),
        dictgen::InsensitiveStr::Ascii("kling"),
        dictgen::InsensitiveStr::Ascii("kres"),
        dictgen::InsensitiveStr::Ascii("sode"),
        dictgen::InsensitiveStr::Ascii("soded"),
        dictgen::InsensitiveStr::Ascii("soder"),
        dictgen::InsensitiveStr::Ascii("soders"),
        dictgen::InsensitiveStr::Ascii("sodes"),
        dictgen::InsensitiveStr::Ascii("soding"),
    ],
    values: &[
        &["traceability"],
        &["trackers"],
        &["tracking"],
        &["tracking"],
        &["trackers"],
        &["transcode"],
        &["transcoded"],
        &["transcoder"],
        &["transcoders"],
        &["transcodes"],
        &["transcoding"],
    ],
    range: 3..=7,
};

static WORD_TRAB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TRAB_CHILDREN),
    value: None,
};

pub static WORD_TRAB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ajao"),
        dictgen::InsensitiveStr::Ascii("ajdo"),
        dictgen::InsensitiveStr::Ascii("sform"),
    ],
    values: &[&["trabajo"], &["trabajo"], &["transform"]],
    range: 4..=5,
};

static WORD_TP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TP_CHILDREN),
    value: None,
};

pub static WORD_TP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("os"),
        dictgen::InsensitiveStr::Ascii("ye"),
        dictgen::InsensitiveStr::Ascii("yed"),
        dictgen::InsensitiveStr::Ascii("yes"),
        dictgen::InsensitiveStr::Ascii("yo"),
    ],
    values: &[&["typos"], &["type"], &["typed"], &["types"], &["typo"]],
    range: 2..=3,
};

static WORD_TO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_TO_CHILDREN),
    value: None,
};

static WORD_TO_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_TOA_NODE),
    Some(&WORD_TOB_NODE),
    Some(&WORD_TOC_NODE),
    Some(&WORD_TOD_NODE),
    Some(&WORD_TOE_NODE),
    None,
    Some(&WORD_TOG_NODE),
    None,
    Some(&WORD_TOI_NODE),
    None,
    None,
    Some(&WORD_TOL_NODE),
    Some(&WORD_TOM_NODE),
    Some(&WORD_TON_NODE),
    Some(&WORD_TOO_NODE),
    Some(&WORD_TOP_NODE),
    None,
    Some(&WORD_TOR_NODE),
    Some(&WORD_TOS_NODE),
    Some(&WORD_TOT_NODE),
    Some(&WORD_TOU_NODE),
    None,
    Some(&WORD_TOW_NODE),
    Some(&WORD_TOX_NODE),
    None,
    None,
];

static WORD_TOX_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TOX_CHILDREN),
    value: None,
};

pub static WORD_TOX_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("en"),
        dictgen::InsensitiveStr::Ascii("icitity"),
        dictgen::InsensitiveStr::Ascii("icitiy"),
        dictgen::InsensitiveStr::Ascii("iticy"),
    ],
    values: &[&["toxin"], &["toxicity"], &["toxicity"], &["toxicity"]],
    range: 2..=7,
};

static WORD_TOW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TOW_CHILDREN),
    value: None,
};

pub static WORD_TOW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ords"),
        dictgen::InsensitiveStr::Ascii("rad"),
    ],
    values: &[&["towards"], &["toward"]],
    range: 3..=4,
};

static WORD_TOU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TOU_CHILDREN),
    value: None,
};

pub static WORD_TOU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ble"),
        dictgen::InsensitiveStr::Ascii("bles"),
        dictgen::InsensitiveStr::Ascii("bling"),
        dictgen::InsensitiveStr::Ascii("chapd"),
        dictgen::InsensitiveStr::Ascii("chda"),
        dictgen::InsensitiveStr::Ascii("chdwon"),
        dictgen::InsensitiveStr::Ascii("chsceen"),
        dictgen::InsensitiveStr::Ascii("chscreeen"),
        dictgen::InsensitiveStr::Ascii("chscren"),
        dictgen::InsensitiveStr::Ascii("ght"),
        dictgen::InsensitiveStr::Ascii("ghtful"),
        dictgen::InsensitiveStr::Ascii("ghtly"),
        dictgen::InsensitiveStr::Ascii("ghts"),
        dictgen::InsensitiveStr::Ascii("nge"),
        dictgen::InsensitiveStr::Ascii("nrey"),
        dictgen::InsensitiveStr::Ascii("nreys"),
        dictgen::InsensitiveStr::Ascii("ple"),
        dictgen::InsensitiveStr::Ascii("ranment"),
        dictgen::InsensitiveStr::Ascii("ranments"),
        dictgen::InsensitiveStr::Ascii("rch"),
        dictgen::InsensitiveStr::Ascii("risim"),
        dictgen::InsensitiveStr::Ascii("ristas"),
        dictgen::InsensitiveStr::Ascii("ristes"),
        dictgen::InsensitiveStr::Ascii("ristey"),
        dictgen::InsensitiveStr::Ascii("ristly"),
        dictgen::InsensitiveStr::Ascii("ristsy"),
        dictgen::InsensitiveStr::Ascii("risy"),
        dictgen::InsensitiveStr::Ascii("rits"),
        dictgen::InsensitiveStr::Ascii("ritsy"),
        dictgen::InsensitiveStr::Ascii("rmanent"),
        dictgen::InsensitiveStr::Ascii("rnamet"),
        dictgen::InsensitiveStr::Ascii("rnamets"),
        dictgen::InsensitiveStr::Ascii("rnamnet"),
        dictgen::InsensitiveStr::Ascii("rnamnets"),
        dictgen::InsensitiveStr::Ascii("rnemant"),
        dictgen::InsensitiveStr::Ascii("rnemants"),
        dictgen::InsensitiveStr::Ascii("rnement"),
        dictgen::InsensitiveStr::Ascii("rnements"),
        dictgen::InsensitiveStr::Ascii("rnes"),
        dictgen::InsensitiveStr::Ascii("rnmanets"),
        dictgen::InsensitiveStr::Ascii("rnyes"),
        dictgen::InsensitiveStr::Ascii("rsim"),
        dictgen::InsensitiveStr::Ascii("rsit"),
        dictgen::InsensitiveStr::Ascii("rsits"),
        dictgen::InsensitiveStr::Ascii("rsity"),
    ],
    values: &[
        &["trouble"],
        &["troubles"],
        &["troubling"],
        &["touchpad"],
        &["touchpad"],
        &["touchdown"],
        &["touchscreen"],
        &["touchscreen"],
        &["touchscreen"],
        &["thought", "taught", "tough"],
        &["thoughtful"],
        &["tightly"],
        &["thoughts"],
        &["tongue"],
        &["tourney"],
        &["tourneys"],
        &["tuple"],
        &["tournaments"],
        &["tournaments"],
        &["torch", "touch"],
        &["tourism"],
        &["tourists"],
        &["tourists"],
        &["touristy"],
        &["touristy"],
        &["touristy"],
        &["touristy"],
        &["tourist"],
        &["touristy"],
        &["tournaments"],
        &["tournament"],
        &["tournaments"],
        &["tournament"],
        &["tournaments"],
        &["tournament"],
        &["tournaments"],
        &["tournament"],
        &["tournaments"],
        &["tourneys"],
        &["tournaments"],
        &["tourneys"],
        &["tourism"],
        &["tourist"],
        &["tourists"],
        &["touristy"],
    ],
    range: 3..=9,
};

static WORD_TOT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TOT_CHILDREN),
    value: None,
};

pub static WORD_TOT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("alitara"),
        dictgen::InsensitiveStr::Ascii("alitaran"),
        dictgen::InsensitiveStr::Ascii("alitarion"),
        dictgen::InsensitiveStr::Ascii("alitarni"),
        dictgen::InsensitiveStr::Ascii("alitatian"),
        dictgen::InsensitiveStr::Ascii("aly"),
        dictgen::InsensitiveStr::Ascii("at"),
        dictgen::InsensitiveStr::Ascii("ation"),
        dictgen::InsensitiveStr::Ascii("atl"),
        dictgen::InsensitiveStr::Ascii("atlly"),
        dictgen::InsensitiveStr::Ascii("ats"),
        dictgen::InsensitiveStr::Ascii("hiba"),
        dictgen::InsensitiveStr::Ascii("ol"),
        dictgen::InsensitiveStr::Ascii("orial"),
        dictgen::InsensitiveStr::Ascii("orials"),
        dictgen::InsensitiveStr::Ascii("tehnam"),
        dictgen::InsensitiveStr::Ascii("tenahm"),
        dictgen::InsensitiveStr::Ascii("tneham"),
        dictgen::InsensitiveStr::Ascii("urials"),
    ],
    values: &[
        &["totalitarian"],
        &["totalitarian"],
        &["totalitarian"],
        &["totalitarian"],
        &["totalitarian"],
        &["totally"],
        &["total"],
        &["rotation"],
        &["total"],
        &["totally"],
        &["totals"],
        &["toshiba"],
        &["total"],
        &["tutorial"],
        &["tutorials"],
        &["tottenham"],
        &["tottenham"],
        &["tottenham"],
        &["tutorials"],
    ],
    range: 2..=9,
};

static WORD_TOS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TOS_CHILDREN),
    value: None,
};

pub static WORD_TOS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("day")],
    values: &[&["today", "tuesday"]],
    range: 3..=3,
};

static WORD_TOR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TOR_CHILDREN),
    value: None,
};

pub static WORD_TOR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ando"),
        dictgen::InsensitiveStr::Ascii("andoes"),
        dictgen::InsensitiveStr::Ascii("chilght"),
        dictgen::InsensitiveStr::Ascii("chlgiht"),
        dictgen::InsensitiveStr::Ascii("chligt"),
        dictgen::InsensitiveStr::Ascii("chligth"),
        dictgen::InsensitiveStr::Ascii("elable"),
        dictgen::InsensitiveStr::Ascii("erable"),
        dictgen::InsensitiveStr::Ascii("hclight"),
        dictgen::InsensitiveStr::Ascii("iodal"),
        dictgen::InsensitiveStr::Ascii("itlla"),
        dictgen::InsensitiveStr::Ascii("itllas"),
        dictgen::InsensitiveStr::Ascii("k"),
        dictgen::InsensitiveStr::Ascii("lence"),
        dictgen::InsensitiveStr::Ascii("nadoe"),
        dictgen::InsensitiveStr::Ascii("naodes"),
        dictgen::InsensitiveStr::Ascii("ndao"),
        dictgen::InsensitiveStr::Ascii("otise"),
        dictgen::InsensitiveStr::Ascii("pdeo"),
        dictgen::InsensitiveStr::Ascii("peados"),
        dictgen::InsensitiveStr::Ascii("pedeo"),
        dictgen::InsensitiveStr::Ascii("pedos"),
        dictgen::InsensitiveStr::Ascii("phies"),
        dictgen::InsensitiveStr::Ascii("rentas"),
        dictgen::InsensitiveStr::Ascii("rentbig"),
        dictgen::InsensitiveStr::Ascii("renters"),
        dictgen::InsensitiveStr::Ascii("rentes"),
        dictgen::InsensitiveStr::Ascii("rentking"),
        dictgen::InsensitiveStr::Ascii("rentors"),
        dictgen::InsensitiveStr::Ascii("rentting"),
        dictgen::InsensitiveStr::Ascii("rest"),
        dictgen::InsensitiveStr::Ascii("tialls"),
        dictgen::InsensitiveStr::Ascii("tila"),
        dictgen::InsensitiveStr::Ascii("tilini"),
        dictgen::InsensitiveStr::Ascii("tillera"),
        dictgen::InsensitiveStr::Ascii("tillia"),
        dictgen::InsensitiveStr::Ascii("tillias"),
        dictgen::InsensitiveStr::Ascii("tillita"),
        dictgen::InsensitiveStr::Ascii("tillla"),
        dictgen::InsensitiveStr::Ascii("tilllas"),
        dictgen::InsensitiveStr::Ascii("tiose"),
        dictgen::InsensitiveStr::Ascii("tise"),
        dictgen::InsensitiveStr::Ascii("ubleshoot"),
        dictgen::InsensitiveStr::Ascii("ublesome"),
        dictgen::InsensitiveStr::Ascii("uisty"),
        dictgen::InsensitiveStr::Ascii("unament"),
        dictgen::InsensitiveStr::Ascii("unaments"),
        dictgen::InsensitiveStr::Ascii("uney"),
        dictgen::InsensitiveStr::Ascii("uneys"),
        dictgen::InsensitiveStr::Ascii("ward"),
        dictgen::InsensitiveStr::Ascii("wards"),
    ],
    values: &[
        &["tornado"],
        &["tornadoes"],
        &["torchlight"],
        &["torchlight"],
        &["torchlight"],
        &["torchlight"],
        &["tolerable"],
        &["tolerable"],
        &["torchlight"],
        &["toroidal"],
        &["tortilla"],
        &["tortillas"],
        &["torque"],
        &["tolerance"],
        &["tornado"],
        &["tornadoes"],
        &["tornado"],
        &["tortoise"],
        &["torpedo"],
        &["torpedoes"],
        &["torpedo"],
        &["torpedoes"],
        &["trophies"],
        &["torrents"],
        &["torrenting"],
        &["torrents"],
        &["torrents"],
        &["torrenting"],
        &["torrents"],
        &["torrenting"],
        &["torrents"],
        &["tortillas"],
        &["tortilla"],
        &["tortellini"],
        &["tortilla"],
        &["tortilla"],
        &["tortilla"],
        &["tortilla"],
        &["tortilla"],
        &["tortilla"],
        &["tortoise"],
        &["tortoise"],
        &["troubleshoot"],
        &["troublesome"],
        &["touristy"],
        &["tournament"],
        &["tournaments"],
        &["tourney"],
        &["tourneys"],
        &["toward"],
        &["towards"],
    ],
    range: 1..=9,
};

static WORD_TOP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TOP_CHILDREN),
    value: None,
};

pub static WORD_TOP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("icaizer"),
        dictgen::InsensitiveStr::Ascii("ologie"),
        dictgen::InsensitiveStr::Ascii("oplogical"),
        dictgen::InsensitiveStr::Ascii("oplogies"),
        dictgen::InsensitiveStr::Ascii("oplogy"),
        dictgen::InsensitiveStr::Ascii("pingest"),
        dictgen::InsensitiveStr::Ascii("pins"),
    ],
    values: &[
        &["topicalizer"],
        &["topology"],
        &["topological"],
        &["topologies"],
        &["topology"],
        &["toppings"],
        &["toppings"],
    ],
    range: 4..=9,
};

static WORD_TOO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TOO_CHILDREN),
    value: None,
};

pub static WORD_TOO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("d"),
        dictgen::InsensitiveStr::Ascii("gle"),
        dictgen::InsensitiveStr::Ascii("gling"),
        dictgen::InsensitiveStr::Ascii("kit"),
        dictgen::InsensitiveStr::Ascii("kits"),
        dictgen::InsensitiveStr::Ascii("ks"),
        dictgen::InsensitiveStr::Ascii("lar"),
        dictgen::InsensitiveStr::Ascii("lsbox"),
        dictgen::InsensitiveStr::Ascii("m"),
        dictgen::InsensitiveStr::Ascii("o"),
        dictgen::InsensitiveStr::Ascii("s"),
        dictgen::InsensitiveStr::Ascii("sday"),
        dictgen::InsensitiveStr::Ascii("thbruch"),
        dictgen::InsensitiveStr::Ascii("thbruth"),
        dictgen::InsensitiveStr::Ascii("thbursh"),
        dictgen::InsensitiveStr::Ascii("thrbush"),
        dictgen::InsensitiveStr::Ascii("tonic"),
    ],
    values: &[
        &["todo"],
        &["toggle"],
        &["toggling"],
        &["toolkit"],
        &["toolkits"],
        &["takes", "took"],
        &["toolbar"],
        &["toolbox"],
        &["tomb"],
        &["todo", "too", "took", "tool"],
        &["tools"],
        &["tuesday"],
        &["toothbrush"],
        &["toothbrush"],
        &["toothbrush"],
        &["toothbrush"],
        &["teutonic"],
    ],
    range: 1..=7,
};

static WORD_TON_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TON_CHILDREN),
    value: None,
};

pub static WORD_TON_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ange"),
        dictgen::InsensitiveStr::Ascii("giht"),
        dictgen::InsensitiveStr::Ascii("guers"),
        dictgen::InsensitiveStr::Ascii("ihgt"),
        dictgen::InsensitiveStr::Ascii("uges"),
    ],
    values: &[
        &["tonnage"],
        &["tonight"],
        &["tongues"],
        &["tonight"],
        &["tongues"],
    ],
    range: 4..=5,
};

static WORD_TOM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TOM_CHILDREN),
    value: None,
};

pub static WORD_TOM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("atoe"),
        dictgen::InsensitiveStr::Ascii("atos"),
        dictgen::InsensitiveStr::Ascii("morow"),
        dictgen::InsensitiveStr::Ascii("morrow"),
        dictgen::InsensitiveStr::Ascii("orrrow"),
    ],
    values: &[
        &["tomato"],
        &["tomatoes"],
        &["tomorrow"],
        &["tomorrow"],
        &["tomorrow"],
    ],
    range: 4..=6,
};

static WORD_TOL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TOL_CHILDREN),
    value: None,
};

pub static WORD_TOL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("arable"),
        dictgen::InsensitiveStr::Ascii("earnce"),
        dictgen::InsensitiveStr::Ascii("elerance"),
        dictgen::InsensitiveStr::Ascii("en"),
        dictgen::InsensitiveStr::Ascii("ens"),
        dictgen::InsensitiveStr::Ascii("erabe"),
        dictgen::InsensitiveStr::Ascii("eranz"),
        dictgen::InsensitiveStr::Ascii("erence"),
        dictgen::InsensitiveStr::Ascii("erences"),
        dictgen::InsensitiveStr::Ascii("erent"),
        dictgen::InsensitiveStr::Ascii("ernce"),
        dictgen::InsensitiveStr::Ascii("iets"),
        dictgen::InsensitiveStr::Ascii("kein"),
        dictgen::InsensitiveStr::Ascii("lerable"),
        dictgen::InsensitiveStr::Ascii("lerance"),
        dictgen::InsensitiveStr::Ascii("lerances"),
        dictgen::InsensitiveStr::Ascii("lerant"),
        dictgen::InsensitiveStr::Ascii("orance"),
        dictgen::InsensitiveStr::Ascii("orances"),
        dictgen::InsensitiveStr::Ascii("orant"),
    ],
    values: &[
        &["tolerable"],
        &["tolerance"],
        &["tolerance"],
        &["token"],
        &["tokens"],
        &["tolerable"],
        &["tolerance"],
        &["tolerance"],
        &["tolerances"],
        &["tolerant"],
        &["tolerance"],
        &["toilets"],
        &["tolkien"],
        &["tolerable"],
        &["tolerance"],
        &["tolerances"],
        &["tolerant"],
        &["tolerance"],
        &["tolerances"],
        &["tolerant"],
    ],
    range: 2..=8,
};

static WORD_TOI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TOI_CHILDREN),
    value: Some(&["to", "toy"]),
};

pub static WORD_TOI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("letts")],
    values: &[&["toilets"]],
    range: 5..=5,
};

static WORD_TOG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TOG_CHILDREN),
    value: None,
};

pub static WORD_TOG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ehter"),
        dictgen::InsensitiveStr::Ascii("eter"),
        dictgen::InsensitiveStr::Ascii("eterness"),
        dictgen::InsensitiveStr::Ascii("gel"),
        dictgen::InsensitiveStr::Ascii("geles"),
        dictgen::InsensitiveStr::Ascii("geling"),
        dictgen::InsensitiveStr::Ascii("gels"),
        dictgen::InsensitiveStr::Ascii("gleing"),
        dictgen::InsensitiveStr::Ascii("heter"),
        dictgen::InsensitiveStr::Ascii("hether"),
        dictgen::InsensitiveStr::Ascii("le"),
        dictgen::InsensitiveStr::Ascii("led"),
        dictgen::InsensitiveStr::Ascii("ling"),
        dictgen::InsensitiveStr::Ascii("lle"),
        dictgen::InsensitiveStr::Ascii("lled"),
        dictgen::InsensitiveStr::Ascii("ther"),
        dictgen::InsensitiveStr::Ascii("ueter"),
    ],
    values: &[
        &["together"],
        &["together"],
        &["togetherness"],
        &["toggle"],
        &["toggles"],
        &["toggling"],
        &["toggles"],
        &["toggling"],
        &["together"],
        &["together"],
        &["toggle"],
        &["toggled"],
        &["toggling"],
        &["toggle"],
        &["toggled"],
        &["together"],
        &["together"],
    ],
    range: 2..=8,
};

static WORD_TOE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TOE_CHILDREN),
    value: None,
};

pub static WORD_TOE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("kn"),
        dictgen::InsensitiveStr::Ascii("ther"),
    ],
    values: &[&["token"], &["together", "tether"]],
    range: 2..=4,
};

static WORD_TOD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TOD_CHILDREN),
    value: None,
};

pub static WORD_TOD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ya")],
    values: &[&["today"]],
    range: 2..=2,
};

static WORD_TOC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TOC_CHILDREN),
    value: None,
};

pub static WORD_TOC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("hes"),
        dictgen::InsensitiveStr::Ascii("ksen"),
        dictgen::InsensitiveStr::Ascii("uhdown"),
        dictgen::InsensitiveStr::Ascii("uhpad"),
        dictgen::InsensitiveStr::Ascii("uhscreen"),
    ],
    values: &[
        &["touches"],
        &["toxin"],
        &["touchdown"],
        &["touchpad"],
        &["touchscreen"],
    ],
    range: 3..=8,
};

static WORD_TOB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TOB_CHILDREN),
    value: None,
};

pub static WORD_TOB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("baco"),
        dictgen::InsensitiveStr::Ascii("ot"),
    ],
    values: &[&["tobacco"], &["robot"]],
    range: 2..=4,
};

static WORD_TOA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TOA_CHILDREN),
    value: None,
};

pub static WORD_TOA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("lly")],
    values: &[&["totally"]],
    range: 3..=3,
};

static WORD_TN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TN_CHILDREN),
    value: None,
};

pub static WORD_TN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("e")],
    values: &[&["the"]],
    range: 1..=1,
};

static WORD_TM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TM_CHILDREN),
    value: None,
};

pub static WORD_TM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("is")],
    values: &[&["this"]],
    range: 2..=2,
};

static WORD_TL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TL_CHILDREN),
    value: None,
};

pub static WORD_TL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("aking")],
    values: &[&["talking"]],
    range: 5..=5,
};

static WORD_TK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TK_CHILDREN),
    value: None,
};

pub static WORD_TK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ae"),
        dictgen::InsensitiveStr::Ascii("aes"),
        dictgen::InsensitiveStr::Ascii("aing"),
    ],
    values: &[&["take"], &["takes"], &["taking"]],
    range: 2..=4,
};

static WORD_TJ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TJ_CHILDREN),
    value: None,
};

pub static WORD_TJ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("he"),
        dictgen::InsensitiveStr::Ascii("panishad"),
    ],
    values: &[&["the"], &["the"], &["upanishad"]],
    range: 1..=8,
};

static WORD_TI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_TI_CHILDREN),
    value: None,
};

static WORD_TI_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_TIA_NODE),
    None,
    Some(&WORD_TIC_NODE),
    Some(&WORD_TID_NODE),
    Some(&WORD_TIE_NODE),
    None,
    Some(&WORD_TIG_NODE),
    Some(&WORD_TIH_NODE),
    Some(&WORD_TII_NODE),
    None,
    None,
    Some(&WORD_TIL_NODE),
    Some(&WORD_TIM_NODE),
    Some(&WORD_TIN_NODE),
    Some(&WORD_TIO_NODE),
    Some(&WORD_TIP_NODE),
    None,
    Some(&WORD_TIR_NODE),
    None,
    Some(&WORD_TIT_NODE),
    None,
    None,
    Some(&WORD_TIW_NODE),
    None,
    None,
    None,
];

static WORD_TIW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TIW_CHILDREN),
    value: None,
};

pub static WORD_TIW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ards")],
    values: &[&["towards"]],
    range: 4..=4,
};

static WORD_TIT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TIT_CHILDREN),
    value: None,
};

pub static WORD_TIT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ainum"),
        dictgen::InsensitiveStr::Ascii("anim"),
        dictgen::InsensitiveStr::Ascii("anuim"),
        dictgen::InsensitiveStr::Ascii("el"),
        dictgen::InsensitiveStr::Ascii("els"),
        dictgen::InsensitiveStr::Ascii("ile"),
        dictgen::InsensitiveStr::Ascii("tled"),
        dictgen::InsensitiveStr::Ascii("tling"),
    ],
    values: &[
        &["titanium"],
        &["titanium"],
        &["titanium"],
        &["title"],
        &["titles"],
        &["title"],
        &["titled"],
        &["titling"],
    ],
    range: 2..=5,
};

static WORD_TIR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TIR_CHILDREN),
    value: None,
};

pub static WORD_TIR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("angle"),
        dictgen::InsensitiveStr::Ascii("angles"),
        dictgen::InsensitiveStr::Ascii("bunal"),
        dictgen::InsensitiveStr::Ascii("dent"),
    ],
    values: &[&["triangle"], &["triangles"], &["tribunal"], &["trident"]],
    range: 4..=6,
};

static WORD_TIP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TIP_CHILDREN),
    value: None,
};

pub static WORD_TIP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("ically"),
    ],
    values: &[&["type", "tip"], &["typically"]],
    range: 1..=6,
};

static WORD_TIO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TIO_CHILDREN),
    value: None,
};

pub static WORD_TIO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("lets"),
        dictgen::InsensitiveStr::Ascii("me"),
    ],
    values: &[&["toilets"], &["time", "tome"]],
    range: 2..=4,
};

static WORD_TIN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TIN_CHILDREN),
    value: None,
};

pub static WORD_TIN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("dergarten"),
        dictgen::InsensitiveStr::Ascii("terrupts"),
    ],
    values: &[&["kindergarten"], &["interrupts"]],
    range: 8..=9,
};

static WORD_TIM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TIM_CHILDREN),
    value: None,
};

pub static WORD_TIM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("delta"),
        dictgen::InsensitiveStr::Ascii("edlta"),
        dictgen::InsensitiveStr::Ascii("eing"),
        dictgen::InsensitiveStr::Ascii("emout"),
        dictgen::InsensitiveStr::Ascii("eot"),
        dictgen::InsensitiveStr::Ascii("eput"),
        dictgen::InsensitiveStr::Ascii("eputs"),
        dictgen::InsensitiveStr::Ascii("ere"),
        dictgen::InsensitiveStr::Ascii("esamp"),
        dictgen::InsensitiveStr::Ascii("esamped"),
        dictgen::InsensitiveStr::Ascii("esamps"),
        dictgen::InsensitiveStr::Ascii("espanp"),
        dictgen::InsensitiveStr::Ascii("espanps"),
        dictgen::InsensitiveStr::Ascii("estan"),
        dictgen::InsensitiveStr::Ascii("estanp"),
        dictgen::InsensitiveStr::Ascii("estanps"),
        dictgen::InsensitiveStr::Ascii("estans"),
        dictgen::InsensitiveStr::Ascii("estap"),
        dictgen::InsensitiveStr::Ascii("estaped"),
        dictgen::InsensitiveStr::Ascii("estaping"),
        dictgen::InsensitiveStr::Ascii("estaps"),
        dictgen::InsensitiveStr::Ascii("estemp"),
        dictgen::InsensitiveStr::Ascii("estemps"),
        dictgen::InsensitiveStr::Ascii("estmap"),
        dictgen::InsensitiveStr::Ascii("estmaps"),
        dictgen::InsensitiveStr::Ascii("etamp"),
        dictgen::InsensitiveStr::Ascii("etamps"),
        dictgen::InsensitiveStr::Ascii("mestamp"),
        dictgen::InsensitiveStr::Ascii("mestamps"),
        dictgen::InsensitiveStr::Ascii("ming"),
        dictgen::InsensitiveStr::Ascii("ne"),
        dictgen::InsensitiveStr::Ascii("oeut"),
        dictgen::InsensitiveStr::Ascii("out"),
        dictgen::InsensitiveStr::Ascii("tout"),
        dictgen::InsensitiveStr::Ascii("zeone"),
        dictgen::InsensitiveStr::Ascii("zeones"),
        dictgen::InsensitiveStr::Ascii("zezone"),
        dictgen::InsensitiveStr::Ascii("zezones"),
    ],
    values: &[
        &["timedelta"],
        &["timedelta"],
        &["timing"],
        &["timeout"],
        &["timeout"],
        &["timeout"],
        &["timeouts"],
        &["timer"],
        &["timestamp"],
        &["timestamped"],
        &["timestamps"],
        &["timespan"],
        &["timespans"],
        &["timespan"],
        &["timestamp", "timespan"],
        &["timestamps", "timespans"],
        &["timespans"],
        &["timestamp"],
        &["timestamped"],
        &["timestamping"],
        &["timestamps"],
        &["timestamp"],
        &["timestamps"],
        &["timestamp"],
        &["timestamps"],
        &["timestamp"],
        &["timestamps"],
        &["timestamp"],
        &["timestamps"],
        &["timing", "trimming"],
        &["time"],
        &["timeout"],
        &["timeout"],
        &["timeout"],
        &["timezone"],
        &["timezones"],
        &["timezone"],
        &["timezones"],
    ],
    range: 2..=8,
};

static WORD_TIL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TIL_CHILDREN),
    value: None,
};

pub static WORD_TIL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("lt"),
        dictgen::InsensitiveStr::Ascii("lted"),
        dictgen::InsensitiveStr::Ascii("lts"),
    ],
    values: &[&["tilt"], &["tilted"], &["tilts"]],
    range: 2..=4,
};

static WORD_TII_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TII_CHILDREN),
    value: None,
};

pub static WORD_TII_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("tle")],
    values: &[&["title"]],
    range: 3..=3,
};

static WORD_TIH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TIH_CHILDREN),
    value: None,
};

pub static WORD_TIH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("kn"),
        dictgen::InsensitiveStr::Ascii("nk"),
        dictgen::InsensitiveStr::Ascii("s"),
    ],
    values: &[&["think"], &["think"], &["this"]],
    range: 1..=2,
};

static WORD_TIG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TIG_CHILDREN),
    value: None,
};

pub static WORD_TIG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ger"),
        dictgen::InsensitiveStr::Ascii("gered"),
        dictgen::InsensitiveStr::Ascii("gering"),
        dictgen::InsensitiveStr::Ascii("gers"),
        dictgen::InsensitiveStr::Ascii("her"),
        dictgen::InsensitiveStr::Ascii("hetning"),
        dictgen::InsensitiveStr::Ascii("hly"),
        dictgen::InsensitiveStr::Ascii("htare"),
        dictgen::InsensitiveStr::Ascii("htely"),
        dictgen::InsensitiveStr::Ascii("htenting"),
        dictgen::InsensitiveStr::Ascii("htining"),
        dictgen::InsensitiveStr::Ascii("th"),
        dictgen::InsensitiveStr::Ascii("then"),
        dictgen::InsensitiveStr::Ascii("thened"),
        dictgen::InsensitiveStr::Ascii("thening"),
        dictgen::InsensitiveStr::Ascii("thens"),
        dictgen::InsensitiveStr::Ascii("ther"),
        dictgen::InsensitiveStr::Ascii("thly"),
    ],
    values: &[
        &["trigger"],
        &["triggered"],
        &["triggering"],
        &["triggers"],
        &["tighter"],
        &["tightening"],
        &["tightly"],
        &["tighter"],
        &["tightly"],
        &["tightening"],
        &["tightening"],
        &["tight"],
        &["tighten"],
        &["tightened"],
        &["tightening"],
        &["tightens"],
        &["tighter"],
        &["tightly"],
    ],
    range: 2..=8,
};

static WORD_TIE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TIE_CHILDREN),
    value: None,
};

pub static WORD_TIE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("m"),
        dictgen::InsensitiveStr::Ascii("mout"),
        dictgen::InsensitiveStr::Ascii("mstamp"),
        dictgen::InsensitiveStr::Ascii("mstamped"),
        dictgen::InsensitiveStr::Ascii("mstamps"),
        dictgen::InsensitiveStr::Ascii("th"),
    ],
    values: &[
        &["tying"],
        &["time", "item"],
        &["timeout"],
        &["timestamp"],
        &["timestamped"],
        &["timestamps"],
        &["tithe"],
    ],
    range: 1..=8,
};

static WORD_TID_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TID_CHILDREN),
    value: None,
};

pub static WORD_TID_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ibt"),
        dictgen::InsensitiveStr::Ascii("ibts"),
        dictgen::InsensitiveStr::Ascii("yness"),
    ],
    values: &[&["tidbit"], &["tidbits"], &["tidiness"]],
    range: 3..=5,
};

static WORD_TIC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TIC_CHILDREN),
    value: None,
};

pub static WORD_TIC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("h"),
        dictgen::InsensitiveStr::Ascii("hened"),
        dictgen::InsensitiveStr::Ascii("hness"),
        dictgen::InsensitiveStr::Ascii("kness"),
    ],
    values: &[
        &["thick", "tick", "titch", "stitch"],
        &["thickened"],
        &["thickness"],
        &["thickness"],
    ],
    range: 1..=5,
};

static WORD_TIA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TIA_CHILDREN),
    value: None,
};

pub static WORD_TIA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("wanese")],
    values: &[&["taiwanese"]],
    range: 6..=6,
};

static WORD_TH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_TH_CHILDREN),
    value: None,
};

static WORD_TH_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_THA_NODE),
    None,
    Some(&WORD_THC_NODE),
    None,
    Some(&WORD_THE_NODE),
    None,
    Some(&WORD_THG_NODE),
    Some(&WORD_THH_NODE),
    Some(&WORD_THI_NODE),
    Some(&WORD_THJ_NODE),
    None,
    None,
    Some(&WORD_THM_NODE),
    Some(&WORD_THN_NODE),
    Some(&WORD_THO_NODE),
    None,
    Some(&WORD_THQ_NODE),
    Some(&WORD_THR_NODE),
    Some(&WORD_THS_NODE),
    Some(&WORD_THT_NODE),
    Some(&WORD_THU_NODE),
    None,
    Some(&WORD_THW_NODE),
    None,
    Some(&WORD_THY_NODE),
    None,
];

static WORD_THY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_THY_CHILDREN),
    value: None,
};

pub static WORD_THY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("at"),
        dictgen::InsensitiveStr::Ascii("orid"),
        dictgen::InsensitiveStr::Ascii("riod"),
    ],
    values: &[&["that"], &["thyroid"], &["thyroid"]],
    range: 2..=4,
};

static WORD_THW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_THW_CHILDREN),
    value: Some(&["the", "thaw"]),
};

pub static WORD_THW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[],
    values: &[],
    range: 0..=0,
};

static WORD_THU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_THU_CHILDREN),
    value: None,
};

pub static WORD_THU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("bmnails"),
        dictgen::InsensitiveStr::Ascii("dnerbolt"),
        dictgen::InsensitiveStr::Ascii("is"),
        dictgen::InsensitiveStr::Ascii("mbbnail"),
        dictgen::InsensitiveStr::Ascii("mbmails"),
        dictgen::InsensitiveStr::Ascii("mbnailers"),
        dictgen::InsensitiveStr::Ascii("mbnal"),
        dictgen::InsensitiveStr::Ascii("mbnals"),
        dictgen::InsensitiveStr::Ascii("mbnial"),
        dictgen::InsensitiveStr::Ascii("mnail"),
        dictgen::InsensitiveStr::Ascii("mnails"),
        dictgen::InsensitiveStr::Ascii("nberbolt"),
        dictgen::InsensitiveStr::Ascii("ndebird"),
        dictgen::InsensitiveStr::Ascii("nderblot"),
        dictgen::InsensitiveStr::Ascii("nderboat"),
        dictgen::InsensitiveStr::Ascii("nderboldt"),
        dictgen::InsensitiveStr::Ascii("nderbot"),
        dictgen::InsensitiveStr::Ascii("nderbots"),
        dictgen::InsensitiveStr::Ascii("nderbowl"),
        dictgen::InsensitiveStr::Ascii("nderjolt"),
        dictgen::InsensitiveStr::Ascii("nderolt"),
        dictgen::InsensitiveStr::Ascii("ndervolt"),
        dictgen::InsensitiveStr::Ascii("rday"),
        dictgen::InsensitiveStr::Ascii("rdsay"),
        dictgen::InsensitiveStr::Ascii("rdsays"),
        dictgen::InsensitiveStr::Ascii("rough"),
        dictgen::InsensitiveStr::Ascii("rrow"),
        dictgen::InsensitiveStr::Ascii("rsdey"),
        dictgen::InsensitiveStr::Ascii("rsdsay"),
        dictgen::InsensitiveStr::Ascii("rsdsy"),
        dictgen::InsensitiveStr::Ascii("rsters"),
        dictgen::InsensitiveStr::Ascii("rver"),
    ],
    values: &[
        &["thumbnails"],
        &["thunderbolt"],
        &["this", "thus"],
        &["thumbnail"],
        &["thumbnails"],
        &["thumbnails"],
        &["thumbnails", "thumbnail"],
        &["thumbnails"],
        &["thumbnail"],
        &["thumbnail"],
        &["thumbnails"],
        &["thunderbolt"],
        &["thunderbird"],
        &["thunderbolt"],
        &["thunderbolt"],
        &["thunderbolt"],
        &["thunderbolt"],
        &["thunderbolt"],
        &["thunderbolt"],
        &["thunderbolt"],
        &["thunderbolt"],
        &["thunderbolt"],
        &["thursday"],
        &["thursday"],
        &["thursdays"],
        &["thorough"],
        &["thorough"],
        &["thursday"],
        &["thursdays"],
        &["thursdays"],
        &["thrusters"],
        &["further"],
    ],
    range: 2..=9,
};

static WORD_THT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_THT_CHILDREN),
    value: Some(&["the", "that"]),
};

pub static WORD_THT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("a"),
        dictgen::InsensitiveStr::Ascii("at"),
        dictgen::InsensitiveStr::Ascii("e"),
    ],
    values: &[&["that"], &["that"], &["the", "that"]],
    range: 1..=2,
};

static WORD_THS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_THS_CHILDREN),
    value: Some(&["the", "this"]),
};

pub static WORD_THS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("i"),
        dictgen::InsensitiveStr::Ascii("nk"),
        dictgen::InsensitiveStr::Ascii("nked"),
        dictgen::InsensitiveStr::Ascii("nkful"),
        dictgen::InsensitiveStr::Ascii("nkfully"),
        dictgen::InsensitiveStr::Ascii("nkfulness"),
        dictgen::InsensitiveStr::Ascii("nking"),
        dictgen::InsensitiveStr::Ascii("nks"),
        dictgen::InsensitiveStr::Ascii("oe"),
        dictgen::InsensitiveStr::Ascii("ose"),
        dictgen::InsensitiveStr::Ascii("ould"),
        dictgen::InsensitiveStr::Ascii("t"),
    ],
    values: &[
        &["the", "these", "this"],
        &["these"],
        &["this"],
        &["thank"],
        &["thanked"],
        &["thankful"],
        &["thankfully"],
        &["thankfulness"],
        &["thanking"],
        &["thanks"],
        &["those"],
        &["those"],
        &["should"],
        &["that"],
    ],
    range: 1..=9,
};

static WORD_THR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_THR_CHILDREN),
    value: None,
};

static WORD_THR_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_THRA_NODE),
    None,
    None,
    None,
    Some(&WORD_THRE_NODE),
    None,
    None,
    None,
    Some(&WORD_THRI_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_THRO_NODE),
    None,
    None,
    Some(&WORD_THRR_NODE),
    None,
    None,
    Some(&WORD_THRU_NODE),
    None,
    None,
    None,
    Some(&WORD_THRY_NODE),
    None,
];

static WORD_THRY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_THRY_CHILDREN),
    value: None,
};

pub static WORD_THRY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("oid")],
    values: &[&["thyroid"]],
    range: 3..=3,
};

static WORD_THRU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_THRU_CHILDREN),
    value: None,
};

pub static WORD_THRU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("gh"),
        dictgen::InsensitiveStr::Ascii("ogh"),
        dictgen::InsensitiveStr::Ascii("oghout"),
        dictgen::InsensitiveStr::Ascii("oghput"),
        dictgen::InsensitiveStr::Ascii("out"),
        dictgen::InsensitiveStr::Ascii("sday"),
        dictgen::InsensitiveStr::Ascii("sdays"),
    ],
    values: &[
        &["thru"],
        &["through"],
        &["through"],
        &["throughout"],
        &["throughput"],
        &["throughout"],
        &["thursday"],
        &["thursdays"],
    ],
    range: 1..=6,
};

static WORD_THRR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_THRR_CHILDREN),
    value: None,
};

pub static WORD_THRR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eshold"),
        dictgen::InsensitiveStr::Ascii("esholds"),
    ],
    values: &[&["threshold"], &["thresholds"]],
    range: 6..=7,
};

static WORD_THRO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_THRO_CHILDREN),
    value: None,
};

pub static WORD_THRO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ast"),
        dictgen::InsensitiveStr::Ascii("aths"),
        dictgen::InsensitiveStr::Ascii("en"),
        dictgen::InsensitiveStr::Ascii("gh"),
        dictgen::InsensitiveStr::Ascii("ium"),
        dictgen::InsensitiveStr::Ascii("n"),
        dictgen::InsensitiveStr::Ascii("ners"),
        dictgen::InsensitiveStr::Ascii("ough"),
        dictgen::InsensitiveStr::Ascii("rough"),
        dictgen::InsensitiveStr::Ascii("thling"),
        dictgen::InsensitiveStr::Ascii("tlling"),
        dictgen::InsensitiveStr::Ascii("tte"),
        dictgen::InsensitiveStr::Ascii("tted"),
        dictgen::InsensitiveStr::Ascii("ttes"),
        dictgen::InsensitiveStr::Ascii("tting"),
        dictgen::InsensitiveStr::Ascii("ttleing"),
        dictgen::InsensitiveStr::Ascii("ttoling"),
        dictgen::InsensitiveStr::Ascii("ug"),
        dictgen::InsensitiveStr::Ascii("ugg"),
        dictgen::InsensitiveStr::Ascii("ughiut"),
        dictgen::InsensitiveStr::Ascii("ughly"),
        dictgen::InsensitiveStr::Ascii("ughoput"),
        dictgen::InsensitiveStr::Ascii("ught"),
        dictgen::InsensitiveStr::Ascii("ughtout"),
        dictgen::InsensitiveStr::Ascii("ughtput"),
        dictgen::InsensitiveStr::Ascii("ugout"),
        dictgen::InsensitiveStr::Ascii("ugput"),
        dictgen::InsensitiveStr::Ascii("ugt"),
        dictgen::InsensitiveStr::Ascii("ugth"),
        dictgen::InsensitiveStr::Ascii("uh"),
        dictgen::InsensitiveStr::Ascii("uhg"),
        dictgen::InsensitiveStr::Ascii("uhgout"),
        dictgen::InsensitiveStr::Ascii("uhgput"),
        dictgen::InsensitiveStr::Ascii("uth"),
        dictgen::InsensitiveStr::Ascii("wed"),
        dictgen::InsensitiveStr::Ascii("wgh"),
    ],
    values: &[
        &["throats"],
        &["throats"],
        &["thrown"],
        &["through"],
        &["thorium"],
        &["thrown", "throne"],
        &["thrones"],
        &["thorough"],
        &["thorough"],
        &["throttling"],
        &["throttling"],
        &["throttle", "trot"],
        &["throttled", "trotted"],
        &["throttles", "trots"],
        &["throttling", "trotting"],
        &["throttling"],
        &["throttling"],
        &["through"],
        &["through"],
        &["throughput"],
        &["thoroughly"],
        &["throughput"],
        &["thought", "through", "throughout"],
        &["throughout"],
        &["throughput"],
        &["throughout"],
        &["throughput"],
        &["through"],
        &["through"],
        &["through"],
        &["through"],
        &["throughout"],
        &["throughput"],
        &["through"],
        &["threw", "thrown"],
        &["through"],
    ],
    range: 1..=7,
};

static WORD_THRI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_THRI_CHILDREN),
    value: None,
};

pub static WORD_THRI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("d"),
        dictgen::InsensitiveStr::Ascii("dly"),
        dictgen::InsensitiveStr::Ascii("sty"),
        dictgen::InsensitiveStr::Ascii("teen"),
        dictgen::InsensitiveStr::Ascii("ties"),
    ],
    values: &[
        &["third"],
        &["thirdly"],
        &["thirsty"],
        &["thirteen"],
        &["thirties"],
    ],
    range: 1..=4,
};

static WORD_THRE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_THRE_CHILDREN),
    value: Some(&["three", "there", "their", "the"]),
};

pub static WORD_THRE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("add"),
        dictgen::InsensitiveStr::Ascii("adened"),
        dictgen::InsensitiveStr::Ascii("adsave"),
        dictgen::InsensitiveStr::Ascii("ah"),
        dictgen::InsensitiveStr::Ascii("ashold"),
        dictgen::InsensitiveStr::Ascii("asholds"),
        dictgen::InsensitiveStr::Ascii("ataning"),
        dictgen::InsensitiveStr::Ascii("ated"),
        dictgen::InsensitiveStr::Ascii("atend"),
        dictgen::InsensitiveStr::Ascii("atended"),
        dictgen::InsensitiveStr::Ascii("atenes"),
        dictgen::InsensitiveStr::Ascii("ates"),
        dictgen::InsensitiveStr::Ascii("atining"),
        dictgen::InsensitiveStr::Ascii("atment"),
        dictgen::InsensitiveStr::Ascii("atments"),
        dictgen::InsensitiveStr::Ascii("atning"),
        dictgen::InsensitiveStr::Ascii("d"),
        dictgen::InsensitiveStr::Ascii("ded"),
        dictgen::InsensitiveStr::Ascii("dhold"),
        dictgen::InsensitiveStr::Ascii("ding"),
        dictgen::InsensitiveStr::Ascii("ds"),
        dictgen::InsensitiveStr::Ascii("ee"),
        dictgen::InsensitiveStr::Ascii("efor"),
        dictgen::InsensitiveStr::Ascii("eof"),
        dictgen::InsensitiveStr::Ascii("eshold"),
        dictgen::InsensitiveStr::Ascii("hold"),
        dictgen::InsensitiveStr::Ascii("re"),
        dictgen::InsensitiveStr::Ascii("refore"),
        dictgen::InsensitiveStr::Ascii("shhold"),
        dictgen::InsensitiveStr::Ascii("shholds"),
        dictgen::InsensitiveStr::Ascii("shod"),
        dictgen::InsensitiveStr::Ascii("shods"),
        dictgen::InsensitiveStr::Ascii("shol"),
        dictgen::InsensitiveStr::Ascii("sold"),
        dictgen::InsensitiveStr::Ascii("sshold"),
    ],
    values: &[
        &["threaded"],
        &["threaded"],
        &["threadsafe"],
        &["thread", "threat"],
        &["threshold"],
        &["thresholds"],
        &["threatening"],
        &["threaded", "threatened", "treated"],
        &["threatened"],
        &["threatened"],
        &["threatens"],
        &["threatens"],
        &["threatening"],
        &["treatment"],
        &["treatments"],
        &["threatening"],
        &["thread"],
        &["threaded"],
        &["threshold"],
        &["threading"],
        &["threads"],
        &["three"],
        &["therefor"],
        &["thereof"],
        &["threshold"],
        &["threshold"],
        &["there", "three"],
        &["therefore"],
        &["threshold"],
        &["thresholds"],
        &["threshold"],
        &["thresholds"],
        &["threshold"],
        &["threshold"],
        &["threshold"],
    ],
    range: 1..=7,
};

static WORD_THRA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_THRA_CHILDREN),
    value: None,
};

pub static WORD_THRA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("d")],
    values: &[&["thread"]],
    range: 1..=1,
};

static WORD_THQ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_THQ_CHILDREN),
    value: Some(&["the"]),
};

pub static WORD_THQ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[],
    values: &[],
    range: 0..=0,
};

static WORD_THO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_THO_CHILDREN),
    value: None,
};

pub static WORD_THO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ecracy"),
        dictgen::InsensitiveStr::Ascii("erem"),
        dictgen::InsensitiveStr::Ascii("eretical"),
        dictgen::InsensitiveStr::Ascii("eretically"),
        dictgen::InsensitiveStr::Ascii("eries"),
        dictgen::InsensitiveStr::Ascii("erist"),
        dictgen::InsensitiveStr::Ascii("erists"),
        dictgen::InsensitiveStr::Ascii("ese"),
        dictgen::InsensitiveStr::Ascii("mspon"),
        dictgen::InsensitiveStr::Ascii("nic"),
        dictgen::InsensitiveStr::Ascii("pmson"),
        dictgen::InsensitiveStr::Ascii("rasic"),
        dictgen::InsensitiveStr::Ascii("rats"),
        dictgen::InsensitiveStr::Ascii("rnes"),
        dictgen::InsensitiveStr::Ascii("roidal"),
        dictgen::InsensitiveStr::Ascii("roughty"),
        dictgen::InsensitiveStr::Ascii("roughy"),
        dictgen::InsensitiveStr::Ascii("rttling"),
        dictgen::InsensitiveStr::Ascii("rugh"),
        dictgen::InsensitiveStr::Ascii("rughout"),
        dictgen::InsensitiveStr::Ascii("ruim"),
        dictgen::InsensitiveStr::Ascii("ruoghly"),
        dictgen::InsensitiveStr::Ascii("rwn"),
        dictgen::InsensitiveStr::Ascii("s"),
        dictgen::InsensitiveStr::Ascii("ses"),
        dictgen::InsensitiveStr::Ascii("sse"),
        dictgen::InsensitiveStr::Ascii("uch"),
        dictgen::InsensitiveStr::Ascii("ughout"),
        dictgen::InsensitiveStr::Ascii("ughs"),
        dictgen::InsensitiveStr::Ascii("ugt"),
        dictgen::InsensitiveStr::Ascii("ugth"),
        dictgen::InsensitiveStr::Ascii("ugths"),
        dictgen::InsensitiveStr::Ascii("unsands"),
        dictgen::InsensitiveStr::Ascii("urgh"),
        dictgen::InsensitiveStr::Ascii("urghly"),
        dictgen::InsensitiveStr::Ascii("urogh"),
        dictgen::InsensitiveStr::Ascii("uroghly"),
        dictgen::InsensitiveStr::Ascii("urough"),
        dictgen::InsensitiveStr::Ascii("uroughly"),
        dictgen::InsensitiveStr::Ascii("w"),
        dictgen::InsensitiveStr::Ascii("wn"),
        dictgen::InsensitiveStr::Ascii("ws"),
    ],
    values: &[
        &["theocracy"],
        &["theorem"],
        &["theoretical"],
        &["theoretically"],
        &["theories"],
        &["theorist"],
        &["theorists"],
        &["these", "those"],
        &["thompson"],
        &["chthonic"],
        &["thompson"],
        &["thoracic"],
        &["throats"],
        &["thrones"],
        &["toroidal"],
        &["thoroughly"],
        &["thoroughly"],
        &["throttling"],
        &["through", "thorough"],
        &["throughout"],
        &["thorium"],
        &["thoroughly"],
        &["thrown", "thorn"],
        &["those", "this"],
        &["those"],
        &["those"],
        &["touch"],
        &["throughout"],
        &["thoughts"],
        &["thought", "though"],
        &["thought"],
        &["thoughts"],
        &["thousands"],
        &["thorough", "through"],
        &["thoroughly"],
        &["thorough"],
        &["thoroughly"],
        &["thorough"],
        &["thoroughly"],
        &["throw", "tow"],
        &["thrown", "town"],
        &["those", "throws", "tows"],
    ],
    range: 1..=10,
};

static WORD_THN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_THN_CHILDREN),
    value: Some(&["then"]),
};

pub static WORD_THN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("a"),
        dictgen::InsensitiveStr::Ascii("ak"),
        dictgen::InsensitiveStr::Ascii("aks"),
        dictgen::InsensitiveStr::Ascii("akyou"),
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("ig"),
        dictgen::InsensitiveStr::Ascii("igs"),
    ],
    values: &[
        &["than"],
        &["thank"],
        &["thanks"],
        &["thankyou"],
        &["then"],
        &["thing"],
        &["things"],
    ],
    range: 1..=5,
};

static WORD_THM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_THM_CHILDREN),
    value: None,
};

pub static WORD_THM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("e")],
    values: &[&["them"]],
    range: 1..=1,
};

static WORD_THJ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_THJ_CHILDREN),
    value: None,
};

pub static WORD_THJ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("ese"),
    ],
    values: &[&["the"], &["these"]],
    range: 1..=3,
};

static WORD_THI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_THI_CHILDREN),
    value: Some(&["the", "this"]),
};

pub static WORD_THI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aland"),
        dictgen::InsensitiveStr::Ascii("cking"),
        dictgen::InsensitiveStr::Ascii("cknes"),
        dictgen::InsensitiveStr::Ascii("d"),
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("er"),
        dictgen::InsensitiveStr::Ascii("estic"),
        dictgen::InsensitiveStr::Ascii("ests"),
        dictgen::InsensitiveStr::Ascii("ght"),
        dictgen::InsensitiveStr::Ascii("ghts"),
        dictgen::InsensitiveStr::Ascii("gn"),
        dictgen::InsensitiveStr::Ascii("gns"),
        dictgen::InsensitiveStr::Ascii("gny"),
        dictgen::InsensitiveStr::Ascii("gsn"),
        dictgen::InsensitiveStr::Ascii("k"),
        dictgen::InsensitiveStr::Ascii("king"),
        dictgen::InsensitiveStr::Ascii("kn"),
        dictgen::InsensitiveStr::Ascii("kness"),
        dictgen::InsensitiveStr::Ascii("knesses"),
        dictgen::InsensitiveStr::Ascii("kning"),
        dictgen::InsensitiveStr::Ascii("kns"),
        dictgen::InsensitiveStr::Ascii("ks"),
        dictgen::InsensitiveStr::Ascii("me"),
        dictgen::InsensitiveStr::Ascii("mngs"),
        dictgen::InsensitiveStr::Ascii("ngking"),
        dictgen::InsensitiveStr::Ascii("nigs"),
        dictgen::InsensitiveStr::Ascii("nkabel"),
        dictgen::InsensitiveStr::Ascii("nkg"),
        dictgen::InsensitiveStr::Ascii("nkgs"),
        dictgen::InsensitiveStr::Ascii("nn"),
        dictgen::InsensitiveStr::Ascii("rites"),
        dictgen::InsensitiveStr::Ascii("rldy"),
        dictgen::InsensitiveStr::Ascii("rlling"),
        dictgen::InsensitiveStr::Ascii("rs"),
        dictgen::InsensitiveStr::Ascii("rstay"),
        dictgen::InsensitiveStr::Ascii("rteeen"),
        dictgen::InsensitiveStr::Ascii("rten"),
        dictgen::InsensitiveStr::Ascii("rtsy"),
        dictgen::InsensitiveStr::Ascii("rtyth"),
        dictgen::InsensitiveStr::Ascii("se"),
        dictgen::InsensitiveStr::Ascii("sle"),
        dictgen::InsensitiveStr::Ascii("st"),
        dictgen::InsensitiveStr::Ascii("sy"),
        dictgen::InsensitiveStr::Ascii("unk"),
        dictgen::InsensitiveStr::Ascii("us"),
    ],
    values: &[
        &["thailand"],
        &["thinking", "thickening"],
        &["thickness", "thickens"],
        &["this"],
        &["the", "this"],
        &["their"],
        &["theistic"],
        &["theists"],
        &["tight", "thigh", "fight"],
        &["tights", "thighs", "fights"],
        &["thing"],
        &["things"],
        &["thingy"],
        &["things"],
        &["thick", "think"],
        &["thinking"],
        &["think"],
        &["thickness"],
        &["thicknesses"],
        &["thinking", "thickening"],
        &["thinks"],
        &["thinks"],
        &["time", "theme", "thyme", "thine"],
        &["things"],
        &["thinking"],
        &["things"],
        &["thinkable"],
        &["think", "thing", "things"],
        &["thinks", "things"],
        &["thin"],
        &["thirties"],
        &["thirdly"],
        &["thrilling"],
        &["third", "thirst"],
        &["thirsty"],
        &["thirteen"],
        &["thirteen"],
        &["thirsty"],
        &["thirtieth"],
        &["these", "this"],
        &["thistle"],
        &["this"],
        &["this"],
        &["think"],
        &["this"],
    ],
    range: 1..=7,
};

static WORD_THH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_THH_CHILDREN),
    value: None,
};

pub static WORD_THH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("ese"),
        dictgen::InsensitiveStr::Ascii("is"),
    ],
    values: &[&["the"], &["these"], &["this"]],
    range: 1..=3,
};

static WORD_THG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_THG_CHILDREN),
    value: None,
};

pub static WORD_THG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("at"),
        dictgen::InsensitiveStr::Ascii("e"),
    ],
    values: &[&["that"], &["the"]],
    range: 1..=2,
};

static WORD_THE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_THE_CHILDREN),
    value: None,
};

static WORD_THE_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_THEA_NODE),
    None,
    None,
    None,
    Some(&WORD_THEE_NODE),
    Some(&WORD_THEF_NODE),
    None,
    None,
    Some(&WORD_THEI_NODE),
    None,
    None,
    None,
    Some(&WORD_THEM_NODE),
    Some(&WORD_THEN_NODE),
    Some(&WORD_THEO_NODE),
    None,
    None,
    Some(&WORD_THER_NODE),
    Some(&WORD_THES_NODE),
    Some(&WORD_THET_NODE),
    None,
    Some(&WORD_THEV_NODE),
    None,
    Some(&WORD_THEX_NODE),
    Some(&WORD_THEY_NODE),
    None,
];

static WORD_THEY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_THEY_CHILDREN),
    value: None,
};

pub static WORD_THEY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("r"),
        dictgen::InsensitiveStr::Ascii("re"),
    ],
    values: &[&["their", "there"], &["their", "there"]],
    range: 1..=2,
};

static WORD_THEX_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_THEX_CHILDREN),
    value: Some(&["the", "then"]),
};

pub static WORD_THEX_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[],
    values: &[],
    range: 0..=0,
};

static WORD_THEV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_THEV_CHILDREN),
    value: Some(&["the"]),
};

pub static WORD_THEV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("es")],
    values: &[&["thieves"]],
    range: 2..=2,
};

static WORD_THET_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_THET_CHILDREN),
    value: None,
};

pub static WORD_THET_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ering"),
        dictgen::InsensitiveStr::Ascii("her"),
        dictgen::InsensitiveStr::Ascii("raedral"),
        dictgen::InsensitiveStr::Ascii("rahedron"),
    ],
    values: &[
        &["tethering"],
        &["tether", "whether"],
        &["tetrahedral"],
        &["tetrahedron"],
    ],
    range: 3..=8,
};

static WORD_THES_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_THES_CHILDREN),
    value: Some(&["this", "these", "the"]),
};

pub static WORD_THES_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("hold"),
        dictgen::InsensitiveStr::Ascii("holds"),
        dictgen::InsensitiveStr::Ascii("itic"),
        dictgen::InsensitiveStr::Ascii("its"),
        dictgen::InsensitiveStr::Ascii("s"),
        dictgen::InsensitiveStr::Ascii("t"),
    ],
    values: &[
        &["threshold"],
        &["thresholds"],
        &["theistic"],
        &["theists"],
        &["this", "these"],
        &["test"],
    ],
    range: 1..=5,
};

static WORD_THER_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_THER_CHILDREN),
    value: Some(&["there", "their", "the", "other"]),
};

static WORD_THER_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_THERA_NODE),
    Some(&WORD_THERB_NODE),
    None,
    None,
    Some(&WORD_THERE_NODE),
    Some(&WORD_THERF_NODE),
    None,
    None,
    Some(&WORD_THERI_NODE),
    None,
    None,
    None,
    Some(&WORD_THERM_NODE),
    Some(&WORD_THERN_NODE),
    Some(&WORD_THERO_NODE),
    None,
    None,
    None,
    Some(&WORD_THERS_NODE),
    None,
    None,
    None,
    Some(&WORD_THERW_NODE),
    None,
    None,
    None,
];

static WORD_THERW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_THERW_CHILDREN),
    value: None,
};

pub static WORD_THERW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ise")],
    values: &[&["otherwise"]],
    range: 3..=3,
};

static WORD_THERS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_THERS_CHILDREN),
    value: None,
};

pub static WORD_THERS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("hold"),
        dictgen::InsensitiveStr::Ascii("tat"),
    ],
    values: &[&["threshold"], &["thermostat"]],
    range: 3..=4,
};

static WORD_THERO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_THERO_CHILDREN),
    value: None,
};

pub static WORD_THERO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("em"),
        dictgen::InsensitiveStr::Ascii("etical"),
        dictgen::InsensitiveStr::Ascii("etically"),
        dictgen::InsensitiveStr::Ascii("fer"),
        dictgen::InsensitiveStr::Ascii("ies"),
        dictgen::InsensitiveStr::Ascii("ist"),
        dictgen::InsensitiveStr::Ascii("ists"),
        dictgen::InsensitiveStr::Ascii("mdynamics"),
        dictgen::InsensitiveStr::Ascii("mstat"),
        dictgen::InsensitiveStr::Ascii("ugh"),
    ],
    values: &[
        &["theorem"],
        &["theoretical"],
        &["theoretically"],
        &["therefore"],
        &["theories"],
        &["theorist"],
        &["theorists"],
        &["thermodynamics"],
        &["thermostat"],
        &["through", "thorough"],
    ],
    range: 2..=9,
};

static WORD_THERN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_THERN_CHILDREN),
    value: None,
};

pub static WORD_THERN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("odynamics")],
    values: &[&["thermodynamics"]],
    range: 9..=9,
};

static WORD_THERM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_THERM_CHILDREN),
    value: None,
};

pub static WORD_THERM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("astat"),
        dictgen::InsensitiveStr::Ascii("isor"),
        dictgen::InsensitiveStr::Ascii("isors"),
        dictgen::InsensitiveStr::Ascii("istat"),
        dictgen::InsensitiveStr::Ascii("odinamics"),
        dictgen::InsensitiveStr::Ascii("odyanmics"),
        dictgen::InsensitiveStr::Ascii("odymamics"),
        dictgen::InsensitiveStr::Ascii("odymanics"),
        dictgen::InsensitiveStr::Ascii("odynaics"),
        dictgen::InsensitiveStr::Ascii("odynamcis"),
        dictgen::InsensitiveStr::Ascii("odynamcs"),
        dictgen::InsensitiveStr::Ascii("odynanics"),
        dictgen::InsensitiveStr::Ascii("odynmaics"),
        dictgen::InsensitiveStr::Ascii("omenter"),
        dictgen::InsensitiveStr::Ascii("omether"),
        dictgen::InsensitiveStr::Ascii("ometor"),
        dictgen::InsensitiveStr::Ascii("ometre"),
        dictgen::InsensitiveStr::Ascii("omiter"),
        dictgen::InsensitiveStr::Ascii("omoter"),
        dictgen::InsensitiveStr::Ascii("omter"),
        dictgen::InsensitiveStr::Ascii("oneter"),
        dictgen::InsensitiveStr::Ascii("ostaat"),
        dictgen::InsensitiveStr::Ascii("ostast"),
        dictgen::InsensitiveStr::Ascii("ostasts"),
    ],
    values: &[
        &["thermostat"],
        &["thermistor"],
        &["thermistors"],
        &["thermostat"],
        &["thermodynamics"],
        &["thermodynamics"],
        &["thermodynamics"],
        &["thermodynamics"],
        &["thermodynamics"],
        &["thermodynamics"],
        &["thermodynamics"],
        &["thermodynamics"],
        &["thermodynamics"],
        &["thermometer"],
        &["thermometer"],
        &["thermometer"],
        &["thermometer"],
        &["thermometer"],
        &["thermometer"],
        &["thermometer"],
        &["thermometer"],
        &["thermostat"],
        &["thermostat"],
        &["thermostats"],
    ],
    range: 4..=9,
};

static WORD_THERI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_THERI_CHILDREN),
    value: Some(&["their", "there"]),
};

pub static WORD_THERI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("en"),
        dictgen::InsensitiveStr::Ascii("pists"),
    ],
    values: &[&["therein"], &["therapists"]],
    range: 2..=5,
};

static WORD_THERF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_THERF_CHILDREN),
    value: None,
};

pub static WORD_THERF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ore")],
    values: &[&["therefore"]],
    range: 3..=3,
};

static WORD_THERE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_THERE_CHILDREN),
    value: None,
};

pub static WORD_THERE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ads"),
        dictgen::InsensitiveStr::Ascii("aputic"),
        dictgen::InsensitiveStr::Ascii("fo"),
        dictgen::InsensitiveStr::Ascii("foer"),
        dictgen::InsensitiveStr::Ascii("four"),
        dictgen::InsensitiveStr::Ascii("ian"),
        dictgen::InsensitiveStr::Ascii("m"),
        dictgen::InsensitiveStr::Ascii("om"),
        dictgen::InsensitiveStr::Ascii("otical"),
        dictgen::InsensitiveStr::Ascii("otically"),
        dictgen::InsensitiveStr::Ascii("peutic"),
        dictgen::InsensitiveStr::Ascii("pists"),
        dictgen::InsensitiveStr::Ascii("rin"),
        dictgen::InsensitiveStr::Ascii("shold"),
        dictgen::InsensitiveStr::Ascii("sholds"),
    ],
    values: &[
        &["threads"],
        &["therapeutic"],
        &["thereof"],
        &["therefor"],
        &["therefor"],
        &["therein"],
        &["there", "theorem"],
        &["theorem"],
        &["theoretical"],
        &["theoretically"],
        &["therapeutic"],
        &["therapists"],
        &["therein"],
        &["threshold"],
        &["thresholds"],
    ],
    range: 1..=8,
};

static WORD_THERB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_THERB_CHILDREN),
    value: None,
};

pub static WORD_THERB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("y")],
    values: &[&["thereby"]],
    range: 1..=1,
};

static WORD_THERA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_THERA_CHILDREN),
    value: None,
};

pub static WORD_THERA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("fter"),
        dictgen::InsensitiveStr::Ascii("pautic"),
        dictgen::InsensitiveStr::Ascii("petic"),
        dictgen::InsensitiveStr::Ascii("peudic"),
        dictgen::InsensitiveStr::Ascii("peutisch"),
        dictgen::InsensitiveStr::Ascii("peutuc"),
        dictgen::InsensitiveStr::Ascii("phy"),
        dictgen::InsensitiveStr::Ascii("pudic"),
        dictgen::InsensitiveStr::Ascii("puetic"),
        dictgen::InsensitiveStr::Ascii("upetic"),
    ],
    values: &[
        &["thereafter"],
        &["therapeutic"],
        &["therapeutic"],
        &["therapeutic"],
        &["therapeutic"],
        &["therapeutic"],
        &["therapy"],
        &["therapeutic"],
        &["therapeutic"],
        &["therapeutic"],
    ],
    range: 3..=8,
};

static WORD_THEO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_THEO_CHILDREN),
    value: None,
};

pub static WORD_THEO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cracry"),
        dictgen::InsensitiveStr::Ascii("ligical"),
        dictgen::InsensitiveStr::Ascii("logia"),
        dictgen::InsensitiveStr::Ascii("logial"),
        dictgen::InsensitiveStr::Ascii("logicial"),
        dictgen::InsensitiveStr::Ascii("ratical"),
        dictgen::InsensitiveStr::Ascii("ratically"),
        dictgen::InsensitiveStr::Ascii("rectical"),
        dictgen::InsensitiveStr::Ascii("reticall"),
        dictgen::InsensitiveStr::Ascii("reticaly"),
        dictgen::InsensitiveStr::Ascii("reticly"),
        dictgen::InsensitiveStr::Ascii("rical"),
        dictgen::InsensitiveStr::Ascii("rically"),
        dictgen::InsensitiveStr::Ascii("ritical"),
        dictgen::InsensitiveStr::Ascii("ritically"),
        dictgen::InsensitiveStr::Ascii("rits"),
    ],
    values: &[
        &["theocracy"],
        &["theological"],
        &["theological"],
        &["theological"],
        &["theological"],
        &["theoretical"],
        &["theoretically"],
        &["theoretical"],
        &["theoretically"],
        &["theoretically"],
        &["theoretical"],
        &["theoretical"],
        &["theoretically"],
        &["theoretical"],
        &["theoretically"],
        &["theorist"],
    ],
    range: 4..=9,
};

static WORD_THEN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_THEN_CHILDREN),
    value: None,
};

pub static WORD_THEN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("n"),
    ],
    values: &[&["themes"], &["then"]],
    range: 1..=2,
};

static WORD_THEM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_THEM_CHILDREN),
    value: None,
};

pub static WORD_THEM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eselves"),
        dictgen::InsensitiveStr::Ascii("plate"),
        dictgen::InsensitiveStr::Ascii("sef"),
        dictgen::InsensitiveStr::Ascii("selces"),
        dictgen::InsensitiveStr::Ascii("selfe"),
        dictgen::InsensitiveStr::Ascii("selfes"),
        dictgen::InsensitiveStr::Ascii("selfs"),
        dictgen::InsensitiveStr::Ascii("selve"),
        dictgen::InsensitiveStr::Ascii("selvs"),
        dictgen::InsensitiveStr::Ascii("sevles"),
        dictgen::InsensitiveStr::Ascii("slef"),
        dictgen::InsensitiveStr::Ascii("sleves"),
        dictgen::InsensitiveStr::Ascii("slves"),
    ],
    values: &[
        &["themselves"],
        &["template"],
        &["themself"],
        &["themselves"],
        &["themselves", "themself"],
        &["themselves"],
        &["themselves"],
        &["themselves", "themself"],
        &["themselves"],
        &["themselves"],
        &["themself"],
        &["themselves"],
        &["themselves"],
    ],
    range: 3..=7,
};

static WORD_THEI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_THEI_CHILDREN),
    value: Some(&["their", "they"]),
};

pub static WORD_THEI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("f"),
        dictgen::InsensitiveStr::Ascii("fs"),
        dictgen::InsensitiveStr::Ascii("re"),
        dictgen::InsensitiveStr::Ascii("s"),
        dictgen::InsensitiveStr::Ascii("sitc"),
        dictgen::InsensitiveStr::Ascii("stc"),
        dictgen::InsensitiveStr::Ascii("v"),
        dictgen::InsensitiveStr::Ascii("ve"),
        dictgen::InsensitiveStr::Ascii("ves"),
    ],
    values: &[
        &["thief"],
        &["thieves"],
        &["their"],
        &["this", "thesis"],
        &["theistic"],
        &["theistic"],
        &["thief"],
        &["thief"],
        &["thieves"],
    ],
    range: 1..=4,
};

static WORD_THEF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_THEF_CHILDREN),
    value: None,
};

pub static WORD_THEF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ore")],
    values: &[&["therefore"]],
    range: 3..=3,
};

static WORD_THEE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_THEE_CHILDREN),
    value: None,
};

pub static WORD_THEE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("f"),
        dictgen::InsensitiveStr::Ascii("r"),
        dictgen::InsensitiveStr::Ascii("ry"),
        dictgen::InsensitiveStr::Ascii("se"),
    ],
    values: &[&["thief"], &["there"], &["theory"], &["these"]],
    range: 1..=2,
};

static WORD_THEA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_THEA_CHILDREN),
    value: None,
};

pub static WORD_THEA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("rd"),
        dictgen::InsensitiveStr::Ascii("rding"),
        dictgen::InsensitiveStr::Ascii("rds"),
        dictgen::InsensitiveStr::Ascii("red"),
        dictgen::InsensitiveStr::Ascii("rpy"),
        dictgen::InsensitiveStr::Ascii("ther"),
        dictgen::InsensitiveStr::Ascii("thre"),
        dictgen::InsensitiveStr::Ascii("ture"),
    ],
    values: &[
        &["thread"],
        &["threading"],
        &["threads"],
        &["threaded"],
        &["therapy"],
        &["theater"],
        &["theatre"],
        &["theatre"],
    ],
    range: 2..=5,
};

static WORD_THC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_THC_CHILDREN),
    value: None,
};

pub static WORD_THC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("k")],
    values: &[&["thick"]],
    range: 1..=1,
};

static WORD_THA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_THA_CHILDREN),
    value: Some(&["than", "that", "the"]),
};

pub static WORD_THA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ir"),
        dictgen::InsensitiveStr::Ascii("liand"),
        dictgen::InsensitiveStr::Ascii("nkfullly"),
        dictgen::InsensitiveStr::Ascii("nkfuly"),
        dictgen::InsensitiveStr::Ascii("nksgivng"),
        dictgen::InsensitiveStr::Ascii("nkyooou"),
        dictgen::InsensitiveStr::Ascii("nkyoou"),
        dictgen::InsensitiveStr::Ascii("nkyu"),
        dictgen::InsensitiveStr::Ascii("nn"),
        dictgen::InsensitiveStr::Ascii("nsk"),
        dictgen::InsensitiveStr::Ascii("nskgiving"),
        dictgen::InsensitiveStr::Ascii("nsparent"),
        dictgen::InsensitiveStr::Ascii("nt"),
        dictgen::InsensitiveStr::Ascii("r"),
        dictgen::InsensitiveStr::Ascii("re"),
        dictgen::InsensitiveStr::Ascii("st"),
        dictgen::InsensitiveStr::Ascii("tn"),
        dictgen::InsensitiveStr::Ascii("ught"),
        dictgen::InsensitiveStr::Ascii("ughts"),
        dictgen::InsensitiveStr::Ascii("y"),
    ],
    values: &[
        &["their", "there"],
        &["thailand"],
        &["thankfully"],
        &["thankfully"],
        &["thanksgiving"],
        &["thankyou"],
        &["thankyou"],
        &["thankyou"],
        &["than", "thank"],
        &["thanks"],
        &["thanksgiving"],
        &["transparent"],
        &["than"],
        &["than", "that"],
        &["there"],
        &["that"],
        &["that", "than"],
        &["taught", "thought"],
        &["thoughts"],
        &["they", "that"],
    ],
    range: 1..=9,
};

static WORD_TG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TG_CHILDREN),
    value: None,
};

pub static WORD_TG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("he")],
    values: &[&["the"]],
    range: 2..=2,
};

static WORD_TE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_TE_CHILDREN),
    value: None,
};

static WORD_TE_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_TEA_NODE),
    None,
    Some(&WORD_TEC_NODE),
    Some(&WORD_TED_NODE),
    Some(&WORD_TEE_NODE),
    Some(&WORD_TEF_NODE),
    None,
    Some(&WORD_TEH_NODE),
    None,
    None,
    Some(&WORD_TEK_NODE),
    Some(&WORD_TEL_NODE),
    Some(&WORD_TEM_NODE),
    Some(&WORD_TEN_NODE),
    None,
    Some(&WORD_TEP_NODE),
    Some(&WORD_TEQ_NODE),
    Some(&WORD_TER_NODE),
    Some(&WORD_TES_NODE),
    Some(&WORD_TET_NODE),
    Some(&WORD_TEU_NODE),
    None,
    None,
    Some(&WORD_TEX_NODE),
    Some(&WORD_TEY_NODE),
    None,
];

static WORD_TEY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TEY_CHILDREN),
    value: Some(&["they"]),
};

pub static WORD_TEY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[],
    values: &[],
    range: 0..=0,
};

static WORD_TEX_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TEX_CHILDREN),
    value: None,
};

pub static WORD_TEX_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("chnically"),
        dictgen::InsensitiveStr::Ascii("line"),
        dictgen::InsensitiveStr::Ascii("tfrme"),
        dictgen::InsensitiveStr::Ascii("turers"),
        dictgen::InsensitiveStr::Ascii("ual"),
        dictgen::InsensitiveStr::Ascii("ually"),
        dictgen::InsensitiveStr::Ascii("ure"),
        dictgen::InsensitiveStr::Ascii("ured"),
        dictgen::InsensitiveStr::Ascii("ures"),
        dictgen::InsensitiveStr::Ascii("utres"),
        dictgen::InsensitiveStr::Ascii("xt"),
    ],
    values: &[
        &["technically"],
        &["textline"],
        &["textframe"],
        &["textures"],
        &["textual"],
        &["textually"],
        &["texture"],
        &["textured"],
        &["textures"],
        &["textures"],
        &["text"],
    ],
    range: 2..=9,
};

static WORD_TEU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TEU_CHILDREN),
    value: None,
};

pub static WORD_TEU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("sday"),
        dictgen::InsensitiveStr::Ascii("sdays"),
    ],
    values: &[&["tuesday"], &["tuesdays"]],
    range: 4..=5,
};

static WORD_TET_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TET_CHILDREN),
    value: None,
};

pub static WORD_TET_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("rahedora"),
        dictgen::InsensitiveStr::Ascii("rahedoren"),
        dictgen::InsensitiveStr::Ascii("rahedorens"),
        dictgen::InsensitiveStr::Ascii("rahedran"),
        dictgen::InsensitiveStr::Ascii("rahedrans"),
        dictgen::InsensitiveStr::Ascii("ry"),
        dictgen::InsensitiveStr::Ascii("ss"),
        dictgen::InsensitiveStr::Ascii("xture"),
    ],
    values: &[
        &["tetrahedra"],
        &["tetrahedron"],
        &["tetrahedrons"],
        &["tetrahedron"],
        &["tetrahedrons"],
        &["retry"],
        &["tests"],
        &["texture"],
    ],
    range: 2..=10,
};

static WORD_TES_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TES_CHILDREN),
    value: None,
};

pub static WORD_TES_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("case"),
        dictgen::InsensitiveStr::Ascii("cases"),
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("ellate"),
        dictgen::InsensitiveStr::Ascii("ellated"),
        dictgen::InsensitiveStr::Ascii("ellation"),
        dictgen::InsensitiveStr::Ascii("ellator"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("itcle"),
        dictgen::InsensitiveStr::Ascii("itcles"),
        dictgen::InsensitiveStr::Ascii("ited"),
        dictgen::InsensitiveStr::Ascii("itfy"),
        dictgen::InsensitiveStr::Ascii("itmony"),
        dictgen::InsensitiveStr::Ascii("sealte"),
        dictgen::InsensitiveStr::Ascii("sealted"),
        dictgen::InsensitiveStr::Ascii("selatad"),
        dictgen::InsensitiveStr::Ascii("selate"),
        dictgen::InsensitiveStr::Ascii("selated"),
        dictgen::InsensitiveStr::Ascii("selation"),
        dictgen::InsensitiveStr::Ascii("selator"),
        dictgen::InsensitiveStr::Ascii("sleate"),
        dictgen::InsensitiveStr::Ascii("sleated"),
        dictgen::InsensitiveStr::Ascii("sleating"),
        dictgen::InsensitiveStr::Ascii("sleator"),
        dictgen::InsensitiveStr::Ascii("tasterone"),
        dictgen::InsensitiveStr::Ascii("teing"),
        dictgen::InsensitiveStr::Ascii("testorone"),
        dictgen::InsensitiveStr::Ascii("tice"),
        dictgen::InsensitiveStr::Ascii("ticel"),
        dictgen::InsensitiveStr::Ascii("ticels"),
        dictgen::InsensitiveStr::Ascii("ticlees"),
        dictgen::InsensitiveStr::Ascii("ticlies"),
        dictgen::InsensitiveStr::Ascii("ticlular"),
        dictgen::InsensitiveStr::Ascii("tifiy"),
        dictgen::InsensitiveStr::Ascii("tiing"),
        dictgen::InsensitiveStr::Ascii("timoney"),
        dictgen::InsensitiveStr::Ascii("tin"),
        dictgen::InsensitiveStr::Ascii("tng"),
        dictgen::InsensitiveStr::Ascii("tomony"),
        dictgen::InsensitiveStr::Ascii("tsdata"),
        dictgen::InsensitiveStr::Ascii("tsing"),
    ],
    values: &[
        &["testcase"],
        &["testcases"],
        &["these", "tease", "terse"],
        &["used", "teased", "tested"],
        &["tessellate"],
        &["tessellated"],
        &["tessellation"],
        &["tessellator"],
        &["testing"],
        &["testicle"],
        &["testicles"],
        &["tested"],
        &["testify"],
        &["testimony"],
        &["tessellate"],
        &["tessellated"],
        &["tessellated"],
        &["tessellate"],
        &["tessellated"],
        &["tessellation"],
        &["tessellator"],
        &["tessellate"],
        &["tessellated"],
        &["tessellating"],
        &["tessellator"],
        &["testosterone"],
        &["testing"],
        &["testosterone"],
        &["testicle"],
        &["testicle"],
        &["testicles"],
        &["testicles"],
        &["testicle"],
        &["testicular"],
        &["testify"],
        &["testing"],
        &["testimony"],
        &["testing"],
        &["testing"],
        &["testimony"],
        &["testdata"],
        &["testing"],
    ],
    range: 1..=9,
};

static WORD_TER_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_TER_CHILDREN),
    value: None,
};

static WORD_TER_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_TERA_NODE),
    None,
    None,
    None,
    Some(&WORD_TERE_NODE),
    Some(&WORD_TERF_NODE),
    None,
    None,
    Some(&WORD_TERI_NODE),
    None,
    None,
    None,
    Some(&WORD_TERM_NODE),
    Some(&WORD_TERN_NODE),
    Some(&WORD_TERO_NODE),
    None,
    None,
    Some(&WORD_TERR_NODE),
    None,
    None,
    Some(&WORD_TERU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_TERU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TERU_CHILDREN),
    value: None,
};

pub static WORD_TERU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("rn"),
        dictgen::InsensitiveStr::Ascii("rns"),
    ],
    values: &[&["return"], &["returns"]],
    range: 2..=3,
};

static WORD_TERR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TERR_CHILDREN),
    value: None,
};

pub static WORD_TERR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("able"),
        dictgen::InsensitiveStr::Ascii("abyte"),
        dictgen::InsensitiveStr::Ascii("atorial"),
        dictgen::InsensitiveStr::Ascii("atories"),
        dictgen::InsensitiveStr::Ascii("erists"),
        dictgen::InsensitiveStr::Ascii("estial"),
        dictgen::InsensitiveStr::Ascii("etorial"),
        dictgen::InsensitiveStr::Ascii("etories"),
        dictgen::InsensitiveStr::Ascii("form"),
        dictgen::InsensitiveStr::Ascii("formed"),
        dictgen::InsensitiveStr::Ascii("forming"),
        dictgen::InsensitiveStr::Ascii("forms"),
        dictgen::InsensitiveStr::Ascii("iblely"),
        dictgen::InsensitiveStr::Ascii("ibley"),
        dictgen::InsensitiveStr::Ascii("iblly"),
        dictgen::InsensitiveStr::Ascii("iffic"),
        dictgen::InsensitiveStr::Ascii("iories"),
        dictgen::InsensitiveStr::Ascii("iory"),
        dictgen::InsensitiveStr::Ascii("irorial"),
        dictgen::InsensitiveStr::Ascii("irories"),
        dictgen::InsensitiveStr::Ascii("iroties"),
        dictgen::InsensitiveStr::Ascii("iroty"),
        dictgen::InsensitiveStr::Ascii("istrial"),
        dictgen::InsensitiveStr::Ascii("itoires"),
        dictgen::InsensitiveStr::Ascii("itoral"),
        dictgen::InsensitiveStr::Ascii("itores"),
        dictgen::InsensitiveStr::Ascii("itoriella"),
        dictgen::InsensitiveStr::Ascii("itoris"),
        dictgen::InsensitiveStr::Ascii("itorist"),
        dictgen::InsensitiveStr::Ascii("itority"),
        dictgen::InsensitiveStr::Ascii("itorrial"),
        dictgen::InsensitiveStr::Ascii("itorries"),
        dictgen::InsensitiveStr::Ascii("itorry"),
        dictgen::InsensitiveStr::Ascii("itoy"),
        dictgen::InsensitiveStr::Ascii("oist"),
        dictgen::InsensitiveStr::Ascii("orisim"),
        dictgen::InsensitiveStr::Ascii("oristas"),
        dictgen::InsensitiveStr::Ascii("oristes"),
        dictgen::InsensitiveStr::Ascii("orities"),
        dictgen::InsensitiveStr::Ascii("orits"),
        dictgen::InsensitiveStr::Ascii("orsim"),
        dictgen::InsensitiveStr::Ascii("orsits"),
        dictgen::InsensitiveStr::Ascii("otorial"),
        dictgen::InsensitiveStr::Ascii("otories"),
        dictgen::InsensitiveStr::Ascii("urists"),
    ],
    values: &[
        &["terrible"],
        &["terabyte"],
        &["territorial"],
        &["territories"],
        &["terrorists"],
        &["terrestrial"],
        &["territorial"],
        &["territories"],
        &["terraform"],
        &["terraformed"],
        &["terraforming"],
        &["terraforms"],
        &["terribly"],
        &["terribly"],
        &["terribly"],
        &["terrific"],
        &["territories"],
        &["territory"],
        &["territorial"],
        &["territories"],
        &["territories"],
        &["territory"],
        &["territorial"],
        &["territories"],
        &["territorial"],
        &["territories"],
        &["territorial"],
        &["territories"],
        &["terrorist"],
        &["territory"],
        &["territorial"],
        &["territories"],
        &["territory"],
        &["territory"],
        &["terrorist"],
        &["terrorism"],
        &["terrorists"],
        &["terrorists"],
        &["territories"],
        &["terrorist"],
        &["terrorism"],
        &["terrorists"],
        &["territorial"],
        &["territories"],
        &["terrorists"],
    ],
    range: 4..=9,
};

static WORD_TERO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TERO_CHILDREN),
    value: None,
};

pub static WORD_TERO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("rrism"),
        dictgen::InsensitiveStr::Ascii("rrist"),
        dictgen::InsensitiveStr::Ascii("rrists"),
    ],
    values: &[&["terrorism"], &["terrorist"], &["terrorists"]],
    range: 5..=6,
};

static WORD_TERN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TERN_CHILDREN),
    value: None,
};

pub static WORD_TERN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ament"),
        dictgen::InsensitiveStr::Ascii("imate"),
        dictgen::InsensitiveStr::Ascii("inal"),
        dictgen::InsensitiveStr::Ascii("inals"),
    ],
    values: &[
        &["tournament"],
        &["terminate"],
        &["terminal"],
        &["terminals"],
    ],
    range: 4..=5,
};

static WORD_TERM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TERM_CHILDREN),
    value: None,
};

pub static WORD_TERM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("anator"),
        dictgen::InsensitiveStr::Ascii("anology"),
        dictgen::InsensitiveStr::Ascii("endous"),
        dictgen::InsensitiveStr::Ascii("endously"),
        dictgen::InsensitiveStr::Ascii("ial"),
        dictgen::InsensitiveStr::Ascii("ials"),
        dictgen::InsensitiveStr::Ascii("ianl"),
        dictgen::InsensitiveStr::Ascii("ianls"),
        dictgen::InsensitiveStr::Ascii("iante"),
        dictgen::InsensitiveStr::Ascii("ianted"),
        dictgen::InsensitiveStr::Ascii("iantor"),
        dictgen::InsensitiveStr::Ascii("igator"),
        dictgen::InsensitiveStr::Ascii("imal"),
        dictgen::InsensitiveStr::Ascii("imals"),
        dictgen::InsensitiveStr::Ascii("inacion"),
        dictgen::InsensitiveStr::Ascii("inaison"),
        dictgen::InsensitiveStr::Ascii("inales"),
        dictgen::InsensitiveStr::Ascii("inalis"),
        dictgen::InsensitiveStr::Ascii("inalogy"),
        dictgen::InsensitiveStr::Ascii("inarla"),
        dictgen::InsensitiveStr::Ascii("inarlo"),
        dictgen::InsensitiveStr::Ascii("inaron"),
        dictgen::InsensitiveStr::Ascii("inatd"),
        dictgen::InsensitiveStr::Ascii("inater"),
        dictgen::InsensitiveStr::Ascii("inaters"),
        dictgen::InsensitiveStr::Ascii("inatior"),
        dictgen::InsensitiveStr::Ascii("inato"),
        dictgen::InsensitiveStr::Ascii("inatorn"),
        dictgen::InsensitiveStr::Ascii("inats"),
        dictgen::InsensitiveStr::Ascii("indate"),
        dictgen::InsensitiveStr::Ascii("ine"),
        dictgen::InsensitiveStr::Ascii("ined"),
        dictgen::InsensitiveStr::Ascii("iniator"),
        dictgen::InsensitiveStr::Ascii("inilogy"),
        dictgen::InsensitiveStr::Ascii("inolgy"),
        dictgen::InsensitiveStr::Ascii("inoligy"),
        dictgen::InsensitiveStr::Ascii("inte"),
        dictgen::InsensitiveStr::Ascii("intor"),
        dictgen::InsensitiveStr::Ascii("niate"),
        dictgen::InsensitiveStr::Ascii("niated"),
        dictgen::InsensitiveStr::Ascii("niates"),
        dictgen::InsensitiveStr::Ascii("niating"),
        dictgen::InsensitiveStr::Ascii("niation"),
        dictgen::InsensitiveStr::Ascii("niations"),
        dictgen::InsensitiveStr::Ascii("niator"),
        dictgen::InsensitiveStr::Ascii("niators"),
        dictgen::InsensitiveStr::Ascii("o"),
        dictgen::InsensitiveStr::Ascii("onology"),
        dictgen::InsensitiveStr::Ascii("ostat"),
        dictgen::InsensitiveStr::Ascii("peratue"),
        dictgen::InsensitiveStr::Ascii("peratues"),
        dictgen::InsensitiveStr::Ascii("perature"),
        dictgen::InsensitiveStr::Ascii("peratures"),
        dictgen::InsensitiveStr::Ascii("plate"),
        dictgen::InsensitiveStr::Ascii("plated"),
        dictgen::InsensitiveStr::Ascii("plates"),
        dictgen::InsensitiveStr::Ascii("poral"),
        dictgen::InsensitiveStr::Ascii("poraries"),
        dictgen::InsensitiveStr::Ascii("porarily"),
        dictgen::InsensitiveStr::Ascii("porary"),
    ],
    values: &[
        &["terminator"],
        &["terminology"],
        &["tremendous"],
        &["tremendously"],
        &["terminal"],
        &["terminals"],
        &["terminal"],
        &["terminals"],
        &["terminate"],
        &["terminated"],
        &["terminator"],
        &["terminator"],
        &["terminal"],
        &["terminals"],
        &["termination"],
        &["termination"],
        &["terminals"],
        &["terminals"],
        &["terminology"],
        &["terminal"],
        &["terminal"],
        &["terminator"],
        &["terminated"],
        &["terminator"],
        &["terminators"],
        &["terminator"],
        &["termination"],
        &["termination"],
        &["terminates"],
        &["terminate"],
        &["determine"],
        &["terminated"],
        &["terminator"],
        &["terminology"],
        &["terminology"],
        &["terminology"],
        &["terminate"],
        &["terminator"],
        &["terminate"],
        &["terminated"],
        &["terminates"],
        &["terminating"],
        &["termination"],
        &["terminations"],
        &["terminator"],
        &["terminators"],
        &["thermo"],
        &["terminology"],
        &["thermostat"],
        &["temperature"],
        &["temperatures"],
        &["temperature"],
        &["temperatures"],
        &["template"],
        &["templated"],
        &["templates"],
        &["temporal"],
        &["temporaries"],
        &["temporarily"],
        &["temporary"],
    ],
    range: 1..=9,
};

static WORD_TERI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TERI_CHILDREN),
    value: None,
};

pub static WORD_TERI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("dactyl"),
        dictgen::InsensitiveStr::Ascii("fic"),
        dictgen::InsensitiveStr::Ascii("mnate"),
        dictgen::InsensitiveStr::Ascii("tory"),
    ],
    values: &[
        &["pterodactyl"],
        &["terrific"],
        &["terminate"],
        &["territory"],
    ],
    range: 3..=6,
};

static WORD_TERF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TERF_CHILDREN),
    value: None,
};

pub static WORD_TERF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("form"),
        dictgen::InsensitiveStr::Ascii("formed"),
        dictgen::InsensitiveStr::Ascii("forming"),
        dictgen::InsensitiveStr::Ascii("forms"),
    ],
    values: &[
        &["terraform"],
        &["terraformed"],
        &["terraforming"],
        &["terraforms"],
    ],
    range: 4..=7,
};

static WORD_TERE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TERE_CHILDREN),
    value: Some(&["there", "here"]),
};

pub static WORD_TERE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[],
    values: &[],
    range: 0..=0,
};

static WORD_TERA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TERA_CHILDREN),
    value: None,
};

pub static WORD_TERA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("form"),
        dictgen::InsensitiveStr::Ascii("formed"),
        dictgen::InsensitiveStr::Ascii("forming"),
        dictgen::InsensitiveStr::Ascii("forms"),
    ],
    values: &[
        &["terraform"],
        &["terraformed"],
        &["terraforming"],
        &["terraforms"],
    ],
    range: 4..=7,
};

static WORD_TEQ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TEQ_CHILDREN),
    value: None,
};

pub static WORD_TEQ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("uilia"),
        dictgen::InsensitiveStr::Ascii("ulia"),
    ],
    values: &[&["tequila"], &["tequila"]],
    range: 4..=5,
};

static WORD_TEP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TEP_CHILDREN),
    value: None,
};

pub static WORD_TEP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("lmate"),
        dictgen::InsensitiveStr::Ascii("lmated"),
        dictgen::InsensitiveStr::Ascii("lmates"),
        dictgen::InsensitiveStr::Ascii("morarily"),
    ],
    values: &[
        &["template"],
        &["templated"],
        &["templates"],
        &["temporarily"],
    ],
    range: 5..=8,
};

static WORD_TEN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TEN_CHILDREN),
    value: None,
};

pub static WORD_TEN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("acitiy"),
        dictgen::InsensitiveStr::Ascii("acle"),
        dictgen::InsensitiveStr::Ascii("acles"),
        dictgen::InsensitiveStr::Ascii("actiy"),
        dictgen::InsensitiveStr::Ascii("anet"),
        dictgen::InsensitiveStr::Ascii("anets"),
        dictgen::InsensitiveStr::Ascii("atious"),
        dictgen::InsensitiveStr::Ascii("atiously"),
        dictgen::InsensitiveStr::Ascii("ative"),
        dictgen::InsensitiveStr::Ascii("atively"),
        dictgen::InsensitiveStr::Ascii("caity"),
        dictgen::InsensitiveStr::Ascii("dacy"),
        dictgen::InsensitiveStr::Ascii("dancies"),
        dictgen::InsensitiveStr::Ascii("dancy"),
        dictgen::InsensitiveStr::Ascii("dence"),
        dictgen::InsensitiveStr::Ascii("dencias"),
        dictgen::InsensitiveStr::Ascii("dencije"),
        dictgen::InsensitiveStr::Ascii("densies"),
        dictgen::InsensitiveStr::Ascii("dincies"),
        dictgen::InsensitiveStr::Ascii("gentially"),
        dictgen::InsensitiveStr::Ascii("siones"),
        dictgen::InsensitiveStr::Ascii("sionors"),
        dictgen::InsensitiveStr::Ascii("tacel"),
        dictgen::InsensitiveStr::Ascii("tacels"),
        dictgen::InsensitiveStr::Ascii("tacls"),
        dictgen::InsensitiveStr::Ascii("tacreul"),
        dictgen::InsensitiveStr::Ascii("tacuel"),
        dictgen::InsensitiveStr::Ascii("taive"),
        dictgen::InsensitiveStr::Ascii("taively"),
        dictgen::InsensitiveStr::Ascii("talce"),
        dictgen::InsensitiveStr::Ascii("talces"),
        dictgen::InsensitiveStr::Ascii("tion"),
    ],
    values: &[
        &["tenacity"],
        &["tentacle"],
        &["tentacles"],
        &["tenacity"],
        &["tenant"],
        &["tenants"],
        &["tenacious"],
        &["tenaciously"],
        &["tentative"],
        &["tentatively"],
        &["tenacity"],
        &["tendency"],
        &["tendencies"],
        &["tendency"],
        &["tendencies"],
        &["tendencies"],
        &["tendencies"],
        &["tendencies"],
        &["tendencies"],
        &["tangentially"],
        &["tensions"],
        &["tensions"],
        &["tentacle"],
        &["tentacles"],
        &["tentacles"],
        &["tentacle"],
        &["tentacle"],
        &["tentative"],
        &["tentatively"],
        &["tentacle"],
        &["tentacles"],
        &["tension"],
    ],
    range: 4..=9,
};

static WORD_TEM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_TEM_CHILDREN),
    value: None,
};

static WORD_TEM_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_TEMA_NODE),
    None,
    None,
    None,
    Some(&WORD_TEME_NODE),
    None,
    None,
    None,
    Some(&WORD_TEMI_NODE),
    None,
    None,
    Some(&WORD_TEML_NODE),
    Some(&WORD_TEMM_NODE),
    None,
    Some(&WORD_TEMO_NODE),
    Some(&WORD_TEMP_NODE),
    None,
    Some(&WORD_TEMR_NODE),
    Some(&WORD_TEMS_NODE),
    Some(&WORD_TEMT_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_TEMT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TEMT_CHILDREN),
    value: None,
};

pub static WORD_TEMT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ation")],
    values: &[&["temptation"]],
    range: 5..=5,
};

static WORD_TEMS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TEMS_CHILDREN),
    value: None,
};

pub static WORD_TEMS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("elves")],
    values: &[&["themselves"]],
    range: 5..=5,
};

static WORD_TEMR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TEMR_CHILDREN),
    value: Some(&["term"]),
};

pub static WORD_TEMR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("inal")],
    values: &[&["terminal"]],
    range: 4..=4,
};

static WORD_TEMP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_TEMP_CHILDREN),
    value: None,
};

static WORD_TEMP_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_TEMPA_NODE),
    None,
    None,
    Some(&WORD_TEMPD_NODE),
    Some(&WORD_TEMPE_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_TEMPL_NODE),
    None,
    None,
    Some(&WORD_TEMPO_NODE),
    None,
    None,
    Some(&WORD_TEMPR_NODE),
    Some(&WORD_TEMPS_NODE),
    Some(&WORD_TEMPT_NODE),
    Some(&WORD_TEMPU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_TEMPU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TEMPU_CHILDREN),
    value: None,
};

pub static WORD_TEMPU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("rature"),
        dictgen::InsensitiveStr::Ascii("ratures"),
        dictgen::InsensitiveStr::Ascii("rture"),
    ],
    values: &[&["temperature"], &["temperatures"], &["temperature"]],
    range: 5..=7,
};

static WORD_TEMPT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TEMPT_CHILDREN),
    value: None,
};

pub static WORD_TEMPT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("atation"),
        dictgen::InsensitiveStr::Ascii("ating"),
        dictgen::InsensitiveStr::Ascii("etion"),
    ],
    values: &[&["temptation"], &["temptation"], &["temptation"]],
    range: 5..=7,
};

static WORD_TEMPS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TEMPS_CHILDREN),
    value: None,
};

pub static WORD_TEMPS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("et")],
    values: &[&["tempest"]],
    range: 2..=2,
};

static WORD_TEMPR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TEMPR_CHILDREN),
    value: None,
};

pub static WORD_TEMPR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aaily"),
        dictgen::InsensitiveStr::Ascii("aal"),
        dictgen::InsensitiveStr::Ascii("aarily"),
        dictgen::InsensitiveStr::Ascii("aarly"),
        dictgen::InsensitiveStr::Ascii("aary"),
        dictgen::InsensitiveStr::Ascii("aay"),
        dictgen::InsensitiveStr::Ascii("aily"),
        dictgen::InsensitiveStr::Ascii("al"),
        dictgen::InsensitiveStr::Ascii("ament"),
        dictgen::InsensitiveStr::Ascii("amental"),
        dictgen::InsensitiveStr::Ascii("araily"),
        dictgen::InsensitiveStr::Ascii("aral"),
        dictgen::InsensitiveStr::Ascii("araly"),
        dictgen::InsensitiveStr::Ascii("ararily"),
        dictgen::InsensitiveStr::Ascii("ararly"),
        dictgen::InsensitiveStr::Ascii("arary"),
        dictgen::InsensitiveStr::Ascii("aray"),
        dictgen::InsensitiveStr::Ascii("arily"),
        dictgen::InsensitiveStr::Ascii("ary"),
        dictgen::InsensitiveStr::Ascii("ature"),
        dictgen::InsensitiveStr::Ascii("atures"),
        dictgen::InsensitiveStr::Ascii("ay"),
        dictgen::InsensitiveStr::Ascii("eature"),
        dictgen::InsensitiveStr::Ascii("eatures"),
        dictgen::InsensitiveStr::Ascii("ement"),
        dictgen::InsensitiveStr::Ascii("emental"),
        dictgen::InsensitiveStr::Ascii("oaily"),
        dictgen::InsensitiveStr::Ascii("oal"),
        dictgen::InsensitiveStr::Ascii("oarily"),
        dictgen::InsensitiveStr::Ascii("oarly"),
        dictgen::InsensitiveStr::Ascii("oary"),
        dictgen::InsensitiveStr::Ascii("oay"),
        dictgen::InsensitiveStr::Ascii("oily"),
        dictgen::InsensitiveStr::Ascii("ol"),
        dictgen::InsensitiveStr::Ascii("oment"),
        dictgen::InsensitiveStr::Ascii("omental"),
        dictgen::InsensitiveStr::Ascii("oraily"),
        dictgen::InsensitiveStr::Ascii("oral"),
        dictgen::InsensitiveStr::Ascii("oraly"),
        dictgen::InsensitiveStr::Ascii("orarily"),
        dictgen::InsensitiveStr::Ascii("orarly"),
        dictgen::InsensitiveStr::Ascii("orary"),
        dictgen::InsensitiveStr::Ascii("oray"),
        dictgen::InsensitiveStr::Ascii("orily"),
        dictgen::InsensitiveStr::Ascii("ory"),
        dictgen::InsensitiveStr::Ascii("oy"),
    ],
    values: &[
        &["temporarily"],
        &["temporal"],
        &["temporarily"],
        &["temporarily"],
        &["temporary"],
        &["temporary"],
        &["temporarily"],
        &["temporal"],
        &["temperament"],
        &["temperamental"],
        &["temporarily"],
        &["temporal"],
        &["temporarily", "temporally"],
        &["temporarily"],
        &["temporarily"],
        &["temporary"],
        &["temporary"],
        &["temporarily"],
        &["temporary", "temporarily"],
        &["temperature"],
        &["temperatures"],
        &["temporary"],
        &["temperature"],
        &["temperatures"],
        &["temperament"],
        &["temperamental"],
        &["temporarily"],
        &["temporal"],
        &["temporarily"],
        &["temporarily"],
        &["temporary"],
        &["temporary"],
        &["temporarily", "temporally"],
        &["temporal"],
        &["temperament"],
        &["temperamental"],
        &["temporarily"],
        &["temporal"],
        &["temporarily"],
        &["temporarily"],
        &["temporarily"],
        &["temporary"],
        &["temporary"],
        &["temporarily"],
        &["temporary"],
        &["temporary"],
    ],
    range: 2..=7,
};

static WORD_TEMPO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TEMPO_CHILDREN),
    value: None,
};

pub static WORD_TEMPO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aray"),
        dictgen::InsensitiveStr::Ascii("pary"),
        dictgen::InsensitiveStr::Ascii("raere"),
        dictgen::InsensitiveStr::Ascii("rafy"),
        dictgen::InsensitiveStr::Ascii("raily"),
        dictgen::InsensitiveStr::Ascii("rairly"),
        dictgen::InsensitiveStr::Ascii("rali"),
        dictgen::InsensitiveStr::Ascii("ralily"),
        dictgen::InsensitiveStr::Ascii("raly"),
        dictgen::InsensitiveStr::Ascii("raraly"),
        dictgen::InsensitiveStr::Ascii("rarely"),
        dictgen::InsensitiveStr::Ascii("rarilly"),
        dictgen::InsensitiveStr::Ascii("rarilty"),
        dictgen::InsensitiveStr::Ascii("rarilu"),
        dictgen::InsensitiveStr::Ascii("rarirly"),
        dictgen::InsensitiveStr::Ascii("rarity"),
        dictgen::InsensitiveStr::Ascii("rarly"),
        dictgen::InsensitiveStr::Ascii("ray"),
        dictgen::InsensitiveStr::Ascii("ries"),
        dictgen::InsensitiveStr::Ascii("rily"),
        dictgen::InsensitiveStr::Ascii("roraries"),
        dictgen::InsensitiveStr::Ascii("rorarily"),
        dictgen::InsensitiveStr::Ascii("rorary"),
        dictgen::InsensitiveStr::Ascii("rories"),
        dictgen::InsensitiveStr::Ascii("rorily"),
        dictgen::InsensitiveStr::Ascii("rory"),
        dictgen::InsensitiveStr::Ascii("rraies"),
        dictgen::InsensitiveStr::Ascii("rraily"),
        dictgen::InsensitiveStr::Ascii("rraries"),
        dictgen::InsensitiveStr::Ascii("rrarily"),
        dictgen::InsensitiveStr::Ascii("rrary"),
        dictgen::InsensitiveStr::Ascii("rray"),
        dictgen::InsensitiveStr::Ascii("rries"),
        dictgen::InsensitiveStr::Ascii("rrily"),
        dictgen::InsensitiveStr::Ascii("rry"),
        dictgen::InsensitiveStr::Ascii("rtal"),
        dictgen::InsensitiveStr::Ascii("rtaries"),
        dictgen::InsensitiveStr::Ascii("rtarily"),
        dictgen::InsensitiveStr::Ascii("rtary"),
        dictgen::InsensitiveStr::Ascii("ry"),
        dictgen::InsensitiveStr::Ascii("ryries"),
        dictgen::InsensitiveStr::Ascii("ryrily"),
        dictgen::InsensitiveStr::Ascii("ryry"),
    ],
    values: &[
        &["temporary"],
        &["temporary"],
        &["temporary"],
        &["temporary"],
        &["temporarily"],
        &["temporarily"],
        &["temporarily"],
        &["temporarily"],
        &["temporary", "temporarily", "temporally"],
        &["temporarily"],
        &["temporarily"],
        &["temporarily"],
        &["temporarily"],
        &["temporary"],
        &["temporarily"],
        &["temporarily"],
        &["temporary", "temporarily"],
        &["temporary"],
        &["temporaries"],
        &["temporarily"],
        &["temporaries"],
        &["temporarily"],
        &["temporary"],
        &["temporaries"],
        &["temporarily"],
        &["temporary"],
        &["temporaries"],
        &["temporarily"],
        &["temporaries"],
        &["temporarily"],
        &["temporary"],
        &["temporary"],
        &["temporaries"],
        &["temporarily"],
        &["temporary"],
        &["temporal"],
        &["temporaries"],
        &["temporarily"],
        &["temporary"],
        &["temporary"],
        &["temporaries"],
        &["temporarily"],
        &["temporary"],
    ],
    range: 2..=8,
};

static WORD_TEMPL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TEMPL_CHILDREN),
    value: None,
};

pub static WORD_TEMPL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aced"),
        dictgen::InsensitiveStr::Ascii("aces"),
        dictgen::InsensitiveStr::Ascii("acing"),
        dictgen::InsensitiveStr::Ascii("aet"),
        dictgen::InsensitiveStr::Ascii("aras"),
        dictgen::InsensitiveStr::Ascii("ares"),
        dictgen::InsensitiveStr::Ascii("arios"),
        dictgen::InsensitiveStr::Ascii("arius"),
        dictgen::InsensitiveStr::Ascii("as"),
        dictgen::InsensitiveStr::Ascii("at"),
        dictgen::InsensitiveStr::Ascii("ateas"),
        dictgen::InsensitiveStr::Ascii("ats"),
        dictgen::InsensitiveStr::Ascii("eos"),
        dictgen::InsensitiveStr::Ascii("ers"),
        dictgen::InsensitiveStr::Ascii("ete"),
        dictgen::InsensitiveStr::Ascii("eted"),
        dictgen::InsensitiveStr::Ascii("etes"),
        dictgen::InsensitiveStr::Ascii("eting"),
        dictgen::InsensitiveStr::Ascii("tes"),
    ],
    values: &[
        &["templated"],
        &["templates"],
        &["templating"],
        &["template"],
        &["templars"],
        &["templars"],
        &["templars"],
        &["templars"],
        &["templars"],
        &["template"],
        &["templates"],
        &["templates"],
        &["temples"],
        &["temples"],
        &["template"],
        &["templated"],
        &["templates"],
        &["templating"],
        &["templates"],
    ],
    range: 2..=5,
};

static WORD_TEMPE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TEMPE_CHILDREN),
    value: None,
};

pub static WORD_TEMPE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("arture"),
        dictgen::InsensitiveStr::Ascii("artures"),
        dictgen::InsensitiveStr::Ascii("arure"),
        dictgen::InsensitiveStr::Ascii("late"),
        dictgen::InsensitiveStr::Ascii("ls"),
        dictgen::InsensitiveStr::Ascii("ral"),
        dictgen::InsensitiveStr::Ascii("ramant"),
        dictgen::InsensitiveStr::Ascii("rarily"),
        dictgen::InsensitiveStr::Ascii("rarure"),
        dictgen::InsensitiveStr::Ascii("rary"),
        dictgen::InsensitiveStr::Ascii("ratue"),
        dictgen::InsensitiveStr::Ascii("ratues"),
        dictgen::InsensitiveStr::Ascii("ratur"),
        dictgen::InsensitiveStr::Ascii("raturas"),
        dictgen::InsensitiveStr::Ascii("raturs"),
        dictgen::InsensitiveStr::Ascii("ratuur"),
        dictgen::InsensitiveStr::Ascii("reature"),
        dictgen::InsensitiveStr::Ascii("rement"),
        dictgen::InsensitiveStr::Ascii("rmeant"),
        dictgen::InsensitiveStr::Ascii("rment"),
        dictgen::InsensitiveStr::Ascii("rtaure"),
        dictgen::InsensitiveStr::Ascii("rture"),
        dictgen::InsensitiveStr::Ascii("ts"),
    ],
    values: &[
        &["temperatures", "temperature"],
        &["temperatures"],
        &["temperature"],
        &["template"],
        &["temples"],
        &["temporal"],
        &["temperament"],
        &["temporarily"],
        &["temperature"],
        &["temporary"],
        &["temperature"],
        &["temperatures"],
        &["temperature"],
        &["temperatures"],
        &["temperatures"],
        &["temperature"],
        &["temperature"],
        &["temperament"],
        &["temperament"],
        &["temperament"],
        &["temperature"],
        &["temperature"],
        &["tempest"],
    ],
    range: 2..=7,
};

static WORD_TEMPD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TEMPD_CHILDREN),
    value: None,
};

pub static WORD_TEMPD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ate")],
    values: &[&["template"]],
    range: 3..=3,
};

static WORD_TEMPA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TEMPA_CHILDREN),
    value: None,
};

pub static WORD_TEMPA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("lrs"),
        dictgen::InsensitiveStr::Ascii("lte"),
        dictgen::InsensitiveStr::Ascii("ltes"),
        dictgen::InsensitiveStr::Ascii("ral"),
        dictgen::InsensitiveStr::Ascii("rally"),
        dictgen::InsensitiveStr::Ascii("rament"),
        dictgen::InsensitiveStr::Ascii("rarily"),
        dictgen::InsensitiveStr::Ascii("rary"),
        dictgen::InsensitiveStr::Ascii("rate"),
        dictgen::InsensitiveStr::Ascii("rature"),
        dictgen::InsensitiveStr::Ascii("ratures"),
        dictgen::InsensitiveStr::Ascii("rement"),
        dictgen::InsensitiveStr::Ascii("rily"),
        dictgen::InsensitiveStr::Ascii("te"),
        dictgen::InsensitiveStr::Ascii("ted"),
        dictgen::InsensitiveStr::Ascii("tes"),
        dictgen::InsensitiveStr::Ascii("tied"),
        dictgen::InsensitiveStr::Ascii("tion"),
        dictgen::InsensitiveStr::Ascii("tised"),
        dictgen::InsensitiveStr::Ascii("tized"),
        dictgen::InsensitiveStr::Ascii("ture"),
    ],
    values: &[
        &["templars"],
        &["template"],
        &["templates"],
        &["temporal"],
        &["temporally", "temporarily"],
        &["temperament"],
        &["temporarily"],
        &["temporary"],
        &["temperate"],
        &["temperature"],
        &["temperatures"],
        &["temperament"],
        &["temporarily"],
        &["template"],
        &["templated"],
        &["templates"],
        &["templatized"],
        &["temptation"],
        &["templatised"],
        &["templatized"],
        &["temperature"],
    ],
    range: 2..=7,
};

static WORD_TEMO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TEMO_CHILDREN),
    value: None,
};

pub static WORD_TEMO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("rarily"),
        dictgen::InsensitiveStr::Ascii("rary"),
    ],
    values: &[&["temporarily"], &["temporary"]],
    range: 4..=6,
};

static WORD_TEMM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TEMM_CHILDREN),
    value: None,
};

pub static WORD_TEMM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("porary")],
    values: &[&["temporary", "temporarily"]],
    range: 6..=6,
};

static WORD_TEML_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TEML_CHILDREN),
    value: None,
};

pub static WORD_TEML_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ate")],
    values: &[&["template"]],
    range: 3..=3,
};

static WORD_TEMI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TEMI_CHILDREN),
    value: None,
};

pub static WORD_TEMI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("nal"),
        dictgen::InsensitiveStr::Ascii("nals"),
        dictgen::InsensitiveStr::Ascii("nate"),
        dictgen::InsensitiveStr::Ascii("nated"),
        dictgen::InsensitiveStr::Ascii("nating"),
        dictgen::InsensitiveStr::Ascii("nation"),
    ],
    values: &[
        &["terminal"],
        &["terminals"],
        &["terminate"],
        &["terminated"],
        &["terminating"],
        &["termination"],
    ],
    range: 3..=6,
};

static WORD_TEME_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TEME_CHILDREN),
    value: None,
};

pub static WORD_TEME_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("prature"),
        dictgen::InsensitiveStr::Ascii("pratures"),
        dictgen::InsensitiveStr::Ascii("pst"),
        dictgen::InsensitiveStr::Ascii("rature"),
    ],
    values: &[
        &["temperature"],
        &["temperatures"],
        &["tempest"],
        &["temperature"],
    ],
    range: 3..=8,
};

static WORD_TEMA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TEMA_CHILDREN),
    value: None,
};

pub static WORD_TEMA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("fight"),
        dictgen::InsensitiveStr::Ascii("fights"),
        dictgen::InsensitiveStr::Ascii("plate"),
        dictgen::InsensitiveStr::Ascii("plates"),
    ],
    values: &[
        &["teamfight"],
        &["teamfights"],
        &["template"],
        &["templates"],
    ],
    range: 5..=6,
};

static WORD_TEL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TEL_CHILDREN),
    value: None,
};

pub static WORD_TEL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aportation"),
        dictgen::InsensitiveStr::Ascii("egrah"),
        dictgen::InsensitiveStr::Ascii("egramm"),
        dictgen::InsensitiveStr::Ascii("egrapgh"),
        dictgen::InsensitiveStr::Ascii("egrpah"),
        dictgen::InsensitiveStr::Ascii("elevision"),
        dictgen::InsensitiveStr::Ascii("ementry"),
        dictgen::InsensitiveStr::Ascii("eporing"),
        dictgen::InsensitiveStr::Ascii("eportaion"),
        dictgen::InsensitiveStr::Ascii("eportating"),
        dictgen::InsensitiveStr::Ascii("eportato"),
        dictgen::InsensitiveStr::Ascii("eportaton"),
        dictgen::InsensitiveStr::Ascii("eportion"),
        dictgen::InsensitiveStr::Ascii("eprotation"),
        dictgen::InsensitiveStr::Ascii("eproting"),
        dictgen::InsensitiveStr::Ascii("evesion"),
        dictgen::InsensitiveStr::Ascii("evisivo"),
        dictgen::InsensitiveStr::Ascii("evsion"),
        dictgen::InsensitiveStr::Ascii("iportation"),
        dictgen::InsensitiveStr::Ascii("ocom"),
        dictgen::InsensitiveStr::Ascii("oportation"),
        dictgen::InsensitiveStr::Ascii("phony"),
    ],
    values: &[
        &["teleportation"],
        &["telegraph"],
        &["telegram"],
        &["telegraph"],
        &["telegraph"],
        &["television"],
        &["telemetry"],
        &["teleporting"],
        &["teleportation"],
        &["teleportation"],
        &["teleportation"],
        &["teleportation"],
        &["teleporting"],
        &["teleportation"],
        &["teleporting"],
        &["television"],
        &["television"],
        &["television"],
        &["teleportation"],
        &["telecom"],
        &["teleportation"],
        &["telephony"],
    ],
    range: 4..=10,
};

static WORD_TEK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TEK_CHILDREN),
    value: None,
};

pub static WORD_TEK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("n"),
        dictgen::InsensitiveStr::Ascii("st"),
        dictgen::InsensitiveStr::Ascii("sts"),
    ],
    values: &[&["taken", "tekken"], &["text"], &["texts"]],
    range: 1..=3,
};

static WORD_TEH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TEH_CHILDREN),
    value: Some(&["the"]),
};

pub static WORD_TEH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cies"),
        dictgen::InsensitiveStr::Ascii("nically"),
        dictgen::InsensitiveStr::Ascii("re"),
        dictgen::InsensitiveStr::Ascii("tering"),
        dictgen::InsensitiveStr::Ascii("y"),
    ],
    values: &[
        &["techies"],
        &["ethnically", "technically"],
        &["there"],
        &["tethering"],
        &["they"],
    ],
    range: 1..=7,
};

static WORD_TEF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TEF_CHILDREN),
    value: None,
};

pub static WORD_TEF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ine")],
    values: &[&["define"]],
    range: 3..=3,
};

static WORD_TEE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TEE_CHILDREN),
    value: None,
};

pub static WORD_TEE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("angers"),
        dictgen::InsensitiveStr::Ascii("nages"),
        dictgen::InsensitiveStr::Ascii("totler"),
        dictgen::InsensitiveStr::Ascii("totlers"),
    ],
    values: &[
        &["teenagers"],
        &["teenagers"],
        &["teetotaler"],
        &["teetotalers"],
    ],
    range: 5..=7,
};

static WORD_TED_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TED_CHILDREN),
    value: None,
};

pub static WORD_TED_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("eous")],
    values: &[&["tedious"]],
    range: 4..=4,
};

static WORD_TEC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_TEC_CHILDREN),
    value: None,
};

static WORD_TEC_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_TECH_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_TECN_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_TECN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TECN_CHILDREN),
    value: None,
};

pub static WORD_TECN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ic"),
        dictgen::InsensitiveStr::Ascii("ical"),
        dictgen::InsensitiveStr::Ascii("ically"),
        dictgen::InsensitiveStr::Ascii("ician"),
        dictgen::InsensitiveStr::Ascii("icians"),
        dictgen::InsensitiveStr::Ascii("ique"),
        dictgen::InsensitiveStr::Ascii("iques"),
    ],
    values: &[
        &["technique"],
        &["technical"],
        &["technically"],
        &["technician"],
        &["technicians"],
        &["technique"],
        &["techniques"],
    ],
    range: 2..=6,
};

static WORD_TECH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_TECH_CHILDREN),
    value: None,
};

static WORD_TECH_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_TECHA_NODE),
    None,
    None,
    None,
    Some(&WORD_TECHE_NODE),
    None,
    None,
    None,
    Some(&WORD_TECHI_NODE),
    None,
    None,
    None,
    Some(&WORD_TECHM_NODE),
    Some(&WORD_TECHN_NODE),
    Some(&WORD_TECHO_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_TECHT_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_TECHT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TECHT_CHILDREN),
    value: None,
};

pub static WORD_TECHT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ician"),
        dictgen::InsensitiveStr::Ascii("icians"),
    ],
    values: &[&["technician"], &["technicians"]],
    range: 5..=6,
};

static WORD_TECHO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TECHO_CHILDREN),
    value: None,
};

pub static WORD_TECHO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("nlogical")],
    values: &[&["technological"]],
    range: 8..=8,
};

static WORD_TECHN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TECHN_CHILDREN),
    value: None,
};

pub static WORD_TECHN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cially"),
        dictgen::InsensitiveStr::Ascii("eek"),
        dictgen::InsensitiveStr::Ascii("ic"),
        dictgen::InsensitiveStr::Ascii("icain"),
        dictgen::InsensitiveStr::Ascii("icallity"),
        dictgen::InsensitiveStr::Ascii("icalty"),
        dictgen::InsensitiveStr::Ascii("icaly"),
        dictgen::InsensitiveStr::Ascii("icans"),
        dictgen::InsensitiveStr::Ascii("ichan"),
        dictgen::InsensitiveStr::Ascii("ichian"),
        dictgen::InsensitiveStr::Ascii("icial"),
        dictgen::InsensitiveStr::Ascii("icials"),
        dictgen::InsensitiveStr::Ascii("icien"),
        dictgen::InsensitiveStr::Ascii("iciens"),
        dictgen::InsensitiveStr::Ascii("icion"),
        dictgen::InsensitiveStr::Ascii("ics"),
        dictgen::InsensitiveStr::Ascii("ik"),
        dictgen::InsensitiveStr::Ascii("iks"),
        dictgen::InsensitiveStr::Ascii("iqe"),
        dictgen::InsensitiveStr::Ascii("iquest"),
        dictgen::InsensitiveStr::Ascii("iquet"),
        dictgen::InsensitiveStr::Ascii("itian"),
        dictgen::InsensitiveStr::Ascii("itians"),
        dictgen::InsensitiveStr::Ascii("ition"),
        dictgen::InsensitiveStr::Ascii("logy"),
        dictgen::InsensitiveStr::Ascii("nology"),
        dictgen::InsensitiveStr::Ascii("olgy"),
        dictgen::InsensitiveStr::Ascii("oligical"),
        dictgen::InsensitiveStr::Ascii("oligically"),
        dictgen::InsensitiveStr::Ascii("ologia"),
        dictgen::InsensitiveStr::Ascii("ologial"),
        dictgen::InsensitiveStr::Ascii("ologicaly"),
        dictgen::InsensitiveStr::Ascii("ologicially"),
        dictgen::InsensitiveStr::Ascii("ologicly"),
        dictgen::InsensitiveStr::Ascii("oloiges"),
        dictgen::InsensitiveStr::Ascii("qiues"),
    ],
    values: &[
        &["technically"],
        &["technique"],
        &["technique"],
        &["technician"],
        &["technically"],
        &["technicality"],
        &["technically"],
        &["technicians"],
        &["technician"],
        &["technician"],
        &["technical"],
        &["technicians"],
        &["technician"],
        &["technicians"],
        &["technician"],
        &["techniques"],
        &["technique"],
        &["techniques"],
        &["technique"],
        &["techniques"],
        &["technique"],
        &["technician"],
        &["technicians"],
        &["technician"],
        &["technology"],
        &["technology"],
        &["technology"],
        &["technological"],
        &["technologically"],
        &["technological"],
        &["technological"],
        &["technologically"],
        &["technologically"],
        &["technological"],
        &["technologies"],
        &["techniques"],
    ],
    range: 2..=11,
};

static WORD_TECHM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TECHM_CHILDREN),
    value: None,
};

pub static WORD_TECHM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ological")],
    values: &[&["technological"]],
    range: 8..=8,
};

static WORD_TECHI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TECHI_CHILDREN),
    value: None,
};

pub static WORD_TECHI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cal"),
        dictgen::InsensitiveStr::Ascii("cally"),
        dictgen::InsensitiveStr::Ascii("cian"),
        dictgen::InsensitiveStr::Ascii("cians"),
        dictgen::InsensitiveStr::Ascii("ncal"),
        dictgen::InsensitiveStr::Ascii("ncality"),
        dictgen::InsensitiveStr::Ascii("ncally"),
        dictgen::InsensitiveStr::Ascii("ncian"),
        dictgen::InsensitiveStr::Ascii("ncians"),
        dictgen::InsensitiveStr::Ascii("ng"),
        dictgen::InsensitiveStr::Ascii("nically"),
        dictgen::InsensitiveStr::Ascii("nican"),
        dictgen::InsensitiveStr::Ascii("nique"),
        dictgen::InsensitiveStr::Ascii("niques"),
        dictgen::InsensitiveStr::Ascii("nque"),
        dictgen::InsensitiveStr::Ascii("nques"),
        dictgen::InsensitiveStr::Ascii("que"),
        dictgen::InsensitiveStr::Ascii("ques"),
    ],
    values: &[
        &["technical"],
        &["tactically", "technically"],
        &["technician"],
        &["technicians"],
        &["technical"],
        &["technicality"],
        &["technically"],
        &["technician"],
        &["technicians"],
        &["teaching"],
        &["technically"],
        &["technician"],
        &["technique"],
        &["techniques"],
        &["technique"],
        &["techniques"],
        &["technique"],
        &["techniques"],
    ],
    range: 2..=7,
};

static WORD_TECHE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TECHE_CHILDREN),
    value: None,
};

pub static WORD_TECHE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("d"),
        dictgen::InsensitiveStr::Ascii("is"),
        dictgen::InsensitiveStr::Ascii("r"),
        dictgen::InsensitiveStr::Ascii("rs"),
        dictgen::InsensitiveStr::Ascii("s"),
    ],
    values: &[
        &["taught"],
        &["techies"],
        &["teacher"],
        &["teachers"],
        &["teaches"],
    ],
    range: 1..=2,
};

static WORD_TECHA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TECHA_CHILDREN),
    value: None,
};

pub static WORD_TECHA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("nically")],
    values: &[&["mechanically"]],
    range: 7..=7,
};

static WORD_TEA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TEA_CHILDREN),
    value: None,
};

pub static WORD_TEA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cer"),
        dictgen::InsensitiveStr::Ascii("cers"),
        dictgen::InsensitiveStr::Ascii("ched"),
        dictgen::InsensitiveStr::Ascii("chnig"),
        dictgen::InsensitiveStr::Ascii("her"),
        dictgen::InsensitiveStr::Ascii("hers"),
        dictgen::InsensitiveStr::Ascii("mfighs"),
        dictgen::InsensitiveStr::Ascii("mfighters"),
        dictgen::InsensitiveStr::Ascii("mfigt"),
        dictgen::InsensitiveStr::Ascii("mfigth"),
        dictgen::InsensitiveStr::Ascii("mfigths"),
        dictgen::InsensitiveStr::Ascii("mifght"),
        dictgen::InsensitiveStr::Ascii("mifghts"),
        dictgen::InsensitiveStr::Ascii("mplate"),
        dictgen::InsensitiveStr::Ascii("mplates"),
        dictgen::InsensitiveStr::Ascii("mpseak"),
        dictgen::InsensitiveStr::Ascii("mspeack"),
        dictgen::InsensitiveStr::Ascii("mspek"),
        dictgen::InsensitiveStr::Ascii("ncity"),
        dictgen::InsensitiveStr::Ascii("nsylvania"),
        dictgen::InsensitiveStr::Ascii("psoon"),
        dictgen::InsensitiveStr::Ascii("spon"),
        dictgen::InsensitiveStr::Ascii("spooon"),
        dictgen::InsensitiveStr::Ascii("ted"),
        dictgen::InsensitiveStr::Ascii("totaler"),
        dictgen::InsensitiveStr::Ascii("totalers"),
        dictgen::InsensitiveStr::Ascii("totler"),
        dictgen::InsensitiveStr::Ascii("totlers"),
    ],
    values: &[
        &["teacher"],
        &["teachers"],
        &["taught"],
        &["teaching"],
        &["teacher"],
        &["teachers"],
        &["teamfights"],
        &["teamfights"],
        &["teamfight"],
        &["teamfight"],
        &["teamfights"],
        &["teamfight"],
        &["teamfights"],
        &["template"],
        &["templates"],
        &["teamspeak"],
        &["teamspeak"],
        &["teamspeak"],
        &["tenacity"],
        &["transylvania"],
        &["teaspoon"],
        &["teaspoon"],
        &["teaspoon"],
        &["treated"],
        &["teetotaler"],
        &["teetotalers"],
        &["teetotaler"],
        &["teetotalers"],
    ],
    range: 3..=9,
};

static WORD_TD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TD_CHILDREN),
    value: None,
};

pub static WORD_TD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("od")],
    values: &[&["todo"]],
    range: 2..=2,
};

static WORD_TC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TC_CHILDREN),
    value: None,
};

pub static WORD_TC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ahce"),
        dictgen::InsensitiveStr::Ascii("ahces"),
        dictgen::InsensitiveStr::Ascii("heckout"),
        dictgen::InsensitiveStr::Ascii("pdumpp"),
        dictgen::InsensitiveStr::Ascii("ppcheck"),
    ],
    values: &[
        &["cache"],
        &["caches"],
        &["checkout"],
        &["tcpdump"],
        &["cppcheck"],
    ],
    range: 4..=7,
};

static WORD_TB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TB_CHILDREN),
    value: None,
};

pub static WORD_TB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("ey"),
    ],
    values: &[&["the"], &["they"]],
    range: 1..=2,
};

static WORD_TA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_TA_CHILDREN),
    value: None,
};

static WORD_TA_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    Some(&WORD_TAB_NODE),
    Some(&WORD_TAC_NODE),
    None,
    None,
    None,
    Some(&WORD_TAG_NODE),
    Some(&WORD_TAH_NODE),
    Some(&WORD_TAI_NODE),
    None,
    Some(&WORD_TAK_NODE),
    Some(&WORD_TAL_NODE),
    Some(&WORD_TAM_NODE),
    Some(&WORD_TAN_NODE),
    None,
    Some(&WORD_TAP_NODE),
    None,
    Some(&WORD_TAR_NODE),
    Some(&WORD_TAS_NODE),
    Some(&WORD_TAT_NODE),
    None,
    Some(&WORD_TAV_NODE),
    Some(&WORD_TAW_NODE),
    Some(&WORD_TAX_NODE),
    Some(&WORD_TAY_NODE),
    None,
];

static WORD_TAY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TAY_CHILDREN),
    value: None,
};

pub static WORD_TAY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("lored")],
    values: &[&["tailored"]],
    range: 5..=5,
};

static WORD_TAX_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TAX_CHILDREN),
    value: None,
};

pub static WORD_TAX_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("anomic"),
        dictgen::InsensitiveStr::Ascii("anomy"),
        dictgen::InsensitiveStr::Ascii("nomy"),
        dictgen::InsensitiveStr::Ascii("omonmy"),
        dictgen::InsensitiveStr::Ascii("onmy"),
        dictgen::InsensitiveStr::Ascii("onoy"),
    ],
    values: &[
        &["taxonomic"],
        &["taxonomy"],
        &["taxonomy"],
        &["taxonomy"],
        &["taxonomy"],
        &["taxonomy"],
    ],
    range: 4..=6,
};

static WORD_TAW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TAW_CHILDREN),
    value: None,
};

pub static WORD_TAW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ainese"),
        dictgen::InsensitiveStr::Ascii("ianese"),
        dictgen::InsensitiveStr::Ascii("k"),
    ],
    values: &[&["taiwanese"], &["taiwanese"], &["talk"]],
    range: 1..=6,
};

static WORD_TAV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TAV_CHILDREN),
    value: None,
};

pub static WORD_TAV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eled"),
        dictgen::InsensitiveStr::Ascii("eling"),
        dictgen::InsensitiveStr::Ascii("elled"),
        dictgen::InsensitiveStr::Ascii("elling"),
    ],
    values: &[
        &["traveled"],
        &["traveling"],
        &["travelled"],
        &["travelling"],
    ],
    range: 4..=6,
};

static WORD_TAT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TAT_CHILDREN),
    value: None,
};

pub static WORD_TAT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("gert"),
        dictgen::InsensitiveStr::Ascii("gerted"),
        dictgen::InsensitiveStr::Ascii("gerting"),
        dictgen::InsensitiveStr::Ascii("gerts"),
        dictgen::InsensitiveStr::Ascii("h"),
        dictgen::InsensitiveStr::Ascii("oo"),
        dictgen::InsensitiveStr::Ascii("oos"),
        dictgen::InsensitiveStr::Ascii("tooes"),
        dictgen::InsensitiveStr::Ascii("tooos"),
    ],
    values: &[
        &["target"],
        &["targeted"],
        &["targeting"],
        &["targets"],
        &["that"],
        &["tattoo"],
        &["tattoos"],
        &["tattoos"],
        &["tattoos"],
    ],
    range: 1..=7,
};

static WORD_TAS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TAS_CHILDREN),
    value: None,
};

pub static WORD_TAS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("bar"),
        dictgen::InsensitiveStr::Ascii("kelt"),
        dictgen::InsensitiveStr::Ascii("liman"),
        dictgen::InsensitiveStr::Ascii("t"),
    ],
    values: &[
        &["taskbar"],
        &["tasklet"],
        &["talisman"],
        &["taste", "task", "test"],
    ],
    range: 1..=5,
};

static WORD_TAR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TAR_CHILDREN),
    value: None,
};

pub static WORD_TAR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("bal"),
        dictgen::InsensitiveStr::Ascii("bals"),
        dictgen::InsensitiveStr::Ascii("ce"),
        dictgen::InsensitiveStr::Ascii("ced"),
        dictgen::InsensitiveStr::Ascii("ces"),
        dictgen::InsensitiveStr::Ascii("cing"),
        dictgen::InsensitiveStr::Ascii("ffic"),
        dictgen::InsensitiveStr::Ascii("ged"),
        dictgen::InsensitiveStr::Ascii("ger"),
        dictgen::InsensitiveStr::Ascii("gest"),
        dictgen::InsensitiveStr::Ascii("gested"),
        dictgen::InsensitiveStr::Ascii("gesting"),
        dictgen::InsensitiveStr::Ascii("gests"),
        dictgen::InsensitiveStr::Ascii("getd"),
        dictgen::InsensitiveStr::Ascii("getted"),
        dictgen::InsensitiveStr::Ascii("getting"),
        dictgen::InsensitiveStr::Ascii("gettting"),
        dictgen::InsensitiveStr::Ascii("gt"),
        dictgen::InsensitiveStr::Ascii("gte"),
        dictgen::InsensitiveStr::Ascii("gtets"),
        dictgen::InsensitiveStr::Ascii("migan"),
        dictgen::InsensitiveStr::Ascii("nsparent"),
        dictgen::InsensitiveStr::Ascii("polin"),
        dictgen::InsensitiveStr::Ascii("vis"),
        dictgen::InsensitiveStr::Ascii("visci"),
        dictgen::InsensitiveStr::Ascii("yvon"),
    ],
    values: &[
        &["tarball"],
        &["tarballs"],
        &["trace"],
        &["traced"],
        &["traces"],
        &["tracing"],
        &["traffic"],
        &["target"],
        &["target"],
        &["target", "targets"],
        &["targeted"],
        &["targeting"],
        &["targets"],
        &["targeted"],
        &["targeted"],
        &["targeting"],
        &["targeting"],
        &["target"],
        &["target"],
        &["targets"],
        &["ptarmigan"],
        &["transparent"],
        &["tarpaulin"],
        &["travis"],
        &["travisci"],
        &["trayvon"],
    ],
    range: 2..=8,
};

static WORD_TAP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TAP_CHILDREN),
    value: None,
};

pub static WORD_TAP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("itude")],
    values: &[&["aptitude"]],
    range: 5..=5,
};

static WORD_TAN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TAN_CHILDREN),
    value: None,
};

pub static WORD_TAN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("enhill"),
        dictgen::InsensitiveStr::Ascii("geant"),
        dictgen::InsensitiveStr::Ascii("geantial"),
        dictgen::InsensitiveStr::Ascii("geants"),
        dictgen::InsensitiveStr::Ascii("geld"),
        dictgen::InsensitiveStr::Ascii("gencially"),
        dictgen::InsensitiveStr::Ascii("genet"),
        dictgen::InsensitiveStr::Ascii("genitally"),
        dictgen::InsensitiveStr::Ascii("gensial"),
        dictgen::InsensitiveStr::Ascii("gentailly"),
        dictgen::InsensitiveStr::Ascii("gentialy"),
        dictgen::InsensitiveStr::Ascii("get"),
        dictgen::InsensitiveStr::Ascii("getial"),
        dictgen::InsensitiveStr::Ascii("getially"),
        dictgen::InsensitiveStr::Ascii("gets"),
        dictgen::InsensitiveStr::Ascii("gientally"),
        dictgen::InsensitiveStr::Ascii("lged"),
        dictgen::InsensitiveStr::Ascii("nheill"),
        dictgen::InsensitiveStr::Ascii("sact"),
        dictgen::InsensitiveStr::Ascii("saction"),
        dictgen::InsensitiveStr::Ascii("sactional"),
        dictgen::InsensitiveStr::Ascii("sactions"),
        dictgen::InsensitiveStr::Ascii("seint"),
        dictgen::InsensitiveStr::Ascii("sfomed"),
        dictgen::InsensitiveStr::Ascii("sient"),
        dictgen::InsensitiveStr::Ascii("slate"),
        dictgen::InsensitiveStr::Ascii("slated"),
        dictgen::InsensitiveStr::Ascii("slates"),
        dictgen::InsensitiveStr::Ascii("slation"),
        dictgen::InsensitiveStr::Ascii("slations"),
        dictgen::InsensitiveStr::Ascii("slator"),
        dictgen::InsensitiveStr::Ascii("smit"),
        dictgen::InsensitiveStr::Ascii("sverse"),
        dictgen::InsensitiveStr::Ascii("trumers"),
        dictgen::InsensitiveStr::Ascii("turms"),
    ],
    values: &[
        &["tannehill"],
        &["tangent"],
        &["tangential"],
        &["tangents"],
        &["tangled"],
        &["tangentially"],
        &["tangent"],
        &["tangentially"],
        &["tangential"],
        &["tangentially"],
        &["tangentially"],
        &["tangent"],
        &["tangential"],
        &["tangentially"],
        &["tangents"],
        &["tangentially"],
        &["tangled"],
        &["tannehill"],
        &["transact"],
        &["transaction"],
        &["transactional"],
        &["transactions"],
        &["transient"],
        &["transformed"],
        &["transient"],
        &["translate"],
        &["translated"],
        &["translates"],
        &["translation"],
        &["translations"],
        &["translator"],
        &["transmit"],
        &["transverse"],
        &["tantrums"],
        &["tantrums"],
    ],
    range: 3..=9,
};

static WORD_TAM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TAM_CHILDREN),
    value: None,
};

pub static WORD_TAM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("plate"),
        dictgen::InsensitiveStr::Ascii("plated"),
        dictgen::InsensitiveStr::Ascii("plates"),
        dictgen::InsensitiveStr::Ascii("plating"),
    ],
    values: &[
        &["template"],
        &["templated"],
        &["templates"],
        &["templating"],
    ],
    range: 5..=7,
};

static WORD_TAL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TAL_CHILDREN),
    value: None,
};

pub static WORD_TAL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("be"),
        dictgen::InsensitiveStr::Ascii("bian"),
        dictgen::InsensitiveStr::Ascii("ekd"),
        dictgen::InsensitiveStr::Ascii("igate"),
        dictgen::InsensitiveStr::Ascii("igating"),
        dictgen::InsensitiveStr::Ascii("iored"),
        dictgen::InsensitiveStr::Ascii("lents"),
        dictgen::InsensitiveStr::Ascii("lerable"),
        dictgen::InsensitiveStr::Ascii("lets"),
        dictgen::InsensitiveStr::Ascii("siman"),
    ],
    values: &[
        &["table"],
        &["taliban"],
        &["talked"],
        &["tailgate"],
        &["tailgating"],
        &["tailored"],
        &["tallest"],
        &["tolerable"],
        &["tallest"],
        &["talisman"],
    ],
    range: 2..=7,
};

static WORD_TAK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TAK_CHILDREN),
    value: None,
};

pub static WORD_TAK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("s"),
        dictgen::InsensitiveStr::Ascii("slet"),
    ],
    values: &[&["task", "tasks", "takes"], &["tasklet"]],
    range: 1..=4,
};

static WORD_TAI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TAI_CHILDREN),
    value: None,
};

pub static WORD_TAI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("lban"),
        dictgen::InsensitiveStr::Ascii("lgateing"),
        dictgen::InsensitiveStr::Ascii("lgatting"),
        dictgen::InsensitiveStr::Ascii("lord"),
        dictgen::InsensitiveStr::Ascii("lsman"),
        dictgen::InsensitiveStr::Ascii("ned"),
        dictgen::InsensitiveStr::Ascii("wanee"),
        dictgen::InsensitiveStr::Ascii("wanesse"),
    ],
    values: &[
        &["taliban"],
        &["tailgating"],
        &["tailgating"],
        &["tailored"],
        &["talisman"],
        &["stained", "tainted"],
        &["taiwanese"],
        &["taiwanese"],
    ],
    range: 3..=8,
};

static WORD_TAH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TAH_CHILDREN),
    value: None,
};

pub static WORD_TAH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("n"),
        dictgen::InsensitiveStr::Ascii("nkyou"),
        dictgen::InsensitiveStr::Ascii("t"),
    ],
    values: &[&["than"], &["thankyou"], &["that"]],
    range: 1..=5,
};

static WORD_TAG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TAG_CHILDREN),
    value: None,
};

pub static WORD_TAG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("et"),
        dictgen::InsensitiveStr::Ascii("eted"),
        dictgen::InsensitiveStr::Ascii("eting"),
        dictgen::InsensitiveStr::Ascii("ets"),
        dictgen::InsensitiveStr::Ascii("ggen"),
        dictgen::InsensitiveStr::Ascii("liate"),
        dictgen::InsensitiveStr::Ascii("net"),
        dictgen::InsensitiveStr::Ascii("netial"),
        dictgen::InsensitiveStr::Ascii("nets"),
        dictgen::InsensitiveStr::Ascii("ued"),
    ],
    values: &[
        &["stage", "take", "tag", "tagged"],
        &["tagged"],
        &["stages", "tags"],
        &["target"],
        &["targeted"],
        &["targeting"],
        &["targets"],
        &["taggen"],
        &["tailgate"],
        &["tangent"],
        &["tangential"],
        &["tangents"],
        &["tagged"],
    ],
    range: 1..=6,
};

static WORD_TAC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TAC_CHILDREN),
    value: None,
};

pub static WORD_TAC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("itcally"),
        dictgen::InsensitiveStr::Ascii("ticallity"),
        dictgen::InsensitiveStr::Ascii("ticaly"),
        dictgen::InsensitiveStr::Ascii("ticas"),
        dictgen::InsensitiveStr::Ascii("ticts"),
        dictgen::InsensitiveStr::Ascii("ticus"),
    ],
    values: &[
        &["tactically"],
        &["tactically"],
        &["tactically"],
        &["tactics"],
        &["tactics"],
        &["tactics"],
    ],
    range: 5..=9,
};

static WORD_TAB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_TAB_CHILDREN),
    value: None,
};

pub static WORD_TAB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("acco"),
        dictgen::InsensitiveStr::Ascii("baray"),
        dictgen::InsensitiveStr::Ascii("blow"),
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("el"),
        dictgen::InsensitiveStr::Ascii("eles"),
        dictgen::InsensitiveStr::Ascii("els"),
        dictgen::InsensitiveStr::Ascii("elspoon"),
        dictgen::InsensitiveStr::Ascii("elspoons"),
        dictgen::InsensitiveStr::Ascii("eview"),
        dictgen::InsensitiveStr::Ascii("ke"),
        dictgen::InsensitiveStr::Ascii("l"),
        dictgen::InsensitiveStr::Ascii("lepsace"),
        dictgen::InsensitiveStr::Ascii("lepsaces"),
        dictgen::InsensitiveStr::Ascii("lepsoons"),
        dictgen::InsensitiveStr::Ascii("lespon"),
        dictgen::InsensitiveStr::Ascii("lespons"),
        dictgen::InsensitiveStr::Ascii("lespooon"),
        dictgen::InsensitiveStr::Ascii("lespooons"),
        dictgen::InsensitiveStr::Ascii("lesppon"),
        dictgen::InsensitiveStr::Ascii("lesppons"),
        dictgen::InsensitiveStr::Ascii("lle"),
        dictgen::InsensitiveStr::Ascii("luar"),
        dictgen::InsensitiveStr::Ascii("luate"),
        dictgen::InsensitiveStr::Ascii("luated"),
        dictgen::InsensitiveStr::Ascii("luates"),
        dictgen::InsensitiveStr::Ascii("luating"),
        dictgen::InsensitiveStr::Ascii("lular"),
        dictgen::InsensitiveStr::Ascii("ualte"),
        dictgen::InsensitiveStr::Ascii("ualted"),
        dictgen::InsensitiveStr::Ascii("ualtes"),
        dictgen::InsensitiveStr::Ascii("ualting"),
        dictgen::InsensitiveStr::Ascii("ualtor"),
        dictgen::InsensitiveStr::Ascii("ualtors"),
    ],
    values: &[
        &["tobacco"],
        &["taboret"],
        &["tableau"],
        &["table"],
        &["table"],
        &["tables"],
        &["tables"],
        &["tablespoon"],
        &["tablespoons"],
        &["tabview"],
        &["table"],
        &["table"],
        &["tablespace"],
        &["tablespaces"],
        &["tablespoons"],
        &["tablespoon"],
        &["tablespoons"],
        &["tablespoon"],
        &["tablespoon"],
        &["tablespoon"],
        &["tablespoons"],
        &["table"],
        &["tabular"],
        &["tabulate"],
        &["tabulated"],
        &["tabulates"],
        &["tabulating"],
        &["tabular"],
        &["tabulate"],
        &["tabulated"],
        &["tabulates"],
        &["tabulating"],
        &["tabulator"],
        &["tabulators"],
    ],
    range: 1..=9,
};

static WORD_S_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_S_CHILDREN),
    value: None,
};

static WORD_S_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_SA_NODE),
    Some(&WORD_SB_NODE),
    Some(&WORD_SC_NODE),
    None,
    Some(&WORD_SE_NODE),
    Some(&WORD_SF_NODE),
    Some(&WORD_SG_NODE),
    Some(&WORD_SH_NODE),
    Some(&WORD_SI_NODE),
    None,
    Some(&WORD_SK_NODE),
    Some(&WORD_SL_NODE),
    Some(&WORD_SM_NODE),
    Some(&WORD_SN_NODE),
    Some(&WORD_SO_NODE),
    Some(&WORD_SP_NODE),
    Some(&WORD_SQ_NODE),
    Some(&WORD_SR_NODE),
    Some(&WORD_SS_NODE),
    Some(&WORD_ST_NODE),
    Some(&WORD_SU_NODE),
    Some(&WORD_SV_NODE),
    Some(&WORD_SW_NODE),
    Some(&WORD_SX_NODE),
    Some(&WORD_SY_NODE),
    Some(&WORD_SZ_NODE),
];

static WORD_SZ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SZ_CHILDREN),
    value: None,
};

pub static WORD_SZ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("enario"),
        dictgen::InsensitiveStr::Ascii("enarios"),
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("ie"),
        dictgen::InsensitiveStr::Ascii("ied"),
        dictgen::InsensitiveStr::Ascii("ies"),
    ],
    values: &[
        &["scenario"],
        &["scenarios"],
        &["sizes"],
        &["size"],
        &["sized"],
        &["sizes"],
    ],
    range: 2..=7,
};

static WORD_SY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_SY_CHILDREN),
    value: None,
};

static WORD_SY_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_SYA_NODE),
    Some(&WORD_SYB_NODE),
    Some(&WORD_SYC_NODE),
    Some(&WORD_SYD_NODE),
    None,
    Some(&WORD_SYF_NODE),
    None,
    None,
    Some(&WORD_SYI_NODE),
    None,
    Some(&WORD_SYK_NODE),
    Some(&WORD_SYL_NODE),
    Some(&WORD_SYM_NODE),
    Some(&WORD_SYN_NODE),
    None,
    Some(&WORD_SYP_NODE),
    None,
    Some(&WORD_SYR_NODE),
    Some(&WORD_SYS_NODE),
    Some(&WORD_SYT_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_SYT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SYT_CHILDREN),
    value: None,
};

pub static WORD_SYT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ax"),
        dictgen::InsensitiveStr::Ascii("em"),
        dictgen::InsensitiveStr::Ascii("ematic"),
        dictgen::InsensitiveStr::Ascii("emd"),
        dictgen::InsensitiveStr::Ascii("eme"),
        dictgen::InsensitiveStr::Ascii("emerror"),
        dictgen::InsensitiveStr::Ascii("emmemory"),
        dictgen::InsensitiveStr::Ascii("ems"),
        dictgen::InsensitiveStr::Ascii("emwindow"),
        dictgen::InsensitiveStr::Ascii("hesis"),
        dictgen::InsensitiveStr::Ascii("le"),
        dictgen::InsensitiveStr::Ascii("led"),
        dictgen::InsensitiveStr::Ascii("les"),
        dictgen::InsensitiveStr::Ascii("lesheet"),
        dictgen::InsensitiveStr::Ascii("ling"),
        dictgen::InsensitiveStr::Ascii("lish"),
        dictgen::InsensitiveStr::Ascii("nax"),
        dictgen::InsensitiveStr::Ascii("ntax"),
        dictgen::InsensitiveStr::Ascii("rofoam"),
        dictgen::InsensitiveStr::Ascii("sem"),
        dictgen::InsensitiveStr::Ascii("semic"),
        dictgen::InsensitiveStr::Ascii("sems"),
    ],
    values: &[
        &["syntax"],
        &["system"],
        &["systematic"],
        &["systemd"],
        &["system"],
        &["systemerror"],
        &["systemmemory"],
        &["systems"],
        &["systemwindow"],
        &["synthesis"],
        &["style"],
        &["styled"],
        &["styles"],
        &["stylesheet"],
        &["styling"],
        &["stylish"],
        &["syntax"],
        &["syntax"],
        &["styrofoam"],
        &["system"],
        &["systemic"],
        &["systems"],
    ],
    range: 2..=8,
};

static WORD_SYS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SYS_CHILDREN),
    value: None,
};

pub static WORD_SYS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("admn"),
        dictgen::InsensitiveStr::Ascii("amdin"),
        dictgen::InsensitiveStr::Ascii("bols"),
        dictgen::InsensitiveStr::Ascii("chronize"),
        dictgen::InsensitiveStr::Ascii("damin"),
        dictgen::InsensitiveStr::Ascii("em"),
        dictgen::InsensitiveStr::Ascii("ematic"),
        dictgen::InsensitiveStr::Ascii("ems"),
        dictgen::InsensitiveStr::Ascii("matically"),
        dictgen::InsensitiveStr::Ascii("mbol"),
        dictgen::InsensitiveStr::Ascii("mograph"),
        dictgen::InsensitiveStr::Ascii("mte"),
        dictgen::InsensitiveStr::Ascii("mtes"),
        dictgen::InsensitiveStr::Ascii("tamatic"),
        dictgen::InsensitiveStr::Ascii("tax"),
        dictgen::InsensitiveStr::Ascii("te"),
        dictgen::InsensitiveStr::Ascii("tematicaly"),
        dictgen::InsensitiveStr::Ascii("tematiclly"),
        dictgen::InsensitiveStr::Ascii("tematisch"),
        dictgen::InsensitiveStr::Ascii("temc"),
        dictgen::InsensitiveStr::Ascii("temetic"),
        dictgen::InsensitiveStr::Ascii("temetically"),
        dictgen::InsensitiveStr::Ascii("temisch"),
        dictgen::InsensitiveStr::Ascii("temn"),
        dictgen::InsensitiveStr::Ascii("temwindiow"),
        dictgen::InsensitiveStr::Ascii("ten"),
        dictgen::InsensitiveStr::Ascii("tens"),
        dictgen::InsensitiveStr::Ascii("tesm"),
        dictgen::InsensitiveStr::Ascii("them"),
        dictgen::InsensitiveStr::Ascii("themerror"),
        dictgen::InsensitiveStr::Ascii("themmemory"),
        dictgen::InsensitiveStr::Ascii("thems"),
        dictgen::InsensitiveStr::Ascii("themwindow"),
        dictgen::InsensitiveStr::Ascii("timatic"),
        dictgen::InsensitiveStr::Ascii("timatically"),
        dictgen::InsensitiveStr::Ascii("tm"),
        dictgen::InsensitiveStr::Ascii("tme"),
        dictgen::InsensitiveStr::Ascii("tmes"),
        dictgen::InsensitiveStr::Ascii("tms"),
        dictgen::InsensitiveStr::Ascii("tyem"),
        dictgen::InsensitiveStr::Ascii("tyems"),
        dictgen::InsensitiveStr::Ascii("yem"),
        dictgen::InsensitiveStr::Ascii("yems"),
    ],
    values: &[
        &["sysadmin"],
        &["sysadmin"],
        &["symbols"],
        &["synchronize"],
        &["sysadmin"],
        &["system"],
        &["systematic"],
        &["systems"],
        &["systematically"],
        &["symbol"],
        &["seismograph"],
        &["system"],
        &["systems"],
        &["systematic"],
        &["syntax"],
        &["system"],
        &["systematically"],
        &["systematically"],
        &["systematic"],
        &["systemic"],
        &["systematic"],
        &["systematically"],
        &["systemic"],
        &["system"],
        &["systemwindow"],
        &["system"],
        &["systems"],
        &["systems"],
        &["system"],
        &["systemerror"],
        &["systemmemory"],
        &["systems"],
        &["systemwindow"],
        &["systematic"],
        &["systematically"],
        &["system"],
        &["system"],
        &["systems"],
        &["systems"],
        &["system"],
        &["systems"],
        &["system"],
        &["systems"],
    ],
    range: 2..=11,
};

static WORD_SYR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SYR_CHILDREN),
    value: None,
};

pub static WORD_SYR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("acue"),
        dictgen::InsensitiveStr::Ascii("acusae"),
        dictgen::InsensitiveStr::Ascii("ains"),
        dictgen::InsensitiveStr::Ascii("ap"),
        dictgen::InsensitiveStr::Ascii("aucse"),
        dictgen::InsensitiveStr::Ascii("cause"),
        dictgen::InsensitiveStr::Ascii("ingae"),
        dictgen::InsensitiveStr::Ascii("ingue"),
    ],
    values: &[
        &["syracuse"],
        &["syracuse"],
        &["syrians"],
        &["syrup"],
        &["syracuse"],
        &["syracuse"],
        &["syringe"],
        &["syringe"],
    ],
    range: 2..=6,
};

static WORD_SYP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SYP_CHILDREN),
    value: None,
};

pub static WORD_SYP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("hyllis"),
        dictgen::InsensitiveStr::Ascii("mathetic"),
        dictgen::InsensitiveStr::Ascii("mathize"),
        dictgen::InsensitiveStr::Ascii("mathy"),
        dictgen::InsensitiveStr::Ascii("mtom"),
        dictgen::InsensitiveStr::Ascii("mtoms"),
        dictgen::InsensitiveStr::Ascii("nosis"),
        dictgen::InsensitiveStr::Ascii("port"),
    ],
    values: &[
        &["syphilis"],
        &["sympathetic"],
        &["sympathize"],
        &["sympathy"],
        &["symptom"],
        &["symptoms"],
        &["synopsis"],
        &["support"],
    ],
    range: 4..=8,
};

static WORD_SYN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_SYN_CHILDREN),
    value: None,
};

static WORD_SYN_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_SYNA_NODE),
    None,
    Some(&WORD_SYNC_NODE),
    Some(&WORD_SYND_NODE),
    Some(&WORD_SYNE_NODE),
    None,
    None,
    None,
    Some(&WORD_SYNI_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_SYNO_NODE),
    Some(&WORD_SYNP_NODE),
    None,
    Some(&WORD_SYNR_NODE),
    None,
    Some(&WORD_SYNT_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_SYNT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SYNT_CHILDREN),
    value: None,
};

pub static WORD_SYNT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ac"),
        dictgen::InsensitiveStr::Ascii("aces"),
        dictgen::InsensitiveStr::Ascii("acks"),
        dictgen::InsensitiveStr::Ascii("acs"),
        dictgen::InsensitiveStr::Ascii("act"),
        dictgen::InsensitiveStr::Ascii("actally"),
        dictgen::InsensitiveStr::Ascii("acts"),
        dictgen::InsensitiveStr::Ascii("ak"),
        dictgen::InsensitiveStr::Ascii("aks"),
        dictgen::InsensitiveStr::Ascii("akt"),
        dictgen::InsensitiveStr::Ascii("akts"),
        dictgen::InsensitiveStr::Ascii("atic"),
        dictgen::InsensitiveStr::Ascii("atically"),
        dictgen::InsensitiveStr::Ascii("axe"),
        dictgen::InsensitiveStr::Ascii("axg"),
        dictgen::InsensitiveStr::Ascii("axical"),
        dictgen::InsensitiveStr::Ascii("axically"),
        dictgen::InsensitiveStr::Ascii("axt"),
        dictgen::InsensitiveStr::Ascii("ehsis"),
        dictgen::InsensitiveStr::Ascii("ehsise"),
        dictgen::InsensitiveStr::Ascii("ehsised"),
        dictgen::InsensitiveStr::Ascii("ehsize"),
        dictgen::InsensitiveStr::Ascii("ehsized"),
        dictgen::InsensitiveStr::Ascii("ehtic"),
        dictgen::InsensitiveStr::Ascii("esis"),
        dictgen::InsensitiveStr::Ascii("ethic"),
        dictgen::InsensitiveStr::Ascii("ethically"),
        dictgen::InsensitiveStr::Ascii("ethics"),
        dictgen::InsensitiveStr::Ascii("etic"),
        dictgen::InsensitiveStr::Ascii("etize"),
        dictgen::InsensitiveStr::Ascii("etized"),
        dictgen::InsensitiveStr::Ascii("hesasia"),
        dictgen::InsensitiveStr::Ascii("hesesia"),
        dictgen::InsensitiveStr::Ascii("hethic"),
        dictgen::InsensitiveStr::Ascii("htic"),
    ],
    values: &[
        &["syntax"],
        &["syntax", "syntaxes"],
        &["syntax"],
        &["syntax"],
        &["syntax"],
        &["syntactically"],
        &["syntax"],
        &["syntax"],
        &["syntax"],
        &["syntax"],
        &["syntax"],
        &["syntactic"],
        &["syntactically"],
        &["syntax"],
        &["syntax"],
        &["syntactical"],
        &["syntactically"],
        &["syntax"],
        &["synthesis"],
        &["synthesise"],
        &["synthesised"],
        &["synthesize"],
        &["synthesized"],
        &["synthetic"],
        &["synthesis"],
        &["synthetic"],
        &["synthetically"],
        &["synthetics"],
        &["synthetic"],
        &["synthetize"],
        &["synthetized"],
        &["synthesis"],
        &["synthesis"],
        &["synthetic"],
        &["synthetic"],
    ],
    range: 2..=9,
};

static WORD_SYNR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SYNR_CHILDREN),
    value: None,
};

pub static WORD_SYNR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("onous")],
    values: &[&["synchronous"]],
    range: 5..=5,
};

static WORD_SYNP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SYNP_CHILDREN),
    value: None,
};

pub static WORD_SYNP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("hony"),
        dictgen::InsensitiveStr::Ascii("osis"),
    ],
    values: &[&["symphony"], &["synopsis"]],
    range: 4..=4,
};

static WORD_SYNO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SYNO_CHILDREN),
    value: None,
};

pub static WORD_SYNO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("mym"),
        dictgen::InsensitiveStr::Ascii("mymous"),
        dictgen::InsensitiveStr::Ascii("mynous"),
        dictgen::InsensitiveStr::Ascii("myns"),
        dictgen::InsensitiveStr::Ascii("namous"),
        dictgen::InsensitiveStr::Ascii("nim"),
        dictgen::InsensitiveStr::Ascii("nimous"),
        dictgen::InsensitiveStr::Ascii("nmyous"),
        dictgen::InsensitiveStr::Ascii("nmys"),
        dictgen::InsensitiveStr::Ascii("nomous"),
        dictgen::InsensitiveStr::Ascii("nomy"),
        dictgen::InsensitiveStr::Ascii("numous"),
        dictgen::InsensitiveStr::Ascii("nymes"),
        dictgen::InsensitiveStr::Ascii("nymis"),
        dictgen::InsensitiveStr::Ascii("nymns"),
        dictgen::InsensitiveStr::Ascii("nymos"),
        dictgen::InsensitiveStr::Ascii("nymus"),
        dictgen::InsensitiveStr::Ascii("nynous"),
        dictgen::InsensitiveStr::Ascii("pis"),
        dictgen::InsensitiveStr::Ascii("psies"),
        dictgen::InsensitiveStr::Ascii("psys"),
        dictgen::InsensitiveStr::Ascii("ym"),
        dictgen::InsensitiveStr::Ascii("ynm"),
        dictgen::InsensitiveStr::Ascii("ynms"),
    ],
    values: &[
        &["synonym"],
        &["synonymous"],
        &["synonymous"],
        &["synonyms"],
        &["synonymous"],
        &["synonym"],
        &["synonymous"],
        &["synonymous"],
        &["synonyms"],
        &["synonymous"],
        &["synonym"],
        &["synonymous"],
        &["synonyms"],
        &["synonyms"],
        &["synonyms"],
        &["synonymous"],
        &["synonyms"],
        &["synonymous"],
        &["synopsis"],
        &["synopsis"],
        &["synopsis"],
        &["synonym"],
        &["synonym"],
        &["synonyms"],
    ],
    range: 2..=6,
};

static WORD_SYNI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SYNI_CHILDREN),
    value: None,
};

pub static WORD_SYNI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("dcate")],
    values: &[&["syndicate"]],
    range: 5..=5,
};

static WORD_SYNE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SYNE_CHILDREN),
    value: None,
};

pub static WORD_SYNE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("gry")],
    values: &[&["synergy"]],
    range: 3..=3,
};

static WORD_SYND_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SYND_CHILDREN),
    value: None,
};

pub static WORD_SYND_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("acite"),
        dictgen::InsensitiveStr::Ascii("iacte"),
        dictgen::InsensitiveStr::Ascii("onic"),
        dictgen::InsensitiveStr::Ascii("rom"),
        dictgen::InsensitiveStr::Ascii("roms"),
    ],
    values: &[
        &["syndicate"],
        &["syndicate"],
        &["syntonic"],
        &["syndrome"],
        &["syndromes"],
    ],
    range: 3..=5,
};

static WORD_SYNC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SYNC_CHILDREN),
    value: None,
};

pub static WORD_SYNC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("honisation"),
        dictgen::InsensitiveStr::Ascii("honise"),
        dictgen::InsensitiveStr::Ascii("honised"),
        dictgen::InsensitiveStr::Ascii("honises"),
        dictgen::InsensitiveStr::Ascii("honising"),
        dictgen::InsensitiveStr::Ascii("honization"),
        dictgen::InsensitiveStr::Ascii("honize"),
        dictgen::InsensitiveStr::Ascii("honized"),
        dictgen::InsensitiveStr::Ascii("honizes"),
        dictgen::InsensitiveStr::Ascii("honizing"),
        dictgen::InsensitiveStr::Ascii("honous"),
        dictgen::InsensitiveStr::Ascii("honrous"),
        dictgen::InsensitiveStr::Ascii("honrously"),
        dictgen::InsensitiveStr::Ascii("hornously"),
        dictgen::InsensitiveStr::Ascii("hrnization"),
        dictgen::InsensitiveStr::Ascii("hrnonization"),
        dictgen::InsensitiveStr::Ascii("hroizing"),
        dictgen::InsensitiveStr::Ascii("hromized"),
        dictgen::InsensitiveStr::Ascii("hroneous"),
        dictgen::InsensitiveStr::Ascii("hroneously"),
        dictgen::InsensitiveStr::Ascii("hronious"),
        dictgen::InsensitiveStr::Ascii("hroniously"),
        dictgen::InsensitiveStr::Ascii("hronizaton"),
        dictgen::InsensitiveStr::Ascii("hronsouly"),
        dictgen::InsensitiveStr::Ascii("hronuous"),
        dictgen::InsensitiveStr::Ascii("hronuously"),
        dictgen::InsensitiveStr::Ascii("hronus"),
        dictgen::InsensitiveStr::Ascii("rhonise"),
        dictgen::InsensitiveStr::Ascii("rhonised"),
        dictgen::InsensitiveStr::Ascii("rhonize"),
        dictgen::InsensitiveStr::Ascii("rhonized"),
        dictgen::InsensitiveStr::Ascii("ronise"),
        dictgen::InsensitiveStr::Ascii("ronised"),
        dictgen::InsensitiveStr::Ascii("ronises"),
        dictgen::InsensitiveStr::Ascii("ronising"),
        dictgen::InsensitiveStr::Ascii("ronization"),
        dictgen::InsensitiveStr::Ascii("ronizations"),
        dictgen::InsensitiveStr::Ascii("ronize"),
        dictgen::InsensitiveStr::Ascii("ronized"),
        dictgen::InsensitiveStr::Ascii("ronizes"),
        dictgen::InsensitiveStr::Ascii("ronizing"),
        dictgen::InsensitiveStr::Ascii("ronous"),
        dictgen::InsensitiveStr::Ascii("ronously"),
        dictgen::InsensitiveStr::Ascii("ronus"),
        dictgen::InsensitiveStr::Ascii("ting"),
    ],
    values: &[
        &["synchronisation"],
        &["synchronise"],
        &["synchronised"],
        &["synchronises"],
        &["synchronising"],
        &["synchronization"],
        &["synchronize"],
        &["synchronized"],
        &["synchronizes"],
        &["synchronizing"],
        &["synchronous"],
        &["synchronous"],
        &["synchronously"],
        &["synchronously"],
        &["synchronization"],
        &["synchronization"],
        &["synchronizing"],
        &["synchronized"],
        &["synchronous"],
        &["synchronously"],
        &["synchronous"],
        &["synchronously"],
        &["synchronization"],
        &["synchronously"],
        &["synchronous"],
        &["synchronously"],
        &["synchronous"],
        &["synchronise"],
        &["synchronised"],
        &["synchronize"],
        &["synchronized"],
        &["synchronise"],
        &["synchronised"],
        &["synchronises"],
        &["synchronising"],
        &["synchronization"],
        &["synchronizations"],
        &["synchronize"],
        &["synchronized"],
        &["synchronizes"],
        &["synchronizing"],
        &["synchronous"],
        &["synchronously"],
        &["synchronous"],
        &["syncing"],
    ],
    range: 4..=12,
};

static WORD_SYNA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SYNA_CHILDREN),
    value: None,
};

pub static WORD_SYNA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("gouge"),
        dictgen::InsensitiveStr::Ascii("mic"),
        dictgen::InsensitiveStr::Ascii("x"),
    ],
    values: &[&["synagogue"], &["dynamic"], &["syntax"]],
    range: 1..=5,
};

static WORD_SYM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_SYM_CHILDREN),
    value: None,
};

static WORD_SYM_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_SYMA_NODE),
    Some(&WORD_SYMB_NODE),
    None,
    None,
    Some(&WORD_SYME_NODE),
    None,
    None,
    Some(&WORD_SYMH_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_SYMM_NODE),
    Some(&WORD_SYMN_NODE),
    Some(&WORD_SYMO_NODE),
    Some(&WORD_SYMP_NODE),
    None,
    None,
    None,
    Some(&WORD_SYMT_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_SYMT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SYMT_CHILDREN),
    value: None,
};

pub static WORD_SYMT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("pom"),
        dictgen::InsensitiveStr::Ascii("poms"),
    ],
    values: &[&["symptom"], &["symptoms"]],
    range: 3..=4,
};

static WORD_SYMP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SYMP_CHILDREN),
    value: None,
};

pub static WORD_SYMP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("athatic"),
        dictgen::InsensitiveStr::Ascii("atheic"),
        dictgen::InsensitiveStr::Ascii("athethic"),
        dictgen::InsensitiveStr::Ascii("athie"),
        dictgen::InsensitiveStr::Ascii("athiek"),
        dictgen::InsensitiveStr::Ascii("athien"),
        dictgen::InsensitiveStr::Ascii("athiers"),
        dictgen::InsensitiveStr::Ascii("athsize"),
        dictgen::InsensitiveStr::Ascii("athsizer"),
        dictgen::InsensitiveStr::Ascii("athtic"),
        dictgen::InsensitiveStr::Ascii("athyze"),
        dictgen::InsensitiveStr::Ascii("athyzers"),
        dictgen::InsensitiveStr::Ascii("aty"),
        dictgen::InsensitiveStr::Ascii("ethetic"),
        dictgen::InsensitiveStr::Ascii("ethize"),
        dictgen::InsensitiveStr::Ascii("ethizers"),
        dictgen::InsensitiveStr::Ascii("hatetic"),
        dictgen::InsensitiveStr::Ascii("hatize"),
        dictgen::InsensitiveStr::Ascii("hatized"),
        dictgen::InsensitiveStr::Ascii("hatizer"),
        dictgen::InsensitiveStr::Ascii("hatizers"),
        dictgen::InsensitiveStr::Ascii("hatizes"),
        dictgen::InsensitiveStr::Ascii("haty"),
        dictgen::InsensitiveStr::Ascii("honey"),
        dictgen::InsensitiveStr::Ascii("honity"),
        dictgen::InsensitiveStr::Ascii("ithizers"),
        dictgen::InsensitiveStr::Ascii("othetic"),
        dictgen::InsensitiveStr::Ascii("othize"),
        dictgen::InsensitiveStr::Ascii("tomes"),
        dictgen::InsensitiveStr::Ascii("tomps"),
        dictgen::InsensitiveStr::Ascii("toom"),
        dictgen::InsensitiveStr::Ascii("tum"),
        dictgen::InsensitiveStr::Ascii("tumatic"),
        dictgen::InsensitiveStr::Ascii("tumatically"),
        dictgen::InsensitiveStr::Ascii("tumaticaly"),
        dictgen::InsensitiveStr::Ascii("tumaticlly"),
        dictgen::InsensitiveStr::Ascii("tumaticly"),
        dictgen::InsensitiveStr::Ascii("tums"),
    ],
    values: &[
        &["sympathetic"],
        &["sympathetic"],
        &["sympathetic"],
        &["sympathize"],
        &["sympathize"],
        &["sympathize"],
        &["sympathizers"],
        &["sympathize"],
        &["sympathizers"],
        &["sympathetic"],
        &["sympathize"],
        &["sympathizers"],
        &["sympathy"],
        &["sympathetic"],
        &["sympathize"],
        &["sympathizers"],
        &["sympathetic"],
        &["sympathize"],
        &["sympathize"],
        &["sympathizers"],
        &["sympathizers"],
        &["sympathize"],
        &["sympathy"],
        &["symphony"],
        &["symphony"],
        &["sympathizers"],
        &["sympathetic"],
        &["sympathize"],
        &["symptoms"],
        &["symptoms"],
        &["symptom"],
        &["symptom"],
        &["symptomatic"],
        &["symptomatically"],
        &["symptomatically"],
        &["symptomatically"],
        &["symptomatically"],
        &["symptoms"],
    ],
    range: 3..=11,
};

static WORD_SYMO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SYMO_CHILDREN),
    value: None,
};

pub static WORD_SYMO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("bilic"),
        dictgen::InsensitiveStr::Ascii("bl"),
        dictgen::InsensitiveStr::Ascii("blic"),
        dictgen::InsensitiveStr::Ascii("blically"),
        dictgen::InsensitiveStr::Ascii("blism"),
        dictgen::InsensitiveStr::Ascii("bls"),
        dictgen::InsensitiveStr::Ascii("bolic"),
        dictgen::InsensitiveStr::Ascii("bolical"),
        dictgen::InsensitiveStr::Ascii("l"),
        dictgen::InsensitiveStr::Ascii("ls"),
    ],
    values: &[
        &["symbolic"],
        &["symbol"],
        &["symbolic"],
        &["symbolically"],
        &["symbolism"],
        &["symbols"],
        &["symbolic"],
        &["symbolical"],
        &["symbol"],
        &["symbols"],
    ],
    range: 1..=8,
};

static WORD_SYMN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SYMN_CHILDREN),
    value: None,
};

pub static WORD_SYMN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ol"),
        dictgen::InsensitiveStr::Ascii("ols"),
    ],
    values: &[&["symbol"], &["symbols"]],
    range: 2..=3,
};

static WORD_SYMM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SYMM_CHILDREN),
    value: None,
};

pub static WORD_SYMM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ertical"),
        dictgen::InsensitiveStr::Ascii("erty"),
        dictgen::InsensitiveStr::Ascii("etic"),
        dictgen::InsensitiveStr::Ascii("etral"),
        dictgen::InsensitiveStr::Ascii("etri"),
        dictgen::InsensitiveStr::Ascii("etria"),
        dictgen::InsensitiveStr::Ascii("etricaly"),
        dictgen::InsensitiveStr::Ascii("ety"),
        dictgen::InsensitiveStr::Ascii("tery"),
    ],
    values: &[
        &["symmetrical"],
        &["symmetry"],
        &["symmetric"],
        &["symmetric"],
        &["symmetry"],
        &["symmetrical"],
        &["symmetrically"],
        &["symmetry"],
        &["symmetry"],
    ],
    range: 3..=8,
};

static WORD_SYMH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SYMH_CHILDREN),
    value: None,
};

pub static WORD_SYMH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("pony")],
    values: &[&["symphony"]],
    range: 4..=4,
};

static WORD_SYME_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SYME_CHILDREN),
    value: None,
};

pub static WORD_SYME_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("metric"),
        dictgen::InsensitiveStr::Ascii("tri"),
        dictgen::InsensitiveStr::Ascii("tric"),
        dictgen::InsensitiveStr::Ascii("trical"),
        dictgen::InsensitiveStr::Ascii("trically"),
        dictgen::InsensitiveStr::Ascii("try"),
        dictgen::InsensitiveStr::Ascii("ttric"),
    ],
    values: &[
        &["symmetric"],
        &["symmetry"],
        &["symmetric"],
        &["symmetrical"],
        &["symmetrically"],
        &["symmetry"],
        &["symmetric"],
    ],
    range: 3..=8,
};

static WORD_SYMB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SYMB_CHILDREN),
    value: None,
};

pub static WORD_SYMB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("le"),
        dictgen::InsensitiveStr::Ascii("les"),
        dictgen::InsensitiveStr::Ascii("lic"),
        dictgen::InsensitiveStr::Ascii("o"),
        dictgen::InsensitiveStr::Ascii("olc"),
        dictgen::InsensitiveStr::Ascii("oles"),
        dictgen::InsensitiveStr::Ascii("olisch"),
        dictgen::InsensitiveStr::Ascii("olisim"),
        dictgen::InsensitiveStr::Ascii("oll"),
        dictgen::InsensitiveStr::Ascii("olsim"),
        dictgen::InsensitiveStr::Ascii("onname"),
        dictgen::InsensitiveStr::Ascii("sol"),
        dictgen::InsensitiveStr::Ascii("sols"),
    ],
    values: &[
        &["symbol"],
        &["symbols"],
        &["symbolic"],
        &["symbol"],
        &["symbolic"],
        &["symbols"],
        &["symbolic"],
        &["symbolism"],
        &["symbol"],
        &["symbolism"],
        &["symbolname"],
        &["symbol"],
        &["symbols"],
    ],
    range: 1..=6,
};

static WORD_SYMA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SYMA_CHILDREN),
    value: None,
};

pub static WORD_SYMA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ntics"),
        dictgen::InsensitiveStr::Ascii("pthetic"),
        dictgen::InsensitiveStr::Ascii("pthize"),
        dictgen::InsensitiveStr::Ascii("pthizers"),
        dictgen::InsensitiveStr::Ascii("pthy"),
    ],
    values: &[
        &["semantics"],
        &["sympathetic"],
        &["sympathize"],
        &["sympathizers"],
        &["sympathy"],
    ],
    range: 4..=8,
};

static WORD_SYL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SYL_CHILDREN),
    value: None,
};

pub static WORD_SYL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ablle"),
        dictgen::InsensitiveStr::Ascii("ablles"),
        dictgen::InsensitiveStr::Ascii("abus"),
        dictgen::InsensitiveStr::Ascii("abuses"),
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("ibol"),
        dictgen::InsensitiveStr::Ascii("inder"),
        dictgen::InsensitiveStr::Ascii("inders"),
        dictgen::InsensitiveStr::Ascii("istic"),
        dictgen::InsensitiveStr::Ascii("labe"),
        dictgen::InsensitiveStr::Ascii("label"),
        dictgen::InsensitiveStr::Ascii("labels"),
        dictgen::InsensitiveStr::Ascii("labills"),
        dictgen::InsensitiveStr::Ascii("og"),
    ],
    values: &[
        &["syllable"],
        &["syllables"],
        &["syllabus"],
        &["syllabuses", "syllabi"],
        &["style"],
        &["styles"],
        &["syllable"],
        &["cylinder"],
        &["cylinders"],
        &["stylistic"],
        &["syllable"],
        &["syllable"],
        &["syllables"],
        &["syllabus", "syllabification"],
        &["syslog"],
    ],
    range: 1..=7,
};

static WORD_SYK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SYK_CHILDREN),
    value: None,
};

pub static WORD_SYK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("walker"),
        dictgen::InsensitiveStr::Ascii("ward"),
    ],
    values: &[&["skywalker"], &["skyward"]],
    range: 4..=6,
};

static WORD_SYI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SYI_CHILDREN),
    value: None,
};

pub static WORD_SYI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("rans")],
    values: &[&["syrians"]],
    range: 4..=4,
};

static WORD_SYF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SYF_CHILDREN),
    value: None,
};

pub static WORD_SYF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("s")],
    values: &[&["sysfs"]],
    range: 1..=1,
};

static WORD_SYD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SYD_CHILDREN),
    value: None,
};

pub static WORD_SYD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("nicate"),
        dictgen::InsensitiveStr::Ascii("nrome"),
    ],
    values: &[&["syndicate"], &["syndrome"]],
    range: 5..=6,
};

static WORD_SYC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SYC_CHILDREN),
    value: None,
};

pub static WORD_SYC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("hnronization"),
        dictgen::InsensitiveStr::Ascii("hronisation"),
        dictgen::InsensitiveStr::Ascii("hronise"),
        dictgen::InsensitiveStr::Ascii("hronised"),
        dictgen::InsensitiveStr::Ascii("hroniser"),
        dictgen::InsensitiveStr::Ascii("hronises"),
        dictgen::InsensitiveStr::Ascii("hronisly"),
        dictgen::InsensitiveStr::Ascii("hronization"),
        dictgen::InsensitiveStr::Ascii("hronize"),
        dictgen::InsensitiveStr::Ascii("hronized"),
        dictgen::InsensitiveStr::Ascii("hronizer"),
        dictgen::InsensitiveStr::Ascii("hronizes"),
        dictgen::InsensitiveStr::Ascii("hronmode"),
        dictgen::InsensitiveStr::Ascii("hronous"),
        dictgen::InsensitiveStr::Ascii("hronously"),
        dictgen::InsensitiveStr::Ascii("le"),
        dictgen::InsensitiveStr::Ascii("led"),
        dictgen::InsensitiveStr::Ascii("les"),
        dictgen::InsensitiveStr::Ascii("lic"),
        dictgen::InsensitiveStr::Ascii("lical"),
        dictgen::InsensitiveStr::Ascii("ling"),
        dictgen::InsensitiveStr::Ascii("n"),
        dictgen::InsensitiveStr::Ascii("ning"),
        dictgen::InsensitiveStr::Ascii("ology"),
        dictgen::InsensitiveStr::Ascii("ronise"),
        dictgen::InsensitiveStr::Ascii("ronised"),
        dictgen::InsensitiveStr::Ascii("ronises"),
        dictgen::InsensitiveStr::Ascii("ronising"),
        dictgen::InsensitiveStr::Ascii("ronization"),
        dictgen::InsensitiveStr::Ascii("ronizations"),
        dictgen::InsensitiveStr::Ascii("ronize"),
        dictgen::InsensitiveStr::Ascii("ronized"),
        dictgen::InsensitiveStr::Ascii("ronizes"),
        dictgen::InsensitiveStr::Ascii("ronizing"),
        dictgen::InsensitiveStr::Ascii("ronous"),
        dictgen::InsensitiveStr::Ascii("ronously"),
        dictgen::InsensitiveStr::Ascii("ronus"),
        dictgen::InsensitiveStr::Ascii("ther"),
    ],
    values: &[
        &["synchronization"],
        &["synchronisation"],
        &["synchronise"],
        &["synchronised"],
        &["synchroniser"],
        &["synchronises"],
        &["synchronously"],
        &["synchronization"],
        &["synchronize"],
        &["synchronized"],
        &["synchronizer"],
        &["synchronizes"],
        &["synchronmode"],
        &["synchronous"],
        &["synchronously"],
        &["cycle"],
        &["cycled"],
        &["cycles"],
        &["cyclic", "psychic"],
        &["cyclical", "physical"],
        &["cycling"],
        &["sync"],
        &["syncing"],
        &["psychology"],
        &["synchronise"],
        &["synchronised"],
        &["synchronises"],
        &["synchronising"],
        &["synchronization"],
        &["synchronizations"],
        &["synchronize"],
        &["synchronized"],
        &["synchronizes"],
        &["synchronizing"],
        &["synchronous"],
        &["synchronously"],
        &["synchronous"],
        &["scyther"],
    ],
    range: 1..=12,
};

static WORD_SYB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SYB_CHILDREN),
    value: None,
};

pub static WORD_SYB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("system"),
        dictgen::InsensitiveStr::Ascii("systems"),
    ],
    values: &[&["subsystem"], &["subsystems"]],
    range: 6..=7,
};

static WORD_SYA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SYA_CHILDREN),
    value: None,
};

pub static WORD_SYA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ntax"),
        dictgen::InsensitiveStr::Ascii("rcuse"),
        dictgen::InsensitiveStr::Ascii("s"),
        dictgen::InsensitiveStr::Ascii("tem"),
        dictgen::InsensitiveStr::Ascii("tems"),
    ],
    values: &[
        &["syntax"],
        &["syracuse"],
        &["says"],
        &["system"],
        &["systems"],
    ],
    range: 1..=5,
};

static WORD_SX_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SX_CHILDREN),
    value: None,
};

pub static WORD_SX_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("l"),
        dictgen::InsensitiveStr::Ascii("mbol"),
        dictgen::InsensitiveStr::Ascii("mbolic"),
        dictgen::InsensitiveStr::Ascii("mbols"),
    ],
    values: &[&["xsl"], &["symbol"], &["symbolic"], &["symbols"]],
    range: 1..=6,
};

static WORD_SW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_SW_CHILDREN),
    value: None,
};

static WORD_SW_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_SWA_NODE),
    None,
    Some(&WORD_SWC_NODE),
    None,
    Some(&WORD_SWE_NODE),
    None,
    None,
    None,
    Some(&WORD_SWI_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_SWN_NODE),
    Some(&WORD_SWO_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_SWT_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_SWT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SWT_CHILDREN),
    value: None,
};

pub static WORD_SWT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ich"),
        dictgen::InsensitiveStr::Ascii("ichable"),
        dictgen::InsensitiveStr::Ascii("ichback"),
        dictgen::InsensitiveStr::Ascii("ichbacks"),
        dictgen::InsensitiveStr::Ascii("ichboard"),
        dictgen::InsensitiveStr::Ascii("ichboards"),
        dictgen::InsensitiveStr::Ascii("iched"),
        dictgen::InsensitiveStr::Ascii("icher"),
        dictgen::InsensitiveStr::Ascii("ichers"),
        dictgen::InsensitiveStr::Ascii("iches"),
        dictgen::InsensitiveStr::Ascii("iching"),
        dictgen::InsensitiveStr::Ascii("ichover"),
        dictgen::InsensitiveStr::Ascii("ichs"),
        dictgen::InsensitiveStr::Ascii("izerland"),
    ],
    values: &[
        &["switch"],
        &["switchable"],
        &["switchback"],
        &["switchbacks"],
        &["switchboard"],
        &["switchboards"],
        &["switched"],
        &["switcher"],
        &["switchers"],
        &["switches"],
        &["switching"],
        &["switchover"],
        &["switches"],
        &["switzerland"],
    ],
    range: 3..=9,
};

static WORD_SWO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SWO_CHILDREN),
    value: None,
};

pub static WORD_SWO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("wn")],
    values: &[&["shown"]],
    range: 2..=2,
};

static WORD_SWN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SWN_CHILDREN),
    value: None,
};

pub static WORD_SWN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("asea")],
    values: &[&["swansea"]],
    range: 4..=4,
};

static WORD_SWI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SWI_CHILDREN),
    value: None,
};

pub static WORD_SWI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ch"),
        dictgen::InsensitiveStr::Ascii("ched"),
        dictgen::InsensitiveStr::Ascii("ching"),
        dictgen::InsensitiveStr::Ascii("cth"),
        dictgen::InsensitiveStr::Ascii("cthed"),
        dictgen::InsensitiveStr::Ascii("cthing"),
        dictgen::InsensitiveStr::Ascii("flty"),
        dictgen::InsensitiveStr::Ascii("ftley"),
        dictgen::InsensitiveStr::Ascii("ming"),
        dictgen::InsensitiveStr::Ascii("tcheasy"),
        dictgen::InsensitiveStr::Ascii("tchign"),
        dictgen::InsensitiveStr::Ascii("tchs"),
        dictgen::InsensitiveStr::Ascii("tcht"),
        dictgen::InsensitiveStr::Ascii("tchting"),
        dictgen::InsensitiveStr::Ascii("terzland"),
        dictgen::InsensitiveStr::Ascii("tfly"),
        dictgen::InsensitiveStr::Ascii("th"),
        dictgen::InsensitiveStr::Ascii("thable"),
        dictgen::InsensitiveStr::Ascii("thc"),
        dictgen::InsensitiveStr::Ascii("thcboard"),
        dictgen::InsensitiveStr::Ascii("thced"),
        dictgen::InsensitiveStr::Ascii("thces"),
        dictgen::InsensitiveStr::Ascii("thch"),
        dictgen::InsensitiveStr::Ascii("thches"),
        dictgen::InsensitiveStr::Ascii("thching"),
        dictgen::InsensitiveStr::Ascii("thcing"),
        dictgen::InsensitiveStr::Ascii("thcover"),
        dictgen::InsensitiveStr::Ascii("thed"),
        dictgen::InsensitiveStr::Ascii("ther"),
        dictgen::InsensitiveStr::Ascii("thes"),
        dictgen::InsensitiveStr::Ascii("thing"),
        dictgen::InsensitiveStr::Ascii("tiches"),
        dictgen::InsensitiveStr::Ascii("tserland"),
        dictgen::InsensitiveStr::Ascii("tzerand"),
        dictgen::InsensitiveStr::Ascii("tzlerand"),
        dictgen::InsensitiveStr::Ascii("zterland"),
    ],
    values: &[
        &["switch"],
        &["switched"],
        &["switching"],
        &["switch"],
        &["switched"],
        &["switching"],
        &["swiftly"],
        &["swiftly"],
        &["swimming"],
        &["switches"],
        &["switching"],
        &["switches"],
        &["switched"],
        &["switching"],
        &["switzerland"],
        &["swiftly"],
        &["switch"],
        &["switchable"],
        &["switch"],
        &["switchboard"],
        &["switched"],
        &["switches"],
        &["switch"],
        &["switches"],
        &["switching"],
        &["switching"],
        &["switchover"],
        &["switched"],
        &["switcher"],
        &["switches"],
        &["switching"],
        &["switches"],
        &["switzerland"],
        &["switzerland"],
        &["switzerland"],
        &["switzerland"],
    ],
    range: 2..=8,
};

static WORD_SWE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SWE_CHILDREN),
    value: None,
};

pub static WORD_SWE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("arengin"),
        dictgen::InsensitiveStr::Ascii("arshirt"),
        dictgen::InsensitiveStr::Ascii("athsirt"),
        dictgen::InsensitiveStr::Ascii("atshit"),
        dictgen::InsensitiveStr::Ascii("atshits"),
        dictgen::InsensitiveStr::Ascii("atshort"),
        dictgen::InsensitiveStr::Ascii("atshrit"),
        dictgen::InsensitiveStr::Ascii("disch"),
        dictgen::InsensitiveStr::Ascii("erheart"),
        dictgen::InsensitiveStr::Ascii("etheat"),
        dictgen::InsensitiveStr::Ascii("etshart"),
        dictgen::InsensitiveStr::Ascii("idsh"),
        dictgen::InsensitiveStr::Ascii("pth"),
    ],
    values: &[
        &["swearing"],
        &["sweatshirt"],
        &["sweatshirt"],
        &["sweatshirt"],
        &["sweatshirt"],
        &["sweatshirt"],
        &["sweatshirt"],
        &["swedish"],
        &["sweetheart"],
        &["sweetheart"],
        &["sweetheart"],
        &["swedish"],
        &["swept"],
    ],
    range: 3..=7,
};

static WORD_SWC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SWC_CHILDREN),
    value: None,
};

pub static WORD_SWC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("loumns")],
    values: &[&["swcolumns"]],
    range: 6..=6,
};

static WORD_SWA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SWA_CHILDREN),
    value: None,
};

pub static WORD_SWA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("er"),
        dictgen::InsensitiveStr::Ascii("ering"),
        dictgen::InsensitiveStr::Ascii("ers"),
        dictgen::InsensitiveStr::Ascii("etshirt"),
        dictgen::InsensitiveStr::Ascii("lloed"),
        dictgen::InsensitiveStr::Ascii("nsoon"),
        dictgen::InsensitiveStr::Ascii("ped"),
        dictgen::InsensitiveStr::Ascii("piness"),
        dictgen::InsensitiveStr::Ascii("ping"),
        dictgen::InsensitiveStr::Ascii("rmin"),
        dictgen::InsensitiveStr::Ascii("sitka"),
        dictgen::InsensitiveStr::Ascii("skita"),
        dictgen::InsensitiveStr::Ascii("stikka"),
        dictgen::InsensitiveStr::Ascii("tiska"),
        dictgen::InsensitiveStr::Ascii("tsika"),
    ],
    values: &[
        &["swear"],
        &["swearing"],
        &["swears"],
        &["sweatshirt"],
        &["swallowed"],
        &["swanson"],
        &["swapped"],
        &["swappiness"],
        &["swapping"],
        &["swarming"],
        &["swastika"],
        &["swastika"],
        &["swastika"],
        &["swastika"],
        &["swastika"],
    ],
    range: 2..=7,
};

static WORD_SV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SV_CHILDREN),
    value: None,
};

pub static WORD_SV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ae"),
        dictgen::InsensitiveStr::Ascii("elt"),
    ],
    values: &[&["save", "suave"], &["svelte"]],
    range: 2..=3,
};

static WORD_SU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_SU_CHILDREN),
    value: None,
};

static WORD_SU_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_SUA_NODE),
    Some(&WORD_SUB_NODE),
    Some(&WORD_SUC_NODE),
    Some(&WORD_SUD_NODE),
    Some(&WORD_SUE_NODE),
    Some(&WORD_SUF_NODE),
    Some(&WORD_SUG_NODE),
    Some(&WORD_SUH_NODE),
    Some(&WORD_SUI_NODE),
    None,
    None,
    None,
    Some(&WORD_SUM_NODE),
    Some(&WORD_SUN_NODE),
    Some(&WORD_SUO_NODE),
    Some(&WORD_SUP_NODE),
    None,
    Some(&WORD_SUR_NODE),
    Some(&WORD_SUS_NODE),
    Some(&WORD_SUT_NODE),
    Some(&WORD_SUU_NODE),
    Some(&WORD_SUV_NODE),
    None,
    None,
    Some(&WORD_SUY_NODE),
    None,
];

static WORD_SUY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SUY_CHILDREN),
    value: None,
};

pub static WORD_SUY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("stem"),
        dictgen::InsensitiveStr::Ascii("stemic"),
        dictgen::InsensitiveStr::Ascii("stems"),
    ],
    values: &[&["system"], &["systemic"], &["systems"]],
    range: 4..=6,
};

static WORD_SUV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SUV_CHILDREN),
    value: None,
};

pub static WORD_SUV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("enear"),
        dictgen::InsensitiveStr::Ascii("h"),
    ],
    values: &[&["souvenir"], &["such"]],
    range: 1..=5,
};

static WORD_SUU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SUU_CHILDREN),
    value: None,
};

pub static WORD_SUU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("port"),
        dictgen::InsensitiveStr::Ascii("ported"),
        dictgen::InsensitiveStr::Ascii("porting"),
        dictgen::InsensitiveStr::Ascii("ports"),
    ],
    values: &[&["support"], &["supported"], &["supporting"], &["supports"]],
    range: 4..=7,
};

static WORD_SUT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SUT_CHILDREN),
    value: None,
};

pub static WORD_SUT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("able"),
        dictgen::InsensitiveStr::Ascii("down"),
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("isfaction"),
        dictgen::InsensitiveStr::Ascii("isfied"),
        dictgen::InsensitiveStr::Ascii("isfies"),
        dictgen::InsensitiveStr::Ascii("isfy"),
        dictgen::InsensitiveStr::Ascii("isfying"),
        dictgen::InsensitiveStr::Ascii("tle"),
        dictgen::InsensitiveStr::Ascii("tled"),
        dictgen::InsensitiveStr::Ascii("tles"),
        dictgen::InsensitiveStr::Ascii("tlety"),
        dictgen::InsensitiveStr::Ascii("tling"),
    ],
    values: &[
        &["suitable", "stable"],
        &["shutdown"],
        &["site", "suite", "suit"],
        &["satisfaction"],
        &["satisfied"],
        &["satisfies"],
        &["satisfy"],
        &["satisfying"],
        &["subtle", "shuttle"],
        &["shuttled"],
        &["shuttles"],
        &["subtlety"],
        &["shuttling"],
    ],
    range: 1..=9,
};

static WORD_SUS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_SUS_CHILDREN),
    value: None,
};

static WORD_SUS_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    Some(&WORD_SUSB_NODE),
    Some(&WORD_SUSC_NODE),
    None,
    Some(&WORD_SUSE_NODE),
    None,
    None,
    None,
    Some(&WORD_SUSI_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_SUSN_NODE),
    None,
    Some(&WORD_SUSP_NODE),
    None,
    None,
    Some(&WORD_SUSS_NODE),
    Some(&WORD_SUST_NODE),
    Some(&WORD_SUSU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_SUSU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SUSU_CHILDREN),
    value: None,
};

pub static WORD_SUSU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("pend")],
    values: &[&["suspend"]],
    range: 4..=4,
};

static WORD_SUST_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SUST_CHILDREN),
    value: None,
};

pub static WORD_SUST_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ainabillity"),
        dictgen::InsensitiveStr::Ascii("ainabiltiy"),
        dictgen::InsensitiveStr::Ascii("ainabilty"),
        dictgen::InsensitiveStr::Ascii("ainabily"),
        dictgen::InsensitiveStr::Ascii("ainaiblity"),
        dictgen::InsensitiveStr::Ascii("ainble"),
        dictgen::InsensitiveStr::Ascii("ainible"),
        dictgen::InsensitiveStr::Ascii("em"),
        dictgen::InsensitiveStr::Ascii("ems"),
        dictgen::InsensitiveStr::Ascii("itution"),
        dictgen::InsensitiveStr::Ascii("itutions"),
    ],
    values: &[
        &["sustainability"],
        &["sustainability"],
        &["sustainability"],
        &["sustainability"],
        &["sustainability"],
        &["sustainable"],
        &["sustainable"],
        &["system"],
        &["systems"],
        &["substitution"],
        &["substitutions"],
    ],
    range: 2..=11,
};

static WORD_SUSS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SUSS_CHILDREN),
    value: None,
};

pub static WORD_SUSS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eed"),
        dictgen::InsensitiveStr::Ascii("eeded"),
        dictgen::InsensitiveStr::Ascii("eeder"),
        dictgen::InsensitiveStr::Ascii("eedes"),
        dictgen::InsensitiveStr::Ascii("eeding"),
        dictgen::InsensitiveStr::Ascii("eeds"),
        dictgen::InsensitiveStr::Ascii("inct"),
    ],
    values: &[
        &["secede"],
        &["seceded"],
        &["seceder"],
        &["secedes"],
        &["seceding"],
        &["secedes"],
        &["succinct"],
    ],
    range: 3..=6,
};

static WORD_SUSP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SUSP_CHILDREN),
    value: None,
};

pub static WORD_SUSP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ecions"),
        dictgen::InsensitiveStr::Ascii("ecious"),
        dictgen::InsensitiveStr::Ascii("eciously"),
        dictgen::InsensitiveStr::Ascii("ectes"),
        dictgen::InsensitiveStr::Ascii("ectible"),
        dictgen::InsensitiveStr::Ascii("edn"),
        dictgen::InsensitiveStr::Ascii("encion"),
        dictgen::InsensitiveStr::Ascii("endeds"),
        dictgen::InsensitiveStr::Ascii("endes"),
        dictgen::InsensitiveStr::Ascii("ened"),
        dictgen::InsensitiveStr::Ascii("eneded"),
        dictgen::InsensitiveStr::Ascii("ensie"),
        dictgen::InsensitiveStr::Ascii("enso"),
        dictgen::InsensitiveStr::Ascii("ention"),
        dictgen::InsensitiveStr::Ascii("icians"),
        dictgen::InsensitiveStr::Ascii("iciois"),
        dictgen::InsensitiveStr::Ascii("icios"),
        dictgen::InsensitiveStr::Ascii("iciosly"),
        dictgen::InsensitiveStr::Ascii("icioso"),
        dictgen::InsensitiveStr::Ascii("icioulsy"),
        dictgen::InsensitiveStr::Ascii("iciouly"),
        dictgen::InsensitiveStr::Ascii("icioun"),
        dictgen::InsensitiveStr::Ascii("iciouns"),
        dictgen::InsensitiveStr::Ascii("icision"),
        dictgen::InsensitiveStr::Ascii("icison"),
        dictgen::InsensitiveStr::Ascii("icisons"),
        dictgen::InsensitiveStr::Ascii("iciuos"),
        dictgen::InsensitiveStr::Ascii("iciuosly"),
        dictgen::InsensitiveStr::Ascii("icous"),
        dictgen::InsensitiveStr::Ascii("icously"),
        dictgen::InsensitiveStr::Ascii("icsion"),
        dictgen::InsensitiveStr::Ascii("ision"),
        dictgen::InsensitiveStr::Ascii("isions"),
        dictgen::InsensitiveStr::Ascii("isious"),
        dictgen::InsensitiveStr::Ascii("isiously"),
        dictgen::InsensitiveStr::Ascii("itions"),
        dictgen::InsensitiveStr::Ascii("send"),
    ],
    values: &[
        &["suspicions"],
        &["suspicious"],
        &["suspiciously"],
        &["suspects"],
        &["susceptible"],
        &["suspend"],
        &["suspension"],
        &["suspense"],
        &["suspense"],
        &["suspend"],
        &["suspended"],
        &["suspense"],
        &["suspension"],
        &["suspension"],
        &["suspicions"],
        &["suspicions"],
        &["suspicious"],
        &["suspiciously"],
        &["suspicions"],
        &["suspiciously"],
        &["suspiciously"],
        &["suspicion"],
        &["suspicion"],
        &["suspicions"],
        &["suspicions"],
        &["suspicions"],
        &["suspicions"],
        &["suspiciously"],
        &["suspicious"],
        &["suspiciously"],
        &["suspicions"],
        &["suspicion"],
        &["suspicions"],
        &["suspicious"],
        &["suspiciously"],
        &["suspicions"],
        &["suspend"],
    ],
    range: 3..=8,
};

static WORD_SUSN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SUSN_CHILDREN),
    value: None,
};

pub static WORD_SUSN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("creen")],
    values: &[&["sunscreen"]],
    range: 5..=5,
};

static WORD_SUSI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SUSI_CHILDREN),
    value: None,
};

pub static WORD_SUSI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("nct"),
        dictgen::InsensitiveStr::Ascii("nctly"),
        dictgen::InsensitiveStr::Ascii("nkt"),
    ],
    values: &[&["succinct"], &["succinctly"], &["succinct"]],
    range: 3..=5,
};

static WORD_SUSE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SUSE_CHILDREN),
    value: None,
};

pub static WORD_SUSE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cptible"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("eded"),
        dictgen::InsensitiveStr::Ascii("eder"),
        dictgen::InsensitiveStr::Ascii("edes"),
        dictgen::InsensitiveStr::Ascii("eding"),
        dictgen::InsensitiveStr::Ascii("eds"),
        dictgen::InsensitiveStr::Ascii("pect"),
        dictgen::InsensitiveStr::Ascii("ptable"),
        dictgen::InsensitiveStr::Ascii("ptible"),
    ],
    values: &[
        &["susceptible"],
        &["secede"],
        &["seceded"],
        &["seceder"],
        &["secedes"],
        &["seceding"],
        &["secedes"],
        &["suspect"],
        &["susceptible"],
        &["susceptible"],
    ],
    range: 2..=7,
};

static WORD_SUSC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SUSC_CHILDREN),
    value: None,
};

pub static WORD_SUSC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ede"),
        dictgen::InsensitiveStr::Ascii("eded"),
        dictgen::InsensitiveStr::Ascii("eder"),
        dictgen::InsensitiveStr::Ascii("eders"),
        dictgen::InsensitiveStr::Ascii("edes"),
        dictgen::InsensitiveStr::Ascii("eding"),
        dictgen::InsensitiveStr::Ascii("epitble"),
        dictgen::InsensitiveStr::Ascii("eptable"),
        dictgen::InsensitiveStr::Ascii("eptiable"),
        dictgen::InsensitiveStr::Ascii("eptibile"),
        dictgen::InsensitiveStr::Ascii("petible"),
        dictgen::InsensitiveStr::Ascii("ribe"),
        dictgen::InsensitiveStr::Ascii("ribed"),
        dictgen::InsensitiveStr::Ascii("ribes"),
        dictgen::InsensitiveStr::Ascii("ript"),
    ],
    values: &[
        &["secede", "succeed"],
        &["seceded", "succeeded"],
        &["seceder"],
        &["seceders"],
        &["secedes", "succeeds"],
        &["seceding", "succeeding"],
        &["susceptible"],
        &["susceptible"],
        &["susceptible"],
        &["susceptible"],
        &["susceptible"],
        &["subscribe"],
        &["subscribed"],
        &["subscribes"],
        &["subscript"],
    ],
    range: 3..=8,
};

static WORD_SUSB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SUSB_CHILDREN),
    value: None,
};

pub static WORD_SUSB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cribe"),
        dictgen::InsensitiveStr::Ascii("cribed"),
        dictgen::InsensitiveStr::Ascii("system"),
        dictgen::InsensitiveStr::Ascii("systems"),
        dictgen::InsensitiveStr::Ascii("sytem"),
        dictgen::InsensitiveStr::Ascii("sytems"),
        dictgen::InsensitiveStr::Ascii("tantial"),
        dictgen::InsensitiveStr::Ascii("tantially"),
        dictgen::InsensitiveStr::Ascii("tantive"),
        dictgen::InsensitiveStr::Ascii("trate"),
    ],
    values: &[
        &["subscribe"],
        &["subscribed"],
        &["subsystem"],
        &["subsystems"],
        &["subsystem"],
        &["subsystems"],
        &["substantial"],
        &["substantially"],
        &["substantive"],
        &["substrate"],
    ],
    range: 5..=9,
};

static WORD_SUR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_SUR_CHILDREN),
    value: Some(&["sure"]),
};

static WORD_SUR_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    Some(&WORD_SURB_NODE),
    None,
    None,
    None,
    Some(&WORD_SURF_NODE),
    Some(&WORD_SURG_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_SURL_NODE),
    None,
    None,
    Some(&WORD_SURO_NODE),
    Some(&WORD_SURP_NODE),
    None,
    Some(&WORD_SURR_NODE),
    None,
    None,
    None,
    Some(&WORD_SURV_NODE),
    None,
    None,
    None,
    None,
];

static WORD_SURV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SURV_CHILDREN),
    value: None,
};

pub static WORD_SURV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aillance"),
        dictgen::InsensitiveStr::Ascii("aillence"),
        dictgen::InsensitiveStr::Ascii("allience"),
        dictgen::InsensitiveStr::Ascii("avibility"),
        dictgen::InsensitiveStr::Ascii("ay"),
        dictgen::InsensitiveStr::Ascii("ays"),
        dictgen::InsensitiveStr::Ascii("eilence"),
        dictgen::InsensitiveStr::Ascii("eill"),
        dictgen::InsensitiveStr::Ascii("eillence"),
        dictgen::InsensitiveStr::Ascii("elliance"),
        dictgen::InsensitiveStr::Ascii("eyer"),
        dictgen::InsensitiveStr::Ascii("ibability"),
        dictgen::InsensitiveStr::Ascii("ice"),
        dictgen::InsensitiveStr::Ascii("iced"),
        dictgen::InsensitiveStr::Ascii("ices"),
        dictgen::InsensitiveStr::Ascii("iellance"),
        dictgen::InsensitiveStr::Ascii("ivabiity"),
        dictgen::InsensitiveStr::Ascii("ivabililty"),
        dictgen::InsensitiveStr::Ascii("ivabiliy"),
        dictgen::InsensitiveStr::Ascii("ivabillity"),
        dictgen::InsensitiveStr::Ascii("ivabiltiy"),
        dictgen::InsensitiveStr::Ascii("ivabilty"),
        dictgen::InsensitiveStr::Ascii("ivabily"),
        dictgen::InsensitiveStr::Ascii("ivalibity"),
        dictgen::InsensitiveStr::Ascii("ivavility"),
        dictgen::InsensitiveStr::Ascii("ivebility"),
        dictgen::InsensitiveStr::Ascii("iver"),
        dictgen::InsensitiveStr::Ascii("ivers"),
        dictgen::InsensitiveStr::Ascii("ivied"),
        dictgen::InsensitiveStr::Ascii("ivour"),
        dictgen::InsensitiveStr::Ascii("ivours"),
    ],
    values: &[
        &["surveillance"],
        &["surveillance"],
        &["surveillance"],
        &["survivability"],
        &["survey"],
        &["surveys"],
        &["surveillance"],
        &["surveil"],
        &["surveillance"],
        &["surveillance"],
        &["surveyor"],
        &["survivability"],
        &["service", "survive"],
        &["serviced", "survived"],
        &["services", "survives"],
        &["surveillance"],
        &["survivability"],
        &["survivability"],
        &["survivability"],
        &["survivability"],
        &["survivability"],
        &["survivability"],
        &["survivability"],
        &["survivability"],
        &["survivability"],
        &["survivability"],
        &["survivor"],
        &["survivors"],
        &["survived"],
        &["survivor"],
        &["survivor"],
    ],
    range: 2..=10,
};

static WORD_SURR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SURR_CHILDREN),
    value: None,
};

pub static WORD_SURR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("egat"),
        dictgen::InsensitiveStr::Ascii("ended"),
        dictgen::InsensitiveStr::Ascii("enderd"),
        dictgen::InsensitiveStr::Ascii("enderred"),
        dictgen::InsensitiveStr::Ascii("epetitious"),
        dictgen::InsensitiveStr::Ascii("epetitiously"),
        dictgen::InsensitiveStr::Ascii("eptious"),
        dictgen::InsensitiveStr::Ascii("eptiously"),
        dictgen::InsensitiveStr::Ascii("ogage"),
        dictgen::InsensitiveStr::Ascii("onded"),
        dictgen::InsensitiveStr::Ascii("oud"),
        dictgen::InsensitiveStr::Ascii("ouded"),
        dictgen::InsensitiveStr::Ascii("ouding"),
        dictgen::InsensitiveStr::Ascii("oundes"),
        dictgen::InsensitiveStr::Ascii("oundig"),
        dictgen::InsensitiveStr::Ascii("oundign"),
        dictgen::InsensitiveStr::Ascii("oundigs"),
        dictgen::InsensitiveStr::Ascii("oundins"),
        dictgen::InsensitiveStr::Ascii("oundngs"),
        dictgen::InsensitiveStr::Ascii("ouned"),
        dictgen::InsensitiveStr::Ascii("ouns"),
        dictgen::InsensitiveStr::Ascii("rounded"),
        dictgen::InsensitiveStr::Ascii("undering"),
    ],
    values: &[
        &["surrogate"],
        &["surrounded", "surrendered"],
        &["surrendered"],
        &["surrendered"],
        &["surreptitious"],
        &["surreptitiously"],
        &["surreptitious"],
        &["surreptitiously"],
        &["surrogate"],
        &["surrounded"],
        &["surround"],
        &["surrounded"],
        &["surrounding"],
        &["surrounds"],
        &["surroundings"],
        &["surroundings"],
        &["surrounds"],
        &["surrounds"],
        &["surrounds"],
        &["surround", "surrounded"],
        &["surrounds"],
        &["surrounded"],
        &["surrendering"],
    ],
    range: 3..=12,
};

static WORD_SURP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SURP_CHILDREN),
    value: None,
};

pub static WORD_SURP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ases"),
        dictgen::InsensitiveStr::Ascii("emacist"),
        dictgen::InsensitiveStr::Ascii("eme"),
        dictgen::InsensitiveStr::Ascii("ise"),
        dictgen::InsensitiveStr::Ascii("ises"),
        dictgen::InsensitiveStr::Ascii("lanted"),
        dictgen::InsensitiveStr::Ascii("ort"),
        dictgen::InsensitiveStr::Ascii("orted"),
        dictgen::InsensitiveStr::Ascii("ress"),
        dictgen::InsensitiveStr::Ascii("ressed"),
        dictgen::InsensitiveStr::Ascii("resses"),
        dictgen::InsensitiveStr::Ascii("ressing"),
        dictgen::InsensitiveStr::Ascii("risinlgy"),
        dictgen::InsensitiveStr::Ascii("risinly"),
        dictgen::InsensitiveStr::Ascii("rize"),
        dictgen::InsensitiveStr::Ascii("rized"),
        dictgen::InsensitiveStr::Ascii("rizing"),
        dictgen::InsensitiveStr::Ascii("rizingly"),
    ],
    values: &[
        &["surpass"],
        &["supremacist"],
        &["supreme"],
        &["surprise"],
        &["surprises"],
        &["supplanted"],
        &["support"],
        &["supported"],
        &["suppress"],
        &["suppressed"],
        &["suppresses"],
        &["suppressing"],
        &["surprisingly"],
        &["surprisingly"],
        &["surprise"],
        &["surprised"],
        &["surprising"],
        &["surprisingly"],
    ],
    range: 3..=8,
};

static WORD_SURO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SURO_CHILDREN),
    value: None,
};

pub static WORD_SURO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("und"),
        dictgen::InsensitiveStr::Ascii("unded"),
        dictgen::InsensitiveStr::Ascii("unding"),
        dictgen::InsensitiveStr::Ascii("undings"),
        dictgen::InsensitiveStr::Ascii("unds"),
    ],
    values: &[
        &["surround"],
        &["surrounded"],
        &["surrounding"],
        &["surroundings"],
        &["surrounds"],
    ],
    range: 3..=7,
};

static WORD_SURL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SURL_CHILDREN),
    value: None,
};

pub static WORD_SURL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ey")],
    values: &[&["surly", "surely"]],
    range: 2..=2,
};

static WORD_SURG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SURG_CHILDREN),
    value: None,
};

pub static WORD_SURG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("est"),
        dictgen::InsensitiveStr::Ascii("ested"),
        dictgen::InsensitiveStr::Ascii("estion"),
        dictgen::InsensitiveStr::Ascii("estions"),
        dictgen::InsensitiveStr::Ascii("ests"),
    ],
    values: &[
        &["suggest"],
        &["suggested"],
        &["suggestion"],
        &["suggestions"],
        &["suggests"],
    ],
    range: 3..=7,
};

static WORD_SURF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SURF_CHILDREN),
    value: None,
};

pub static WORD_SURF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aec"),
        dictgen::InsensitiveStr::Ascii("ce"),
    ],
    values: &[&["surface"], &["surface"]],
    range: 2..=3,
};

static WORD_SURB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SURB_CHILDREN),
    value: None,
};

pub static WORD_SURB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ert"),
        dictgen::InsensitiveStr::Ascii("uban"),
    ],
    values: &[&["sherbert"], &["suburban"]],
    range: 3..=4,
};

static WORD_SUP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_SUP_CHILDREN),
    value: None,
};

static WORD_SUP_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    None,
    None,
    Some(&WORD_SUPE_NODE),
    None,
    None,
    Some(&WORD_SUPH_NODE),
    Some(&WORD_SUPI_NODE),
    None,
    None,
    Some(&WORD_SUPL_NODE),
    None,
    None,
    Some(&WORD_SUPO_NODE),
    Some(&WORD_SUPP_NODE),
    None,
    Some(&WORD_SUPR_NODE),
    Some(&WORD_SUPS_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_SUPS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SUPS_CHILDREN),
    value: None,
};

pub static WORD_SUPS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cription"),
        dictgen::InsensitiveStr::Ascii("criptions"),
        dictgen::InsensitiveStr::Ascii("ects"),
        dictgen::InsensitiveStr::Ascii("end"),
        dictgen::InsensitiveStr::Ascii("ense"),
        dictgen::InsensitiveStr::Ascii("ension"),
        dictgen::InsensitiveStr::Ascii("icion"),
        dictgen::InsensitiveStr::Ascii("icions"),
        dictgen::InsensitiveStr::Ascii("icious"),
        dictgen::InsensitiveStr::Ascii("iciously"),
        dictgen::InsensitiveStr::Ascii("pect"),
        dictgen::InsensitiveStr::Ascii("pected"),
        dictgen::InsensitiveStr::Ascii("pecting"),
        dictgen::InsensitiveStr::Ascii("pects"),
    ],
    values: &[
        &["subscription"],
        &["subscriptions"],
        &["suspects"],
        &["suspend"],
        &["suspense"],
        &["suspension"],
        &["suspicion"],
        &["suspicions"],
        &["suspicious"],
        &["suspiciously"],
        &["suspect"],
        &["suspected"],
        &["suspecting"],
        &["suspects"],
    ],
    range: 3..=9,
};

static WORD_SUPR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SUPR_CHILDREN),
    value: None,
};

pub static WORD_SUPR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("amacist"),
        dictgen::InsensitiveStr::Ascii("ass"),
        dictgen::InsensitiveStr::Ascii("assing"),
        dictgen::InsensitiveStr::Ascii("emacits"),
        dictgen::InsensitiveStr::Ascii("emasist"),
        dictgen::InsensitiveStr::Ascii("emicist"),
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("esed"),
        dictgen::InsensitiveStr::Ascii("eses"),
        dictgen::InsensitiveStr::Ascii("esing"),
        dictgen::InsensitiveStr::Ascii("esion"),
        dictgen::InsensitiveStr::Ascii("ess"),
        dictgen::InsensitiveStr::Ascii("essed"),
        dictgen::InsensitiveStr::Ascii("esses"),
        dictgen::InsensitiveStr::Ascii("essible"),
        dictgen::InsensitiveStr::Ascii("essing"),
        dictgen::InsensitiveStr::Ascii("ession"),
        dictgen::InsensitiveStr::Ascii("essions"),
        dictgen::InsensitiveStr::Ascii("essor"),
        dictgen::InsensitiveStr::Ascii("essors"),
        dictgen::InsensitiveStr::Ascii("esssion"),
        dictgen::InsensitiveStr::Ascii("imacist"),
        dictgen::InsensitiveStr::Ascii("ious"),
        dictgen::InsensitiveStr::Ascii("isd"),
        dictgen::InsensitiveStr::Ascii("ise"),
        dictgen::InsensitiveStr::Ascii("ised"),
        dictgen::InsensitiveStr::Ascii("ises"),
        dictgen::InsensitiveStr::Ascii("ising"),
        dictgen::InsensitiveStr::Ascii("isingly"),
        dictgen::InsensitiveStr::Ascii("ize"),
        dictgen::InsensitiveStr::Ascii("ized"),
        dictgen::InsensitiveStr::Ascii("izing"),
        dictgen::InsensitiveStr::Ascii("izingly"),
        dictgen::InsensitiveStr::Ascii("sied"),
    ],
    values: &[
        &["supremacist"],
        &["surpass"],
        &["surpassing"],
        &["supremacist"],
        &["supremacist"],
        &["supremacist"],
        &["suppress"],
        &["suppressed"],
        &["suppresses"],
        &["suppressing"],
        &["suppression"],
        &["suppress"],
        &["suppressed"],
        &["suppresses"],
        &["suppressible"],
        &["suppressing"],
        &["suppression"],
        &["suppressions"],
        &["suppressor"],
        &["suppressors"],
        &["suppression"],
        &["supremacist"],
        &["spurious"],
        &["surprised"],
        &["surprise"],
        &["surprised"],
        &["surprises"],
        &["surprising"],
        &["surprisingly"],
        &["surprise"],
        &["surprised"],
        &["surprising"],
        &["surprisingly"],
        &["surprised"],
    ],
    range: 2..=7,
};

static WORD_SUPP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_SUPP_CHILDREN),
    value: None,
};

static WORD_SUPP_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    None,
    None,
    Some(&WORD_SUPPE_NODE),
    None,
    None,
    None,
    Some(&WORD_SUPPI_NODE),
    None,
    None,
    Some(&WORD_SUPPL_NODE),
    None,
    None,
    Some(&WORD_SUPPO_NODE),
    Some(&WORD_SUPPP_NODE),
    None,
    Some(&WORD_SUPPR_NODE),
    None,
    None,
    Some(&WORD_SUPPU_NODE),
    None,
    None,
    None,
    Some(&WORD_SUPPY_NODE),
    None,
];

static WORD_SUPPY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SUPPY_CHILDREN),
    value: Some(&["supply"]),
};

pub static WORD_SUPPY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ing")],
    values: &[&["supplying"]],
    range: 3..=3,
};

static WORD_SUPPU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SUPPU_CHILDREN),
    value: None,
};

pub static WORD_SUPPU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("rt"),
        dictgen::InsensitiveStr::Ascii("rted"),
        dictgen::InsensitiveStr::Ascii("rter"),
        dictgen::InsensitiveStr::Ascii("rters"),
        dictgen::InsensitiveStr::Ascii("rting"),
        dictgen::InsensitiveStr::Ascii("rtive"),
        dictgen::InsensitiveStr::Ascii("rts"),
    ],
    values: &[
        &["support"],
        &["supported"],
        &["supporter"],
        &["supporters"],
        &["supporting"],
        &["supportive"],
        &["supports"],
    ],
    range: 2..=5,
};

static WORD_SUPPR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SUPPR_CHILDREN),
    value: None,
};

pub static WORD_SUPPR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("esed"),
        dictgen::InsensitiveStr::Ascii("eses"),
        dictgen::InsensitiveStr::Ascii("esion"),
        dictgen::InsensitiveStr::Ascii("esions"),
        dictgen::InsensitiveStr::Ascii("esors"),
        dictgen::InsensitiveStr::Ascii("essin"),
        dictgen::InsensitiveStr::Ascii("essingd"),
        dictgen::InsensitiveStr::Ascii("essio"),
        dictgen::InsensitiveStr::Ascii("esson"),
        dictgen::InsensitiveStr::Ascii("esssion"),
        dictgen::InsensitiveStr::Ascii("esssor"),
        dictgen::InsensitiveStr::Ascii("ot"),
        dictgen::InsensitiveStr::Ascii("oted"),
        dictgen::InsensitiveStr::Ascii("oter"),
        dictgen::InsensitiveStr::Ascii("oters"),
        dictgen::InsensitiveStr::Ascii("oting"),
        dictgen::InsensitiveStr::Ascii("ots"),
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("ted"),
        dictgen::InsensitiveStr::Ascii("ting"),
    ],
    values: &[
        &["suppress"],
        &["suppressed"],
        &["suppress"],
        &["suppression"],
        &["suppression", "suppressions"],
        &["suppressor"],
        &["suppression"],
        &["suppressing"],
        &["suppressor"],
        &["suppression"],
        &["suppression"],
        &["suppressor"],
        &["support"],
        &["supported"],
        &["supporter"],
        &["supporters"],
        &["supporting"],
        &["supports"],
        &["support"],
        &["supported"],
        &["supporting"],
    ],
    range: 1..=7,
};

static WORD_SUPPP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SUPPP_CHILDREN),
    value: None,
};

pub static WORD_SUPPP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("lied"),
        dictgen::InsensitiveStr::Ascii("ored"),
        dictgen::InsensitiveStr::Ascii("ort"),
        dictgen::InsensitiveStr::Ascii("orted"),
        dictgen::InsensitiveStr::Ascii("orting"),
        dictgen::InsensitiveStr::Ascii("orts"),
    ],
    values: &[
        &["supplied"],
        &["supported"],
        &["support"],
        &["supported"],
        &["supporting"],
        &["supports"],
    ],
    range: 3..=6,
};

static WORD_SUPPO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SUPPO_CHILDREN),
    value: None,
};

pub static WORD_SUPPO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("ert"),
        dictgen::InsensitiveStr::Ascii("ort"),
        dictgen::InsensitiveStr::Ascii("orts"),
        dictgen::InsensitiveStr::Ascii("pose"),
        dictgen::InsensitiveStr::Ascii("prt"),
        dictgen::InsensitiveStr::Ascii("prted"),
        dictgen::InsensitiveStr::Ascii("r"),
        dictgen::InsensitiveStr::Ascii("red"),
        dictgen::InsensitiveStr::Ascii("ression"),
        dictgen::InsensitiveStr::Ascii("ring"),
        dictgen::InsensitiveStr::Ascii("ritng"),
        dictgen::InsensitiveStr::Ascii("rre"),
        dictgen::InsensitiveStr::Ascii("rtare"),
        dictgen::InsensitiveStr::Ascii("rtd"),
        dictgen::InsensitiveStr::Ascii("rte"),
        dictgen::InsensitiveStr::Ascii("rtes"),
        dictgen::InsensitiveStr::Ascii("rtet"),
        dictgen::InsensitiveStr::Ascii("rteur"),
        dictgen::InsensitiveStr::Ascii("rteurs"),
        dictgen::InsensitiveStr::Ascii("rtied"),
        dictgen::InsensitiveStr::Ascii("rtin"),
        dictgen::InsensitiveStr::Ascii("rtors"),
        dictgen::InsensitiveStr::Ascii("rtt"),
        dictgen::InsensitiveStr::Ascii("rtted"),
        dictgen::InsensitiveStr::Ascii("rtting"),
        dictgen::InsensitiveStr::Ascii("rtts"),
        dictgen::InsensitiveStr::Ascii("sdely"),
        dictgen::InsensitiveStr::Ascii("seable"),
        dictgen::InsensitiveStr::Ascii("sebly"),
        dictgen::InsensitiveStr::Ascii("seded"),
        dictgen::InsensitiveStr::Ascii("sedely"),
        dictgen::InsensitiveStr::Ascii("seds"),
        dictgen::InsensitiveStr::Ascii("sedy"),
        dictgen::InsensitiveStr::Ascii("sidely"),
        dictgen::InsensitiveStr::Ascii("sidly"),
        dictgen::InsensitiveStr::Ascii("singly"),
        dictgen::InsensitiveStr::Ascii("ssed"),
        dictgen::InsensitiveStr::Ascii("st"),
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("ted"),
    ],
    values: &[
        &["supposed"],
        &["support"],
        &["support"],
        &["supports"],
        &["suppose"],
        &["support"],
        &["supported"],
        &["support"],
        &["supported"],
        &["suppression"],
        &["supporting"],
        &["supporting"],
        &["supporters"],
        &["supporters"],
        &["supported"],
        &["supported", "supporter"],
        &["supports"],
        &["supporter", "supported"],
        &["supporter"],
        &["supporters"],
        &["supported"],
        &["supporting"],
        &["supporters"],
        &["support"],
        &["supported"],
        &["supporting"],
        &["supports"],
        &["supposedly"],
        &["supposable"],
        &["supposedly"],
        &["supposed"],
        &["supposedly"],
        &["supposed"],
        &["supposedly"],
        &["supposedly"],
        &["supposedly"],
        &["supposedly"],
        &["supposed"],
        &["supports", "support", "suppose"],
        &["support"],
        &["supported"],
    ],
    range: 1..=7,
};

static WORD_SUPPL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SUPPL_CHILDREN),
    value: None,
};

pub static WORD_SUPPL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ament"),
        dictgen::InsensitiveStr::Ascii("amental"),
        dictgen::InsensitiveStr::Ascii("amented"),
        dictgen::InsensitiveStr::Ascii("aments"),
        dictgen::InsensitiveStr::Ascii("emant"),
        dictgen::InsensitiveStr::Ascii("emetal"),
        dictgen::InsensitiveStr::Ascii("emets"),
        dictgen::InsensitiveStr::Ascii("iad"),
        dictgen::InsensitiveStr::Ascii("iementing"),
        dictgen::InsensitiveStr::Ascii("iment"),
        dictgen::InsensitiveStr::Ascii("imental"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("yed"),
    ],
    values: &[
        &["supplement"],
        &["supplemental"],
        &["supplemented"],
        &["supplements"],
        &["supplemental"],
        &["supplemental"],
        &["supplements"],
        &["supplied"],
        &["supplementing"],
        &["supplement"],
        &["supplemental"],
        &["supplying"],
        &["supplied"],
    ],
    range: 3..=9,
};

static WORD_SUPPI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SUPPI_CHILDREN),
    value: None,
};

pub static WORD_SUPPI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("er"),
        dictgen::InsensitiveStr::Ascii("es"),
    ],
    values: &[&["supplied"], &["supplier"], &["supplies"]],
    range: 2..=2,
};

static WORD_SUPPE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SUPPE_CHILDREN),
    value: None,
};

pub static WORD_SUPPE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("rssor")],
    values: &[&["suppressor"]],
    range: 5..=5,
};

static WORD_SUPO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SUPO_CHILDREN),
    value: None,
};

pub static WORD_SUPO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ort"),
        dictgen::InsensitiveStr::Ascii("orted"),
        dictgen::InsensitiveStr::Ascii("orting"),
        dictgen::InsensitiveStr::Ascii("orts"),
        dictgen::InsensitiveStr::Ascii("rt"),
        dictgen::InsensitiveStr::Ascii("rted"),
        dictgen::InsensitiveStr::Ascii("rting"),
        dictgen::InsensitiveStr::Ascii("rts"),
        dictgen::InsensitiveStr::Ascii("rtted"),
        dictgen::InsensitiveStr::Ascii("sable"),
        dictgen::InsensitiveStr::Ascii("se"),
        dictgen::InsensitiveStr::Ascii("seable"),
        dictgen::InsensitiveStr::Ascii("sed"),
        dictgen::InsensitiveStr::Ascii("sedly"),
        dictgen::InsensitiveStr::Ascii("ses"),
        dictgen::InsensitiveStr::Ascii("sing"),
        dictgen::InsensitiveStr::Ascii("sse"),
    ],
    values: &[
        &["support"],
        &["supported"],
        &["supporting"],
        &["supports"],
        &["support"],
        &["supported"],
        &["supporting"],
        &["supports"],
        &["supported"],
        &["supposable"],
        &["suppose"],
        &["supposable"],
        &["supposed"],
        &["supposedly"],
        &["supposes"],
        &["supposing"],
        &["suppose"],
    ],
    range: 2..=6,
};

static WORD_SUPL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SUPL_CHILDREN),
    value: None,
};

pub static WORD_SUPL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ant"),
        dictgen::InsensitiveStr::Ascii("anted"),
        dictgen::InsensitiveStr::Ascii("anting"),
        dictgen::InsensitiveStr::Ascii("ants"),
        dictgen::InsensitiveStr::Ascii("ementary"),
        dictgen::InsensitiveStr::Ascii("ied"),
        dictgen::InsensitiveStr::Ascii("imented"),
        dictgen::InsensitiveStr::Ascii("lemental"),
        dictgen::InsensitiveStr::Ascii("lies"),
    ],
    values: &[
        &["supplant"],
        &["supplanted"],
        &["supplanting"],
        &["supplants"],
        &["supplementary"],
        &["supplied"],
        &["supplemented"],
        &["supplemental"],
        &["supplies"],
    ],
    range: 3..=8,
};

static WORD_SUPI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SUPI_CHILDREN),
    value: None,
};

pub static WORD_SUPI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("rsed")],
    values: &[&["surprised"]],
    range: 4..=4,
};

static WORD_SUPH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SUPH_CHILDREN),
    value: None,
};

pub static WORD_SUPH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("isticated")],
    values: &[&["sophisticated"]],
    range: 9..=9,
};

static WORD_SUPE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_SUPE_CHILDREN),
    value: None,
};

static WORD_SUPE_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    Some(&WORD_SUPEB_NODE),
    None,
    None,
    Some(&WORD_SUPEE_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_SUPER_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_SUPER_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_SUPER_CHILDREN),
    value: None,
};

static WORD_SUPER_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    Some(&WORD_SUPERB_NODE),
    Some(&WORD_SUPERC_NODE),
    None,
    None,
    Some(&WORD_SUPERF_NODE),
    None,
    Some(&WORD_SUPERH_NODE),
    Some(&WORD_SUPERI_NODE),
    None,
    None,
    None,
    Some(&WORD_SUPERM_NODE),
    Some(&WORD_SUPERN_NODE),
    Some(&WORD_SUPERO_NODE),
    Some(&WORD_SUPERP_NODE),
    None,
    None,
    Some(&WORD_SUPERS_NODE),
    None,
    None,
    Some(&WORD_SUPERV_NODE),
    None,
    None,
    None,
    None,
];

static WORD_SUPERV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SUPERV_CHILDREN),
    value: None,
};

pub static WORD_SUPERV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("iors"),
        dictgen::InsensitiveStr::Ascii("iosr"),
        dictgen::InsensitiveStr::Ascii("isar"),
        dictgen::InsensitiveStr::Ascii("iser"),
        dictgen::InsensitiveStr::Ascii("isers"),
        dictgen::InsensitiveStr::Ascii("isin"),
        dictgen::InsensitiveStr::Ascii("isior"),
        dictgen::InsensitiveStr::Ascii("isiors"),
        dictgen::InsensitiveStr::Ascii("iso"),
        dictgen::InsensitiveStr::Ascii("ison"),
        dictgen::InsensitiveStr::Ascii("isoras"),
        dictgen::InsensitiveStr::Ascii("isores"),
        dictgen::InsensitiveStr::Ascii("sior"),
    ],
    values: &[
        &["supervisors"],
        &["supervisors"],
        &["supervisor"],
        &["supervisor"],
        &["supervisors"],
        &["supervision"],
        &["supervisor"],
        &["supervisors"],
        &["supervision"],
        &["supervision"],
        &["supervisors"],
        &["supervisors"],
        &["supervisors"],
    ],
    range: 3..=6,
};

static WORD_SUPERS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SUPERS_CHILDREN),
    value: None,
};

pub static WORD_SUPERS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("eed"),
        dictgen::InsensitiveStr::Ascii("eedd"),
        dictgen::InsensitiveStr::Ascii("eede"),
        dictgen::InsensitiveStr::Ascii("eeded"),
        dictgen::InsensitiveStr::Ascii("eeding"),
        dictgen::InsensitiveStr::Ascii("ition"),
        dictgen::InsensitiveStr::Ascii("ticion"),
        dictgen::InsensitiveStr::Ascii("ticious"),
        dictgen::InsensitiveStr::Ascii("tision"),
        dictgen::InsensitiveStr::Ascii("tisious"),
        dictgen::InsensitiveStr::Ascii("titios"),
        dictgen::InsensitiveStr::Ascii("titiosi"),
        dictgen::InsensitiveStr::Ascii("titiuos"),
        dictgen::InsensitiveStr::Ascii("titon"),
        dictgen::InsensitiveStr::Ascii("titous"),
        dictgen::InsensitiveStr::Ascii("tituous"),
    ],
    values: &[
        &["superseded"],
        &["supersede"],
        &["superseded"],
        &["supersede"],
        &["superseded"],
        &["superseding"],
        &["supervision"],
        &["superstition"],
        &["superstitious"],
        &["superstition"],
        &["superstitious"],
        &["superstitious"],
        &["superstitious"],
        &["superstitious"],
        &["superstition"],
        &["superstitious"],
        &["superstitious"],
    ],
    range: 2..=7,
};

static WORD_SUPERP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SUPERP_CHILDREN),
    value: None,
};

pub static WORD_SUPERP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("oser"),
        dictgen::InsensitiveStr::Ascii("owereds"),
    ],
    values: &[&["superpowers"], &["superpowers"]],
    range: 4..=7,
};

static WORD_SUPERO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SUPERO_CHILDREN),
    value: None,
};

pub static WORD_SUPERO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("peator"),
        dictgen::InsensitiveStr::Ascii("uman"),
    ],
    values: &[&["superoperator"], &["superhuman"]],
    range: 4..=6,
};

static WORD_SUPERN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SUPERN_CHILDREN),
    value: None,
};

pub static WORD_SUPERN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("arkets"),
        dictgen::InsensitiveStr::Ascii("atrual"),
        dictgen::InsensitiveStr::Ascii("atual"),
    ],
    values: &[&["supermarkets"], &["supernatural"], &["supernatural"]],
    range: 5..=6,
};

static WORD_SUPERM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SUPERM_CHILDREN),
    value: None,
};

pub static WORD_SUPERM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("acist"),
        dictgen::InsensitiveStr::Ascii("akert"),
        dictgen::InsensitiveStr::Ascii("aket"),
        dictgen::InsensitiveStr::Ascii("akret"),
        dictgen::InsensitiveStr::Ascii("akter"),
        dictgen::InsensitiveStr::Ascii("are"),
        dictgen::InsensitiveStr::Ascii("arkedet"),
        dictgen::InsensitiveStr::Ascii("arkeds"),
        dictgen::InsensitiveStr::Ascii("arkers"),
        dictgen::InsensitiveStr::Ascii("arkert"),
        dictgen::InsensitiveStr::Ascii("arkerts"),
        dictgen::InsensitiveStr::Ascii("arkt"),
        dictgen::InsensitiveStr::Ascii("arkten"),
        dictgen::InsensitiveStr::Ascii("arktes"),
        dictgen::InsensitiveStr::Ascii("arkts"),
        dictgen::InsensitiveStr::Ascii("aster"),
        dictgen::InsensitiveStr::Ascii("e"),
    ],
    values: &[
        &["supremacist"],
        &["supermarkets"],
        &["supermarket"],
        &["supermarkets"],
        &["supermarkets"],
        &["supermarket"],
        &["supermarket"],
        &["supermarkets"],
        &["supermarkets"],
        &["supermarkets"],
        &["supermarkets"],
        &["supermarket"],
        &["supermarket"],
        &["supermarkets"],
        &["supermarkets"],
        &["supermarkets"],
        &["supreme"],
    ],
    range: 1..=7,
};

static WORD_SUPERI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SUPERI_CHILDREN),
    value: None,
};

pub static WORD_SUPERI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("fical"),
        dictgen::InsensitiveStr::Ascii("ntendant"),
        dictgen::InsensitiveStr::Ascii("oara"),
        dictgen::InsensitiveStr::Ascii("oare"),
        dictgen::InsensitiveStr::Ascii("orest"),
        dictgen::InsensitiveStr::Ascii("oris"),
        dictgen::InsensitiveStr::Ascii("os"),
        dictgen::InsensitiveStr::Ascii("our"),
        dictgen::InsensitiveStr::Ascii("sor"),
        dictgen::InsensitiveStr::Ascii("vsor"),
    ],
    values: &[
        &["superficial"],
        &["superintendent"],
        &["superior"],
        &["superior"],
        &["superiors"],
        &["superiors"],
        &["superiors", "superior"],
        &["superior"],
        &["superiors"],
        &["supervisors"],
    ],
    range: 2..=8,
};

static WORD_SUPERH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SUPERH_CHILDREN),
    value: None,
};

pub static WORD_SUPERH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("am"),
        dictgen::InsensitiveStr::Ascii("eo"),
        dictgen::InsensitiveStr::Ascii("ereos"),
    ],
    values: &[&["superhuman"], &["superhero"], &["superhero"]],
    range: 2..=5,
};

static WORD_SUPERF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SUPERF_CHILDREN),
    value: None,
};

pub static WORD_SUPERF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ical"),
        dictgen::InsensitiveStr::Ascii("iciel"),
        dictgen::InsensitiveStr::Ascii("louous"),
        dictgen::InsensitiveStr::Ascii("lous"),
        dictgen::InsensitiveStr::Ascii("louse"),
        dictgen::InsensitiveStr::Ascii("luious"),
        dictgen::InsensitiveStr::Ascii("luos"),
        dictgen::InsensitiveStr::Ascii("luu"),
        dictgen::InsensitiveStr::Ascii("ulous"),
    ],
    values: &[
        &["superficial"],
        &["superficial"],
        &["superfluous"],
        &["superfluous"],
        &["superfluous"],
        &["superfluous"],
        &["superfluous"],
        &["superfluous"],
        &["superfluous"],
    ],
    range: 3..=6,
};

static WORD_SUPERC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SUPERC_CHILDREN),
    value: None,
};

pub static WORD_SUPERC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("alifragilisticexpialidoceous"),
        dictgen::InsensitiveStr::Ascii("ede"),
        dictgen::InsensitiveStr::Ascii("eded"),
        dictgen::InsensitiveStr::Ascii("edes"),
        dictgen::InsensitiveStr::Ascii("eding"),
        dictgen::InsensitiveStr::Ascii("eed"),
        dictgen::InsensitiveStr::Ascii("eeded"),
        dictgen::InsensitiveStr::Ascii("eedes"),
    ],
    values: &[
        &["supercalifragilisticexpialidocious"],
        &["supersede"],
        &["superseded"],
        &["supersedes"],
        &["superseding"],
        &["supersede"],
        &["superseded"],
        &["supersedes"],
    ],
    range: 3..=28,
};

static WORD_SUPERB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SUPERB_CHILDREN),
    value: None,
};

pub static WORD_SUPERB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ock"),
        dictgen::InsensitiveStr::Ascii("ocks"),
    ],
    values: &[&["superblock"], &["superblocks"]],
    range: 3..=4,
};

static WORD_SUPEE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SUPEE_CHILDREN),
    value: None,
};

pub static WORD_SUPEE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("na")],
    values: &[&["subpoena"]],
    range: 2..=2,
};

static WORD_SUPEB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SUPEB_CHILDREN),
    value: None,
};

pub static WORD_SUPEB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("lock")],
    values: &[&["superblock"]],
    range: 4..=4,
};

static WORD_SUO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SUO_CHILDREN),
    value: None,
};

pub static WORD_SUO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("p")],
    values: &[&["soup"]],
    range: 1..=1,
};

static WORD_SUN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SUN_CHILDREN),
    value: None,
};

pub static WORD_SUN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("conscious"),
        dictgen::InsensitiveStr::Ascii("consciously"),
        dictgen::InsensitiveStr::Ascii("derlad"),
        dictgen::InsensitiveStr::Ascii("derlona"),
        dictgen::InsensitiveStr::Ascii("derlund"),
        dictgen::InsensitiveStr::Ascii("dey"),
        dictgen::InsensitiveStr::Ascii("fiber"),
        dictgen::InsensitiveStr::Ascii("galsses"),
        dictgen::InsensitiveStr::Ascii("ggle"),
        dictgen::InsensitiveStr::Ascii("glases"),
        dictgen::InsensitiveStr::Ascii("glassses"),
        dictgen::InsensitiveStr::Ascii("glesses"),
        dictgen::InsensitiveStr::Ascii("glinger"),
        dictgen::InsensitiveStr::Ascii("ifre"),
        dictgen::InsensitiveStr::Ascii("screeen"),
        dictgen::InsensitiveStr::Ascii("scren"),
        dictgen::InsensitiveStr::Ascii("sday"),
        dictgen::InsensitiveStr::Ascii("task"),
    ],
    values: &[
        &["subconscious"],
        &["subconsciously"],
        &["sunderland"],
        &["sunderland"],
        &["sunderland"],
        &["sunday"],
        &["sunfire"],
        &["sunglasses"],
        &["snuggle"],
        &["sunglasses"],
        &["sunglasses"],
        &["sunglasses"],
        &["gunslinger"],
        &["sunfire"],
        &["sunscreen"],
        &["sunscreen"],
        &["sunday"],
        &["subtask"],
    ],
    range: 3..=11,
};

static WORD_SUM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SUM_CHILDREN),
    value: None,
};

pub static WORD_SUM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("amry"),
        dictgen::InsensitiveStr::Ascii("arize"),
        dictgen::InsensitiveStr::Ascii("ary"),
        dictgen::InsensitiveStr::Ascii("barine"),
        dictgen::InsensitiveStr::Ascii("barines"),
        dictgen::InsensitiveStr::Ascii("berged"),
        dictgen::InsensitiveStr::Ascii("bissions"),
        dictgen::InsensitiveStr::Ascii("bissive"),
        dictgen::InsensitiveStr::Ascii("bit"),
        dictgen::InsensitiveStr::Ascii("bitted"),
        dictgen::InsensitiveStr::Ascii("bitting"),
        dictgen::InsensitiveStr::Ascii("mar"),
        dictgen::InsensitiveStr::Ascii("marizen"),
        dictgen::InsensitiveStr::Ascii("may"),
        dictgen::InsensitiveStr::Ascii("menor"),
        dictgen::InsensitiveStr::Ascii("menors"),
        dictgen::InsensitiveStr::Ascii("merised"),
        dictgen::InsensitiveStr::Ascii("merized"),
        dictgen::InsensitiveStr::Ascii("mersalt"),
        dictgen::InsensitiveStr::Ascii("mmaries"),
        dictgen::InsensitiveStr::Ascii("mmarisation"),
        dictgen::InsensitiveStr::Ascii("mmarised"),
        dictgen::InsensitiveStr::Ascii("mmarization"),
        dictgen::InsensitiveStr::Ascii("mmarized"),
        dictgen::InsensitiveStr::Ascii("mmary"),
        dictgen::InsensitiveStr::Ascii("moenrs"),
        dictgen::InsensitiveStr::Ascii("mones"),
        dictgen::InsensitiveStr::Ascii("monr"),
        dictgen::InsensitiveStr::Ascii("more"),
        dictgen::InsensitiveStr::Ascii("morized"),
        dictgen::InsensitiveStr::Ascii("murize"),
        dictgen::InsensitiveStr::Ascii("murized"),
        dictgen::InsensitiveStr::Ascii("murizes"),
        dictgen::InsensitiveStr::Ascii("murizing"),
        dictgen::InsensitiveStr::Ascii("odules"),
        dictgen::InsensitiveStr::Ascii("ulate"),
        dictgen::InsensitiveStr::Ascii("ulated"),
        dictgen::InsensitiveStr::Ascii("ulates"),
        dictgen::InsensitiveStr::Ascii("ulation"),
        dictgen::InsensitiveStr::Ascii("ulations"),
    ],
    values: &[
        &["summary"],
        &["summarize"],
        &["summary"],
        &["submarine"],
        &["submarines"],
        &["submerged"],
        &["submissions"],
        &["submissive"],
        &["submit"],
        &["submitted"],
        &["submitting"],
        &["summary", "summer"],
        &["summarize"],
        &["summary"],
        &["summoner"],
        &["summoners"],
        &["summarised"],
        &["summarized"],
        &["somersault"],
        &["summaries"],
        &["summarisation"],
        &["summarised"],
        &["summarization"],
        &["summarized"],
        &["summary"],
        &["summoners"],
        &["summoners"],
        &["summoner"],
        &["summoner"],
        &["summarized"],
        &["summarize"],
        &["summarized"],
        &["summarizes"],
        &["summarizing"],
        &["submodules"],
        &["simulate"],
        &["simulated"],
        &["simulates"],
        &["simulation"],
        &["simulations"],
    ],
    range: 3..=11,
};

static WORD_SUI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SUI_CHILDREN),
    value: None,
};

pub static WORD_SUI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ete"),
        dictgen::InsensitiveStr::Ascii("teable"),
    ],
    values: &[&["suite"], &["suitable"]],
    range: 3..=6,
};

static WORD_SUH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SUH_CHILDREN),
    value: Some(&["such"]),
};

pub static WORD_SUH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[],
    values: &[],
    range: 0..=0,
};

static WORD_SUG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SUG_CHILDREN),
    value: None,
};

pub static WORD_SUG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ested"),
        dictgen::InsensitiveStr::Ascii("estion"),
        dictgen::InsensitiveStr::Ascii("estions"),
        dictgen::InsensitiveStr::Ascii("ests"),
        dictgen::InsensitiveStr::Ascii("gesst"),
        dictgen::InsensitiveStr::Ascii("gessted"),
        dictgen::InsensitiveStr::Ascii("gessting"),
        dictgen::InsensitiveStr::Ascii("gesstion"),
        dictgen::InsensitiveStr::Ascii("gesstions"),
        dictgen::InsensitiveStr::Ascii("gessts"),
        dictgen::InsensitiveStr::Ascii("geste"),
        dictgen::InsensitiveStr::Ascii("gestes"),
        dictgen::InsensitiveStr::Ascii("gestie"),
        dictgen::InsensitiveStr::Ascii("gestied"),
        dictgen::InsensitiveStr::Ascii("gestief"),
        dictgen::InsensitiveStr::Ascii("gestieve"),
        dictgen::InsensitiveStr::Ascii("gestin"),
        dictgen::InsensitiveStr::Ascii("gestins"),
        dictgen::InsensitiveStr::Ascii("gestons"),
        dictgen::InsensitiveStr::Ascii("gestsed"),
        dictgen::InsensitiveStr::Ascii("gestted"),
        dictgen::InsensitiveStr::Ascii("gesttion"),
        dictgen::InsensitiveStr::Ascii("gesttions"),
        dictgen::InsensitiveStr::Ascii("get"),
        dictgen::InsensitiveStr::Ascii("geted"),
        dictgen::InsensitiveStr::Ascii("gets"),
        dictgen::InsensitiveStr::Ascii("getsed"),
        dictgen::InsensitiveStr::Ascii("getsing"),
        dictgen::InsensitiveStr::Ascii("getsion"),
        dictgen::InsensitiveStr::Ascii("ggest"),
        dictgen::InsensitiveStr::Ascii("ggested"),
        dictgen::InsensitiveStr::Ascii("ggesting"),
        dictgen::InsensitiveStr::Ascii("ggestion"),
        dictgen::InsensitiveStr::Ascii("ggestions"),
        dictgen::InsensitiveStr::Ascii("guest"),
        dictgen::InsensitiveStr::Ascii("guested"),
        dictgen::InsensitiveStr::Ascii("guesting"),
        dictgen::InsensitiveStr::Ascii("guestion"),
        dictgen::InsensitiveStr::Ascii("guestions"),
    ],
    values: &[
        &["suggested"],
        &["suggestion"],
        &["suggestions"],
        &["suggests"],
        &["suggests", "suggest"],
        &["suggested"],
        &["suggesting"],
        &["suggestion"],
        &["suggestions"],
        &["suggests"],
        &["suggestive"],
        &["suggests"],
        &["suggestive"],
        &["suggestive"],
        &["suggestive"],
        &["suggestive"],
        &["suggestion"],
        &["suggestions"],
        &["suggests"],
        &["suggested"],
        &["suggested"],
        &["suggestion"],
        &["suggestions"],
        &["suggest"],
        &["suggested"],
        &["suggest", "suggests"],
        &["suggested"],
        &["suggesting"],
        &["suggestion"],
        &["suggest"],
        &["suggested"],
        &["suggesting"],
        &["suggestion"],
        &["suggestions"],
        &["suggest"],
        &["suggested"],
        &["suggesting"],
        &["suggestion"],
        &["suggestions"],
    ],
    range: 3..=9,
};

static WORD_SUF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SUF_CHILDREN),
    value: None,
};

pub static WORD_SUF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ace"),
        dictgen::InsensitiveStr::Ascii("aces"),
        dictgen::InsensitiveStr::Ascii("face"),
        dictgen::InsensitiveStr::Ascii("faces"),
        dictgen::InsensitiveStr::Ascii("fciency"),
        dictgen::InsensitiveStr::Ascii("fcient"),
        dictgen::InsensitiveStr::Ascii("fciently"),
        dictgen::InsensitiveStr::Ascii("ferage"),
        dictgen::InsensitiveStr::Ascii("ferd"),
        dictgen::InsensitiveStr::Ascii("ferered"),
        dictgen::InsensitiveStr::Ascii("ferred"),
        dictgen::InsensitiveStr::Ascii("ferring"),
        dictgen::InsensitiveStr::Ascii("fic"),
        dictgen::InsensitiveStr::Ascii("ficate"),
        dictgen::InsensitiveStr::Ascii("ficated"),
        dictgen::InsensitiveStr::Ascii("ficates"),
        dictgen::InsensitiveStr::Ascii("ficating"),
        dictgen::InsensitiveStr::Ascii("fication"),
        dictgen::InsensitiveStr::Ascii("ficency"),
        dictgen::InsensitiveStr::Ascii("ficent"),
        dictgen::InsensitiveStr::Ascii("ficently"),
        dictgen::InsensitiveStr::Ascii("ficiancy"),
        dictgen::InsensitiveStr::Ascii("ficiant"),
        dictgen::InsensitiveStr::Ascii("ficiantly"),
        dictgen::InsensitiveStr::Ascii("ficiennt"),
        dictgen::InsensitiveStr::Ascii("ficienntly"),
        dictgen::InsensitiveStr::Ascii("ficit"),
        dictgen::InsensitiveStr::Ascii("fiency"),
        dictgen::InsensitiveStr::Ascii("fient"),
        dictgen::InsensitiveStr::Ascii("fiently"),
        dictgen::InsensitiveStr::Ascii("fisticated"),
        dictgen::InsensitiveStr::Ascii("icate"),
        dictgen::InsensitiveStr::Ascii("icated"),
        dictgen::InsensitiveStr::Ascii("icates"),
        dictgen::InsensitiveStr::Ascii("icating"),
        dictgen::InsensitiveStr::Ascii("ication"),
        dictgen::InsensitiveStr::Ascii("iccient"),
        dictgen::InsensitiveStr::Ascii("icient"),
        dictgen::InsensitiveStr::Ascii("iciently"),
        dictgen::InsensitiveStr::Ascii("ocate"),
        dictgen::InsensitiveStr::Ascii("ocated"),
        dictgen::InsensitiveStr::Ascii("ocates"),
        dictgen::InsensitiveStr::Ascii("ocating"),
        dictgen::InsensitiveStr::Ascii("ocation"),
    ],
    values: &[
        &["surface"],
        &["surfaces"],
        &["surface"],
        &["surfaces"],
        &["sufficiency"],
        &["sufficient"],
        &["sufficiently"],
        &["suffrage"],
        &["suffered"],
        &["suffered"],
        &["suffered"],
        &["suffering"],
        &["suffix"],
        &["suffocate"],
        &["suffocated"],
        &["suffocates"],
        &["suffocating"],
        &["suffocation"],
        &["sufficiency"],
        &["sufficient"],
        &["sufficiently"],
        &["sufficiency"],
        &["sufficient"],
        &["sufficiently"],
        &["sufficient"],
        &["sufficiently"],
        &["sufficient"],
        &["sufficiency"],
        &["sufficient"],
        &["sufficiently"],
        &["sophisticated"],
        &["suffocate"],
        &["suffocated"],
        &["suffocates"],
        &["suffocating"],
        &["suffocation"],
        &["sufficient"],
        &["sufficient"],
        &["sufficiently"],
        &["suffocate"],
        &["suffocated"],
        &["suffocates"],
        &["suffocating"],
        &["suffocation"],
    ],
    range: 3..=10,
};

static WORD_SUE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SUE_CHILDREN),
    value: None,
};

pub static WORD_SUE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ful"),
        dictgen::InsensitiveStr::Ascii("full"),
        dictgen::InsensitiveStr::Ascii("prset"),
    ],
    values: &[&["useful"], &["useful"], &["superset"]],
    range: 3..=5,
};

static WORD_SUD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SUD_CHILDREN),
    value: None,
};

pub static WORD_SUD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("dently"),
        dictgen::InsensitiveStr::Ascii("deny"),
        dictgen::InsensitiveStr::Ascii("dnely"),
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("ent"),
        dictgen::InsensitiveStr::Ascii("ents"),
        dictgen::InsensitiveStr::Ascii("eo"),
        dictgen::InsensitiveStr::Ascii("io"),
        dictgen::InsensitiveStr::Ascii("mobule"),
        dictgen::InsensitiveStr::Ascii("mobules"),
        dictgen::InsensitiveStr::Ascii("nerland"),
        dictgen::InsensitiveStr::Ascii("u"),
    ],
    values: &[
        &["suddenly"],
        &["suddenly"],
        &["suddenly"],
        &["dude", "side", "sudo", "sued", "suede", "sure"],
        &["student"],
        &["students"],
        &["sudo"],
        &["audio", "sudo"],
        &["submodule"],
        &["submodules"],
        &["sunderland"],
        &["sudo"],
    ],
    range: 1..=7,
};

static WORD_SUC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_SUC_CHILDREN),
    value: None,
};

static WORD_SUC_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    Some(&WORD_SUCC_NODE),
    None,
    Some(&WORD_SUCE_NODE),
    None,
    None,
    None,
    Some(&WORD_SUCI_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_SUCO_NODE),
    None,
    None,
    None,
    Some(&WORD_SUCS_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_SUCS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SUCS_CHILDREN),
    value: None,
};

pub static WORD_SUCS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ede"),
        dictgen::InsensitiveStr::Ascii("eptible"),
        dictgen::InsensitiveStr::Ascii("ess"),
    ],
    values: &[&["succeed"], &["susceptible"], &["success"]],
    range: 3..=7,
};

static WORD_SUCO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SUCO_CHILDREN),
    value: None,
};

pub static WORD_SUCO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("me")],
    values: &[&["succumb"]],
    range: 2..=2,
};

static WORD_SUCI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SUCI_CHILDREN),
    value: None,
};

pub static WORD_SUCI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("de"),
        dictgen::InsensitiveStr::Ascii("dial"),
    ],
    values: &[&["suicide"], &["suicidal"]],
    range: 2..=4,
};

static WORD_SUCE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SUCE_CHILDREN),
    value: None,
};

pub static WORD_SUCE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("eded"),
        dictgen::InsensitiveStr::Ascii("eding"),
        dictgen::InsensitiveStr::Ascii("eds"),
        dictgen::InsensitiveStr::Ascii("essfully"),
        dictgen::InsensitiveStr::Ascii("s"),
        dictgen::InsensitiveStr::Ascii("ses"),
        dictgen::InsensitiveStr::Ascii("sful"),
        dictgen::InsensitiveStr::Ascii("sfull"),
        dictgen::InsensitiveStr::Ascii("sfully"),
        dictgen::InsensitiveStr::Ascii("sfuly"),
        dictgen::InsensitiveStr::Ascii("sion"),
        dictgen::InsensitiveStr::Ascii("sive"),
        dictgen::InsensitiveStr::Ascii("ss"),
        dictgen::InsensitiveStr::Ascii("sscient"),
        dictgen::InsensitiveStr::Ascii("ssed"),
        dictgen::InsensitiveStr::Ascii("sseding"),
        dictgen::InsensitiveStr::Ascii("ssefully"),
        dictgen::InsensitiveStr::Ascii("sses"),
        dictgen::InsensitiveStr::Ascii("ssess"),
        dictgen::InsensitiveStr::Ascii("ssflly"),
        dictgen::InsensitiveStr::Ascii("ssfually"),
        dictgen::InsensitiveStr::Ascii("ssfukk"),
        dictgen::InsensitiveStr::Ascii("ssful"),
        dictgen::InsensitiveStr::Ascii("ssfull"),
        dictgen::InsensitiveStr::Ascii("ssfully"),
        dictgen::InsensitiveStr::Ascii("ssfuly"),
        dictgen::InsensitiveStr::Ascii("ssion"),
        dictgen::InsensitiveStr::Ascii("ssiv"),
        dictgen::InsensitiveStr::Ascii("ssive"),
        dictgen::InsensitiveStr::Ascii("ssively"),
        dictgen::InsensitiveStr::Ascii("ssor"),
        dictgen::InsensitiveStr::Ascii("ssors"),
        dictgen::InsensitiveStr::Ascii("ssot"),
        dictgen::InsensitiveStr::Ascii("sss"),
        dictgen::InsensitiveStr::Ascii("ssses"),
        dictgen::InsensitiveStr::Ascii("sssful"),
        dictgen::InsensitiveStr::Ascii("sssfull"),
        dictgen::InsensitiveStr::Ascii("sssfully"),
        dictgen::InsensitiveStr::Ascii("sssfuly"),
        dictgen::InsensitiveStr::Ascii("ssufll"),
        dictgen::InsensitiveStr::Ascii("ssuflly"),
        dictgen::InsensitiveStr::Ascii("ssully"),
    ],
    values: &[
        &["succeed"],
        &["succeeded"],
        &["succeeding"],
        &["succeeds"],
        &["successfully"],
        &["success"],
        &["successes"],
        &["successful"],
        &["successful"],
        &["successfully"],
        &["successfully"],
        &["succession"],
        &["successive"],
        &["success"],
        &["sufficient"],
        &["succeeded"],
        &["succeeding", "seceding"],
        &["successfully"],
        &["successes"],
        &["success"],
        &["successfully"],
        &["successfully"],
        &["successful"],
        &["successful"],
        &["successful"],
        &["successfully"],
        &["successfully"],
        &["succession"],
        &["successive"],
        &["successive"],
        &["successively"],
        &["successor"],
        &["successors"],
        &["successor"],
        &["success"],
        &["successes"],
        &["successful"],
        &["successful"],
        &["successfully"],
        &["successfully"],
        &["successful"],
        &["successfully"],
        &["successfully"],
    ],
    range: 1..=8,
};

static WORD_SUCC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_SUCC_CHILDREN),
    value: None,
};

static WORD_SUCC_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    Some(&WORD_SUCCC_NODE),
    None,
    Some(&WORD_SUCCE_NODE),
    None,
    None,
    None,
    Some(&WORD_SUCCI_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_SUCCS_NODE),
    None,
    Some(&WORD_SUCCU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_SUCCU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SUCCU_CHILDREN),
    value: None,
};

pub static WORD_SUCCU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ssfully")],
    values: &[&["successfully"]],
    range: 7..=7,
};

static WORD_SUCCS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SUCCS_CHILDREN),
    value: None,
};

pub static WORD_SUCCS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eeded"),
        dictgen::InsensitiveStr::Ascii("esfull"),
        dictgen::InsensitiveStr::Ascii("ess"),
        dictgen::InsensitiveStr::Ascii("essfull"),
        dictgen::InsensitiveStr::Ascii("essive"),
        dictgen::InsensitiveStr::Ascii("sful"),
    ],
    values: &[
        &["succeeded"],
        &["successfully"],
        &["success"],
        &["successful"],
        &["successive"],
        &["successful"],
    ],
    range: 3..=7,
};

static WORD_SUCCI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SUCCI_CHILDREN),
    value: None,
};

pub static WORD_SUCCI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cently"),
        dictgen::InsensitiveStr::Ascii("ent"),
        dictgen::InsensitiveStr::Ascii("nt"),
        dictgen::InsensitiveStr::Ascii("ntly"),
    ],
    values: &[
        &["sufficiently"],
        &["succinct"],
        &["succinct"],
        &["succinctly"],
    ],
    range: 2..=6,
};

static WORD_SUCCE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SUCCE_CHILDREN),
    value: None,
};

pub static WORD_SUCCE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cful"),
        dictgen::InsensitiveStr::Ascii("d"),
        dictgen::InsensitiveStr::Ascii("dd"),
        dictgen::InsensitiveStr::Ascii("dded"),
        dictgen::InsensitiveStr::Ascii("dding"),
        dictgen::InsensitiveStr::Ascii("dds"),
        dictgen::InsensitiveStr::Ascii("de"),
        dictgen::InsensitiveStr::Ascii("ded"),
        dictgen::InsensitiveStr::Ascii("des"),
        dictgen::InsensitiveStr::Ascii("dfully"),
        dictgen::InsensitiveStr::Ascii("ding"),
        dictgen::InsensitiveStr::Ascii("ds"),
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("edde"),
        dictgen::InsensitiveStr::Ascii("edes"),
        dictgen::InsensitiveStr::Ascii("eed"),
        dictgen::InsensitiveStr::Ascii("eedds"),
        dictgen::InsensitiveStr::Ascii("eeded"),
        dictgen::InsensitiveStr::Ascii("eeds"),
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("ess"),
        dictgen::InsensitiveStr::Ascii("esses"),
        dictgen::InsensitiveStr::Ascii("fully"),
        dictgen::InsensitiveStr::Ascii("s"),
        dictgen::InsensitiveStr::Ascii("sd"),
        dictgen::InsensitiveStr::Ascii("sed"),
        dictgen::InsensitiveStr::Ascii("sful"),
        dictgen::InsensitiveStr::Ascii("sfull"),
        dictgen::InsensitiveStr::Ascii("sfully"),
        dictgen::InsensitiveStr::Ascii("sfuly"),
        dictgen::InsensitiveStr::Ascii("sion"),
        dictgen::InsensitiveStr::Ascii("sions"),
        dictgen::InsensitiveStr::Ascii("sive"),
        dictgen::InsensitiveStr::Ascii("sor"),
        dictgen::InsensitiveStr::Ascii("sors"),
        dictgen::InsensitiveStr::Ascii("ssed"),
        dictgen::InsensitiveStr::Ascii("sseurs"),
        dictgen::InsensitiveStr::Ascii("ssfui"),
        dictgen::InsensitiveStr::Ascii("ssfule"),
        dictgen::InsensitiveStr::Ascii("ssfull"),
        dictgen::InsensitiveStr::Ascii("ssfullies"),
        dictgen::InsensitiveStr::Ascii("ssfullly"),
        dictgen::InsensitiveStr::Ascii("ssfulln"),
        dictgen::InsensitiveStr::Ascii("ssfullness"),
        dictgen::InsensitiveStr::Ascii("ssfullt"),
        dictgen::InsensitiveStr::Ascii("ssfuly"),
        dictgen::InsensitiveStr::Ascii("ssing"),
        dictgen::InsensitiveStr::Ascii("ssivo"),
        dictgen::InsensitiveStr::Ascii("sss"),
        dictgen::InsensitiveStr::Ascii("sssfully"),
        dictgen::InsensitiveStr::Ascii("sssion"),
        dictgen::InsensitiveStr::Ascii("sstion"),
        dictgen::InsensitiveStr::Ascii("ssul"),
        dictgen::InsensitiveStr::Ascii("ssully"),
        dictgen::InsensitiveStr::Ascii("sully"),
    ],
    values: &[
        &["successful"],
        &["succeed"],
        &["succeed"],
        &["succeeded"],
        &["succeeding"],
        &["succeeds"],
        &["succeed"],
        &["succeeded"],
        &["succeeds"],
        &["successfully"],
        &["succeeding"],
        &["succeeds"],
        &["succeed"],
        &["succeeded"],
        &["succeeds"],
        &["succeed", "succeeded"],
        &["succeeds"],
        &["succeeded"],
        &["succeeds"],
        &["succeeds", "success"],
        &["success"],
        &["successes"],
        &["successfully"],
        &["success"],
        &["succeeds"],
        &["succeeds"],
        &["successful"],
        &["successful"],
        &["successfully"],
        &["successfully"],
        &["succession"],
        &["succession"],
        &["successive"],
        &["successor"],
        &["successors"],
        &["succeeded", "success", "successful"],
        &["successes"],
        &["successful"],
        &["successful"],
        &["successful"],
        &["successfully"],
        &["successfully"],
        &["successful"],
        &["successfulness"],
        &["successfully"],
        &["successfully"],
        &["succession", "successive"],
        &["succession"],
        &["successes", "success"],
        &["successfully"],
        &["succession"],
        &["succession", "suggestion"],
        &["successful"],
        &["successfully"],
        &["successfully"],
    ],
    range: 1..=10,
};

static WORD_SUCCC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SUCCC_CHILDREN),
    value: None,
};

pub static WORD_SUCCC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eeded"),
        dictgen::InsensitiveStr::Ascii("ess"),
        dictgen::InsensitiveStr::Ascii("esses"),
        dictgen::InsensitiveStr::Ascii("essful"),
        dictgen::InsensitiveStr::Ascii("essfully"),
        dictgen::InsensitiveStr::Ascii("essor"),
        dictgen::InsensitiveStr::Ascii("essors"),
        dictgen::InsensitiveStr::Ascii("essul"),
        dictgen::InsensitiveStr::Ascii("essully"),
    ],
    values: &[
        &["succeeded"],
        &["success"],
        &["successes"],
        &["successful"],
        &["successfully"],
        &["successor"],
        &["successors"],
        &["successful"],
        &["successfully"],
    ],
    range: 3..=8,
};

static WORD_SUB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_SUB_CHILDREN),
    value: None,
};

static WORD_SUB_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_SUBA_NODE),
    Some(&WORD_SUBB_NODE),
    Some(&WORD_SUBC_NODE),
    Some(&WORD_SUBD_NODE),
    Some(&WORD_SUBE_NODE),
    Some(&WORD_SUBF_NODE),
    Some(&WORD_SUBG_NODE),
    None,
    Some(&WORD_SUBI_NODE),
    Some(&WORD_SUBJ_NODE),
    None,
    Some(&WORD_SUBL_NODE),
    Some(&WORD_SUBM_NODE),
    Some(&WORD_SUBN_NODE),
    Some(&WORD_SUBO_NODE),
    Some(&WORD_SUBP_NODE),
    Some(&WORD_SUBQ_NODE),
    Some(&WORD_SUBR_NODE),
    Some(&WORD_SUBS_NODE),
    Some(&WORD_SUBT_NODE),
    Some(&WORD_SUBU_NODE),
    None,
    None,
    None,
    Some(&WORD_SUBY_NODE),
    None,
];

static WORD_SUBY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SUBY_CHILDREN),
    value: None,
};

pub static WORD_SUBY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("stem"),
        dictgen::InsensitiveStr::Ascii("stems"),
    ],
    values: &[&["subsystem"], &["subsystems"]],
    range: 4..=5,
};

static WORD_SUBU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SUBU_CHILDREN),
    value: None,
};

pub static WORD_SUBU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("rburban")],
    values: &[&["suburban"]],
    range: 7..=7,
};

static WORD_SUBT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SUBT_CHILDREN),
    value: None,
};

pub static WORD_SUBT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("abels"),
        dictgen::InsensitiveStr::Ascii("ak"),
        dictgen::InsensitiveStr::Ascii("aks"),
        dictgen::InsensitiveStr::Ascii("ance"),
        dictgen::InsensitiveStr::Ascii("ances"),
        dictgen::InsensitiveStr::Ascii("arct"),
        dictgen::InsensitiveStr::Ascii("arcted"),
        dictgen::InsensitiveStr::Ascii("arcting"),
        dictgen::InsensitiveStr::Ascii("arcts"),
        dictgen::InsensitiveStr::Ascii("arger"),
        dictgen::InsensitiveStr::Ascii("argers"),
        dictgen::InsensitiveStr::Ascii("elty"),
        dictgen::InsensitiveStr::Ascii("erranian"),
        dictgen::InsensitiveStr::Ascii("etly"),
        dictgen::InsensitiveStr::Ascii("iel"),
        dictgen::InsensitiveStr::Ascii("ile"),
        dictgen::InsensitiveStr::Ascii("iles"),
        dictgen::InsensitiveStr::Ascii("ilte"),
        dictgen::InsensitiveStr::Ascii("iltes"),
        dictgen::InsensitiveStr::Ascii("itel"),
        dictgen::InsensitiveStr::Ascii("itels"),
        dictgen::InsensitiveStr::Ascii("itls"),
        dictgen::InsensitiveStr::Ascii("itltes"),
        dictgen::InsensitiveStr::Ascii("itute"),
        dictgen::InsensitiveStr::Ascii("ituted"),
        dictgen::InsensitiveStr::Ascii("itutes"),
        dictgen::InsensitiveStr::Ascii("ituting"),
        dictgen::InsensitiveStr::Ascii("itution"),
        dictgen::InsensitiveStr::Ascii("itutions"),
        dictgen::InsensitiveStr::Ascii("letly"),
        dictgen::InsensitiveStr::Ascii("ltey"),
        dictgen::InsensitiveStr::Ascii("lties"),
        dictgen::InsensitiveStr::Ascii("rafuge"),
        dictgen::InsensitiveStr::Ascii("rate"),
        dictgen::InsensitiveStr::Ascii("rates"),
        dictgen::InsensitiveStr::Ascii("ring"),
        dictgen::InsensitiveStr::Ascii("rings"),
        dictgen::InsensitiveStr::Ascii("situtable"),
        dictgen::InsensitiveStr::Ascii("situtatble"),
    ],
    values: &[
        &["subtables"],
        &["subtask"],
        &["subtask", "subtasks"],
        &["substance"],
        &["substances"],
        &["subtract"],
        &["subtracted"],
        &["subtracting"],
        &["subtracts"],
        &["subtarget"],
        &["subtargets"],
        &["subtlety"],
        &["subterranean"],
        &["subtlety"],
        &["subtitle"],
        &["subfile", "subtitle", "subtle"],
        &["subfiles", "subtitles"],
        &["subtitle"],
        &["subtitles"],
        &["subtitle"],
        &["subtitles"],
        &["subtitles"],
        &["subtitle"],
        &["substitute"],
        &["substituted"],
        &["substitutes"],
        &["substituting"],
        &["substitution"],
        &["substitutions"],
        &["subtlety"],
        &["subtlety"],
        &["subtitles"],
        &["subterfuge"],
        &["substrate"],
        &["substrates"],
        &["substring"],
        &["substrings"],
        &["substitutable"],
        &["substitutable"],
    ],
    range: 2..=10,
};

static WORD_SUBS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_SUBS_CHILDREN),
    value: None,
};

static WORD_SUBS_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_SUBSA_NODE),
    None,
    Some(&WORD_SUBSC_NODE),
    None,
    Some(&WORD_SUBSE_NODE),
    None,
    None,
    Some(&WORD_SUBSH_NODE),
    Some(&WORD_SUBSI_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_SUBSQ_NODE),
    Some(&WORD_SUBSR_NODE),
    None,
    Some(&WORD_SUBST_NODE),
    Some(&WORD_SUBSU_NODE),
    None,
    None,
    None,
    Some(&WORD_SUBSY_NODE),
    None,
];

static WORD_SUBSY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SUBSY_CHILDREN),
    value: None,
};

pub static WORD_SUBSY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("sthem"),
        dictgen::InsensitiveStr::Ascii("sthems"),
        dictgen::InsensitiveStr::Ascii("styem"),
        dictgen::InsensitiveStr::Ascii("styems"),
        dictgen::InsensitiveStr::Ascii("sytem"),
        dictgen::InsensitiveStr::Ascii("sytems"),
        dictgen::InsensitiveStr::Ascii("tem"),
        dictgen::InsensitiveStr::Ascii("tems"),
    ],
    values: &[
        &["subsystem"],
        &["subsystems"],
        &["subsystem"],
        &["subsystems"],
        &["subsystem"],
        &["subsystems"],
        &["subsystem"],
        &["subsystems"],
    ],
    range: 3..=6,
};

static WORD_SUBSU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SUBSU_CHILDREN),
    value: None,
};

pub static WORD_SUBSU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("dized")],
    values: &[&["subsidized"]],
    range: 5..=5,
};

static WORD_SUBST_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_SUBST_CHILDREN),
    value: None,
};

static WORD_SUBST_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_SUBSTA_NODE),
    None,
    None,
    None,
    Some(&WORD_SUBSTE_NODE),
    None,
    None,
    None,
    Some(&WORD_SUBSTI_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_SUBSTR_NODE),
    None,
    None,
    Some(&WORD_SUBSTU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_SUBSTU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SUBSTU_CHILDREN),
    value: None,
};

pub static WORD_SUBSTU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cture"),
        dictgen::InsensitiveStr::Ascii("ctures"),
        dictgen::InsensitiveStr::Ascii("tite"),
    ],
    values: &[
        &["substructure"],
        &["substructures"],
        &["substitutes", "substitute"],
    ],
    range: 4..=6,
};

static WORD_SUBSTR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SUBSTR_CHILDREN),
    value: None,
};

pub static WORD_SUBSTR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("act"),
        dictgen::InsensitiveStr::Ascii("acted"),
        dictgen::InsensitiveStr::Ascii("acting"),
        dictgen::InsensitiveStr::Ascii("action"),
        dictgen::InsensitiveStr::Ascii("acts"),
    ],
    values: &[
        &["subtract"],
        &["subtracted"],
        &["subtracting"],
        &["subtraction"],
        &["subtracts"],
    ],
    range: 3..=6,
};

static WORD_SUBSTI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SUBSTI_CHILDREN),
    value: None,
};

pub static WORD_SUBSTI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("bute"),
        dictgen::InsensitiveStr::Ascii("te"),
        dictgen::InsensitiveStr::Ascii("tion"),
        dictgen::InsensitiveStr::Ascii("tions"),
        dictgen::InsensitiveStr::Ascii("tite"),
        dictgen::InsensitiveStr::Ascii("tition"),
        dictgen::InsensitiveStr::Ascii("titions"),
        dictgen::InsensitiveStr::Ascii("tiute"),
        dictgen::InsensitiveStr::Ascii("ttue"),
        dictgen::InsensitiveStr::Ascii("tuation"),
        dictgen::InsensitiveStr::Ascii("tuations"),
        dictgen::InsensitiveStr::Ascii("tude"),
        dictgen::InsensitiveStr::Ascii("tuded"),
        dictgen::InsensitiveStr::Ascii("tudes"),
        dictgen::InsensitiveStr::Ascii("tuding"),
        dictgen::InsensitiveStr::Ascii("tue"),
        dictgen::InsensitiveStr::Ascii("tued"),
        dictgen::InsensitiveStr::Ascii("tuer"),
        dictgen::InsensitiveStr::Ascii("tues"),
        dictgen::InsensitiveStr::Ascii("tuing"),
        dictgen::InsensitiveStr::Ascii("tuion"),
        dictgen::InsensitiveStr::Ascii("tuions"),
        dictgen::InsensitiveStr::Ascii("ture"),
        dictgen::InsensitiveStr::Ascii("tures"),
        dictgen::InsensitiveStr::Ascii("tutents"),
        dictgen::InsensitiveStr::Ascii("tutie"),
        dictgen::InsensitiveStr::Ascii("tutin"),
        dictgen::InsensitiveStr::Ascii("tutins"),
        dictgen::InsensitiveStr::Ascii("tutivo"),
        dictgen::InsensitiveStr::Ascii("tuto"),
        dictgen::InsensitiveStr::Ascii("tutos"),
        dictgen::InsensitiveStr::Ascii("tuts"),
        dictgen::InsensitiveStr::Ascii("tutue"),
        dictgen::InsensitiveStr::Ascii("tutues"),
        dictgen::InsensitiveStr::Ascii("ution"),
        dictgen::InsensitiveStr::Ascii("utions"),
    ],
    values: &[
        &["substitute"],
        &["substitute"],
        &["substitution"],
        &["substitutions"],
        &["substitute"],
        &["substitution"],
        &["substitutions"],
        &["substitute"],
        &["substitutes"],
        &["substitution"],
        &["substitutions"],
        &["substitute"],
        &["substituted"],
        &["substitutes"],
        &["substituting"],
        &["substitute"],
        &["substitute", "substituted"],
        &["substitute"],
        &["substitutes"],
        &["substituting"],
        &["substitution"],
        &["substitutions"],
        &["substitute"],
        &["substitutes"],
        &["substituents"],
        &["substitutes"],
        &["substituting", "substitution"],
        &["substitutions"],
        &["substitution"],
        &["substitution"],
        &["substitutes"],
        &["substitutes"],
        &["substitutes"],
        &["substitutes"],
        &["substitution"],
        &["substitutions"],
    ],
    range: 2..=8,
};

static WORD_SUBSTE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SUBSTE_CHILDREN),
    value: None,
};

pub static WORD_SUBSTE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("nces"),
        dictgen::InsensitiveStr::Ascii("ntial"),
        dictgen::InsensitiveStr::Ascii("ntially"),
    ],
    values: &[&["substances"], &["substantial"], &["substantially"]],
    range: 4..=7,
};

static WORD_SUBSTA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SUBSTA_CHILDREN),
    value: None,
};

pub static WORD_SUBSTA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ce"),
        dictgen::InsensitiveStr::Ascii("ct"),
        dictgen::InsensitiveStr::Ascii("intially"),
        dictgen::InsensitiveStr::Ascii("ncial"),
        dictgen::InsensitiveStr::Ascii("ncially"),
        dictgen::InsensitiveStr::Ascii("nial"),
        dictgen::InsensitiveStr::Ascii("nitally"),
        dictgen::InsensitiveStr::Ascii("ns"),
        dictgen::InsensitiveStr::Ascii("nse"),
        dictgen::InsensitiveStr::Ascii("nsen"),
        dictgen::InsensitiveStr::Ascii("nser"),
        dictgen::InsensitiveStr::Ascii("nses"),
        dictgen::InsensitiveStr::Ascii("nsial"),
        dictgen::InsensitiveStr::Ascii("nsially"),
        dictgen::InsensitiveStr::Ascii("nsive"),
        dictgen::InsensitiveStr::Ascii("nta"),
        dictgen::InsensitiveStr::Ascii("nte"),
        dictgen::InsensitiveStr::Ascii("ntiable"),
        dictgen::InsensitiveStr::Ascii("ntialy"),
        dictgen::InsensitiveStr::Ascii("ntie"),
        dictgen::InsensitiveStr::Ascii("ntied"),
        dictgen::InsensitiveStr::Ascii("nties"),
        dictgen::InsensitiveStr::Ascii("ntitve"),
        dictgen::InsensitiveStr::Ascii("ntivly"),
        dictgen::InsensitiveStr::Ascii("ntually"),
        dictgen::InsensitiveStr::Ascii("rte"),
        dictgen::InsensitiveStr::Ascii("sk"),
        dictgen::InsensitiveStr::Ascii("sks"),
        dictgen::InsensitiveStr::Ascii("tial"),
    ],
    values: &[
        &["substance"],
        &["subtract"],
        &["substantially"],
        &["substantial"],
        &["substantially"],
        &["substantial"],
        &["substantially"],
        &["substances"],
        &["substances"],
        &["substances"],
        &["substances"],
        &["substances"],
        &["substantial"],
        &["substantially"],
        &["substantive"],
        &["substantial"],
        &["substantive"],
        &["substantial"],
        &["substantially"],
        &["substantive"],
        &["substantive"],
        &["substantive"],
        &["substantive"],
        &["substantially", "substantively"],
        &["substantially"],
        &["substrate"],
        &["subtask"],
        &["subtasks"],
        &["substantial"],
    ],
    range: 2..=8,
};

static WORD_SUBSR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SUBSR_CHILDREN),
    value: None,
};

pub static WORD_SUBSR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cibe"),
        dictgen::InsensitiveStr::Ascii("cibed"),
        dictgen::InsensitiveStr::Ascii("cibers"),
        dictgen::InsensitiveStr::Ascii("ciption"),
        dictgen::InsensitiveStr::Ascii("ibe"),
        dictgen::InsensitiveStr::Ascii("iber"),
        dictgen::InsensitiveStr::Ascii("icption"),
    ],
    values: &[
        &["subscribe"],
        &["subscribed"],
        &["subscribers"],
        &["subscriptions"],
        &["subscribe"],
        &["subscriber"],
        &["subscriptions"],
    ],
    range: 3..=7,
};

static WORD_SUBSQ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SUBSQ_CHILDREN),
    value: None,
};

pub static WORD_SUBSQ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("uent"),
        dictgen::InsensitiveStr::Ascii("uently"),
    ],
    values: &[&["subsequent"], &["subsequently"]],
    range: 4..=6,
};

static WORD_SUBSI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SUBSI_CHILDREN),
    value: None,
};

pub static WORD_SUBSI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("dary"),
        dictgen::InsensitiveStr::Ascii("dezed"),
        dictgen::InsensitiveStr::Ascii("diced"),
        dictgen::InsensitiveStr::Ascii("die"),
        dictgen::InsensitiveStr::Ascii("diezed"),
        dictgen::InsensitiveStr::Ascii("diy"),
        dictgen::InsensitiveStr::Ascii("dizied"),
        dictgen::InsensitiveStr::Ascii("dizies"),
        dictgen::InsensitiveStr::Ascii("dizng"),
        dictgen::InsensitiveStr::Ascii("duary"),
        dictgen::InsensitiveStr::Ascii("quent"),
        dictgen::InsensitiveStr::Ascii("quently"),
        dictgen::InsensitiveStr::Ascii("ttute"),
        dictgen::InsensitiveStr::Ascii("tuent"),
        dictgen::InsensitiveStr::Ascii("tuents"),
        dictgen::InsensitiveStr::Ascii("tutable"),
        dictgen::InsensitiveStr::Ascii("tutatble"),
        dictgen::InsensitiveStr::Ascii("tute"),
        dictgen::InsensitiveStr::Ascii("tuted"),
        dictgen::InsensitiveStr::Ascii("tutes"),
        dictgen::InsensitiveStr::Ascii("tuting"),
        dictgen::InsensitiveStr::Ascii("tution"),
        dictgen::InsensitiveStr::Ascii("tutions"),
        dictgen::InsensitiveStr::Ascii("tutuent"),
        dictgen::InsensitiveStr::Ascii("tutuents"),
        dictgen::InsensitiveStr::Ascii("tutute"),
        dictgen::InsensitiveStr::Ascii("tututed"),
        dictgen::InsensitiveStr::Ascii("tututes"),
        dictgen::InsensitiveStr::Ascii("tututing"),
        dictgen::InsensitiveStr::Ascii("tutution"),
        dictgen::InsensitiveStr::Ascii("zide"),
        dictgen::InsensitiveStr::Ascii("zided"),
        dictgen::InsensitiveStr::Ascii("ziding"),
    ],
    values: &[
        &["subsidiary"],
        &["subsidized"],
        &["subsidized"],
        &["subsidized"],
        &["subsidized"],
        &["subsidy"],
        &["subsidized"],
        &["subsidize"],
        &["subsidizing"],
        &["subsidiary"],
        &["subsequent"],
        &["subsequently"],
        &["substitutes"],
        &["substituent"],
        &["substituents"],
        &["substitutable"],
        &["substitutable"],
        &["substitute"],
        &["substituted"],
        &["substitutes"],
        &["substituting"],
        &["substitution"],
        &["substitutions"],
        &["substituent"],
        &["substituents"],
        &["substitute"],
        &["substituted"],
        &["substitutes"],
        &["substituting"],
        &["substitution"],
        &["subsidize"],
        &["subsidized"],
        &["subsidizing"],
    ],
    range: 3..=8,
};

static WORD_SUBSH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SUBSH_CHILDREN),
    value: None,
};

pub static WORD_SUBSH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ystem"),
        dictgen::InsensitiveStr::Ascii("ystems"),
    ],
    values: &[&["subsystem"], &["subsystems"]],
    range: 5..=6,
};

static WORD_SUBSE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SUBSE_CHILDREN),
    value: None,
};

pub static WORD_SUBSE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("crion"),
        dictgen::InsensitiveStr::Ascii("dent"),
        dictgen::InsensitiveStr::Ascii("dized"),
        dictgen::InsensitiveStr::Ascii("qence"),
        dictgen::InsensitiveStr::Ascii("qent"),
        dictgen::InsensitiveStr::Ascii("quant"),
        dictgen::InsensitiveStr::Ascii("quenty"),
        dictgen::InsensitiveStr::Ascii("quest"),
        dictgen::InsensitiveStr::Ascii("qunce"),
        dictgen::InsensitiveStr::Ascii("qunt"),
        dictgen::InsensitiveStr::Ascii("quntly"),
        dictgen::InsensitiveStr::Ascii("uqent"),
    ],
    values: &[
        &["subsection"],
        &["subsequent"],
        &["subsidized"],
        &["subsequence"],
        &["subsequent"],
        &["subsequent"],
        &["subsequently"],
        &["subsequent"],
        &["subsequence"],
        &["subsequent"],
        &["subsequently"],
        &["subsequent"],
    ],
    range: 4..=6,
};

static WORD_SUBSC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SUBSC_CHILDREN),
    value: None,
};

pub static WORD_SUBSC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eptible"),
        dictgen::InsensitiveStr::Ascii("ibe"),
        dictgen::InsensitiveStr::Ascii("ibed"),
        dictgen::InsensitiveStr::Ascii("iber"),
        dictgen::InsensitiveStr::Ascii("ibers"),
        dictgen::InsensitiveStr::Ascii("irbe"),
        dictgen::InsensitiveStr::Ascii("irbed"),
        dictgen::InsensitiveStr::Ascii("irber"),
        dictgen::InsensitiveStr::Ascii("irbers"),
        dictgen::InsensitiveStr::Ascii("irbes"),
        dictgen::InsensitiveStr::Ascii("irbing"),
        dictgen::InsensitiveStr::Ascii("irpt"),
        dictgen::InsensitiveStr::Ascii("irption"),
        dictgen::InsensitiveStr::Ascii("irptions"),
        dictgen::InsensitiveStr::Ascii("oncious"),
        dictgen::InsensitiveStr::Ascii("onciously"),
        dictgen::InsensitiveStr::Ascii("ribar"),
        dictgen::InsensitiveStr::Ascii("ribbed"),
        dictgen::InsensitiveStr::Ascii("ribber"),
        dictgen::InsensitiveStr::Ascii("ribbers"),
        dictgen::InsensitiveStr::Ascii("ribbing"),
        dictgen::InsensitiveStr::Ascii("ribir"),
        dictgen::InsensitiveStr::Ascii("ribirse"),
        dictgen::InsensitiveStr::Ascii("rible"),
        dictgen::InsensitiveStr::Ascii("ribtion"),
        dictgen::InsensitiveStr::Ascii("ribtions"),
        dictgen::InsensitiveStr::Ascii("rie"),
        dictgen::InsensitiveStr::Ascii("riped"),
        dictgen::InsensitiveStr::Ascii("riping"),
        dictgen::InsensitiveStr::Ascii("riptin"),
        dictgen::InsensitiveStr::Ascii("ripton"),
        dictgen::InsensitiveStr::Ascii("riptons"),
        dictgen::InsensitiveStr::Ascii("ritpion"),
        dictgen::InsensitiveStr::Ascii("ritpions"),
        dictgen::InsensitiveStr::Ascii("ritpiton"),
        dictgen::InsensitiveStr::Ascii("ritpitons"),
        dictgen::InsensitiveStr::Ascii("ritpt"),
        dictgen::InsensitiveStr::Ascii("ritption"),
        dictgen::InsensitiveStr::Ascii("ritptions"),
        dictgen::InsensitiveStr::Ascii("rpition"),
        dictgen::InsensitiveStr::Ascii("rubed"),
        dictgen::InsensitiveStr::Ascii("ryber"),
        dictgen::InsensitiveStr::Ascii("titution"),
    ],
    values: &[
        &["susceptible"],
        &["subscribe"],
        &["subscribed"],
        &["subscriber"],
        &["subscribers"],
        &["subscribe"],
        &["subscribed"],
        &["subscribers", "subscriber"],
        &["subscribers"],
        &["subscribes"],
        &["subscribing"],
        &["subscript"],
        &["subscriptions", "subscription"],
        &["subscriptions"],
        &["subconscious"],
        &["subconsciously"],
        &["subscriber"],
        &["subscribe"],
        &["subscriber"],
        &["subscribers"],
        &["subscribing"],
        &["subscriber"],
        &["subscriber"],
        &["subscriber"],
        &["subscription"],
        &["subscriptions"],
        &["subscriber"],
        &["subscribed"],
        &["subscribing"],
        &["subscriptions"],
        &["subscription"],
        &["subscriptions"],
        &["subscriptions", "subscription"],
        &["subscriptions"],
        &["subscription"],
        &["subscriptions"],
        &["subscript"],
        &["subscription"],
        &["subscriptions"],
        &["subscriptions"],
        &["subscribed"],
        &["subscriber"],
        &["substitution"],
    ],
    range: 3..=9,
};

static WORD_SUBSA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SUBSA_CHILDREN),
    value: None,
};

pub static WORD_SUBSA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("dized")],
    values: &[&["subsidized"]],
    range: 5..=5,
};

static WORD_SUBR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SUBR_CHILDREN),
    value: None,
};

pub static WORD_SUBR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("act"),
        dictgen::InsensitiveStr::Ascii("acted"),
        dictgen::InsensitiveStr::Ascii("action"),
        dictgen::InsensitiveStr::Ascii("edddits"),
        dictgen::InsensitiveStr::Ascii("edditors"),
        dictgen::InsensitiveStr::Ascii("ee"),
        dictgen::InsensitiveStr::Ascii("esoure"),
        dictgen::InsensitiveStr::Ascii("esoures"),
        dictgen::InsensitiveStr::Ascii("outie"),
        dictgen::InsensitiveStr::Ascii("outies"),
        dictgen::InsensitiveStr::Ascii("uban"),
    ],
    values: &[
        &["subtract"],
        &["subtracted"],
        &["subtraction"],
        &["subreddits"],
        &["subreddits"],
        &["subtree"],
        &["subresource"],
        &["subresources"],
        &["subroutine"],
        &["subroutines"],
        &["suburban"],
    ],
    range: 2..=8,
};

static WORD_SUBQ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SUBQ_CHILDREN),
    value: None,
};

pub static WORD_SUBQ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("uue")],
    values: &[&["subqueue"]],
    range: 3..=3,
};

static WORD_SUBP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SUBP_CHILDREN),
    value: None,
};

pub static WORD_SUBP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ackge"),
        dictgen::InsensitiveStr::Ascii("ackges"),
        dictgen::InsensitiveStr::Ascii("ecies"),
        dictgen::InsensitiveStr::Ascii("orgram"),
        dictgen::InsensitiveStr::Ascii("roccese"),
        dictgen::InsensitiveStr::Ascii("sace"),
    ],
    values: &[
        &["subpackage"],
        &["subpackages"],
        &["subspecies"],
        &["subprogram"],
        &["subprocess"],
        &["subspace"],
    ],
    range: 4..=7,
};

static WORD_SUBO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SUBO_CHILDREN),
    value: None,
};

pub static WORD_SUBO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("bjecs"),
        dictgen::InsensitiveStr::Ascii("rutine"),
        dictgen::InsensitiveStr::Ascii("rutines"),
        dictgen::InsensitiveStr::Ascii("utine"),
    ],
    values: &[
        &["subobjects"],
        &["subroutine"],
        &["subroutines"],
        &["subroutine"],
    ],
    range: 5..=7,
};

static WORD_SUBN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SUBN_CHILDREN),
    value: None,
};

pub static WORD_SUBN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("egatiotiation"),
        dictgen::InsensitiveStr::Ascii("egatiotiations"),
        dictgen::InsensitiveStr::Ascii("egoatiation"),
        dictgen::InsensitiveStr::Ascii("egoatiations"),
        dictgen::InsensitiveStr::Ascii("egoation"),
        dictgen::InsensitiveStr::Ascii("egoations"),
        dictgen::InsensitiveStr::Ascii("egociation"),
        dictgen::InsensitiveStr::Ascii("egociations"),
        dictgen::InsensitiveStr::Ascii("egogtiation"),
        dictgen::InsensitiveStr::Ascii("egogtiations"),
        dictgen::InsensitiveStr::Ascii("egoitation"),
        dictgen::InsensitiveStr::Ascii("egoitations"),
        dictgen::InsensitiveStr::Ascii("egoptionsotiation"),
        dictgen::InsensitiveStr::Ascii("egoptionsotiations"),
        dictgen::InsensitiveStr::Ascii("egosiation"),
        dictgen::InsensitiveStr::Ascii("egosiations"),
        dictgen::InsensitiveStr::Ascii("egotaiation"),
        dictgen::InsensitiveStr::Ascii("egotaiations"),
        dictgen::InsensitiveStr::Ascii("egotaition"),
        dictgen::InsensitiveStr::Ascii("egotaitions"),
        dictgen::InsensitiveStr::Ascii("egotatiation"),
        dictgen::InsensitiveStr::Ascii("egotatiations"),
        dictgen::InsensitiveStr::Ascii("egotation"),
        dictgen::InsensitiveStr::Ascii("egotations"),
        dictgen::InsensitiveStr::Ascii("egothiation"),
        dictgen::InsensitiveStr::Ascii("egothiations"),
        dictgen::InsensitiveStr::Ascii("egotication"),
        dictgen::InsensitiveStr::Ascii("egotications"),
        dictgen::InsensitiveStr::Ascii("egotioation"),
        dictgen::InsensitiveStr::Ascii("egotioations"),
        dictgen::InsensitiveStr::Ascii("egotion"),
        dictgen::InsensitiveStr::Ascii("egotionation"),
        dictgen::InsensitiveStr::Ascii("egotionations"),
        dictgen::InsensitiveStr::Ascii("egotions"),
        dictgen::InsensitiveStr::Ascii("egotiotation"),
        dictgen::InsensitiveStr::Ascii("egotiotations"),
        dictgen::InsensitiveStr::Ascii("egotiotion"),
        dictgen::InsensitiveStr::Ascii("egotiotions"),
        dictgen::InsensitiveStr::Ascii("egotitaion"),
        dictgen::InsensitiveStr::Ascii("egotitaions"),
        dictgen::InsensitiveStr::Ascii("egotitation"),
        dictgen::InsensitiveStr::Ascii("egotitations"),
        dictgen::InsensitiveStr::Ascii("egotition"),
        dictgen::InsensitiveStr::Ascii("egotitions"),
        dictgen::InsensitiveStr::Ascii("egoziation"),
        dictgen::InsensitiveStr::Ascii("egoziations"),
    ],
    values: &[
        &["subnegotiation"],
        &["subnegotiations"],
        &["subnegotiation"],
        &["subnegotiations"],
        &["subnegotiation"],
        &["subnegotiations"],
        &["subnegotiation"],
        &["subnegotiations"],
        &["subnegotiation"],
        &["subnegotiations"],
        &["subnegotiation"],
        &["subnegotiations"],
        &["subnegotiation"],
        &["subnegotiations"],
        &["subnegotiation"],
        &["subnegotiations"],
        &["subnegotiation"],
        &["subnegotiations"],
        &["subnegotiation"],
        &["subnegotiations"],
        &["subnegotiation"],
        &["subnegotiations"],
        &["subnegotiation"],
        &["subnegotiations"],
        &["subnegotiation"],
        &["subnegotiations"],
        &["subnegotiation"],
        &["subnegotiations"],
        &["subnegotiation"],
        &["subnegotiations"],
        &["subnegotiation"],
        &["subnegotiation"],
        &["subnegotiations"],
        &["subnegotiations"],
        &["subnegotiation"],
        &["subnegotiations"],
        &["subnegotiation"],
        &["subnegotiations"],
        &["subnegotiation"],
        &["subnegotiations"],
        &["subnegotiation"],
        &["subnegotiations"],
        &["subnegotiation"],
        &["subnegotiations"],
        &["subnegotiation"],
        &["subnegotiations"],
    ],
    range: 7..=18,
};

static WORD_SUBM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SUBM_CHILDREN),
    value: None,
};

pub static WORD_SUBM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("achne"),
        dictgen::InsensitiveStr::Ascii("arie"),
        dictgen::InsensitiveStr::Ascii("ariens"),
        dictgen::InsensitiveStr::Ascii("arinas"),
        dictgen::InsensitiveStr::Ascii("ergerd"),
        dictgen::InsensitiveStr::Ascii("ergered"),
        dictgen::InsensitiveStr::Ascii("erines"),
        dictgen::InsensitiveStr::Ascii("ision"),
        dictgen::InsensitiveStr::Ascii("isions"),
        dictgen::InsensitiveStr::Ascii("isison"),
        dictgen::InsensitiveStr::Ascii("isisons"),
        dictgen::InsensitiveStr::Ascii("issies"),
        dictgen::InsensitiveStr::Ascii("isson"),
        dictgen::InsensitiveStr::Ascii("issons"),
        dictgen::InsensitiveStr::Ascii("ited"),
        dictgen::InsensitiveStr::Ascii("iting"),
        dictgen::InsensitiveStr::Ascii("ition"),
        dictgen::InsensitiveStr::Ascii("itions"),
        dictgen::InsensitiveStr::Ascii("ittion"),
        dictgen::InsensitiveStr::Ascii("ittted"),
        dictgen::InsensitiveStr::Ascii("oule"),
        dictgen::InsensitiveStr::Ascii("ti"),
    ],
    values: &[
        &["submachine"],
        &["submarines"],
        &["submarines"],
        &["submarines"],
        &["submerged"],
        &["submerged"],
        &["submarines"],
        &["submission"],
        &["submissions"],
        &["submissions", "submission"],
        &["submissions"],
        &["submissive"],
        &["submission"],
        &["submissions"],
        &["submitted"],
        &["submitting"],
        &["submission"],
        &["submissions"],
        &["submitting"],
        &["submitted"],
        &["submodule"],
        &["submit"],
    ],
    range: 2..=7,
};

static WORD_SUBL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SUBL_CHILDREN),
    value: None,
};

pub static WORD_SUBL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ass"),
        dictgen::InsensitiveStr::Ascii("asse"),
        dictgen::InsensitiveStr::Ascii("asses"),
        dictgen::InsensitiveStr::Ascii("cass"),
        dictgen::InsensitiveStr::Ascii("casses"),
        dictgen::InsensitiveStr::Ascii("cuase"),
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("tety"),
    ],
    values: &[
        &["subclass"],
        &["subclasse"],
        &["subclasses"],
        &["subclass"],
        &["subclasses"],
        &["subclause"],
        &["subtle"],
        &["subtlety"],
    ],
    range: 1..=6,
};

static WORD_SUBJ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SUBJ_CHILDREN),
    value: None,
};

pub static WORD_SUBJ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ec"),
        dictgen::InsensitiveStr::Ascii("ectief"),
        dictgen::InsensitiveStr::Ascii("ectifs"),
        dictgen::InsensitiveStr::Ascii("ectivelly"),
        dictgen::InsensitiveStr::Ascii("ectivety"),
        dictgen::InsensitiveStr::Ascii("ectivily"),
        dictgen::InsensitiveStr::Ascii("ectivley"),
        dictgen::InsensitiveStr::Ascii("ectivly"),
        dictgen::InsensitiveStr::Ascii("ectivy"),
        dictgen::InsensitiveStr::Ascii("ektive"),
        dictgen::InsensitiveStr::Ascii("est"),
        dictgen::InsensitiveStr::Ascii("et"),
        dictgen::InsensitiveStr::Ascii("udgation"),
    ],
    values: &[
        &["subject"],
        &["subjective"],
        &["subjects"],
        &["subjectively"],
        &["subjectively"],
        &["subjectively"],
        &["subjectively"],
        &["subjectively"],
        &["subjectively"],
        &["subjective"],
        &["subjects"],
        &["subject"],
        &["subjugation"],
    ],
    range: 2..=9,
};

static WORD_SUBI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SUBI_CHILDREN),
    value: None,
};

pub static WORD_SUBI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("rectory"),
        dictgen::InsensitiveStr::Ascii("sdized"),
        dictgen::InsensitiveStr::Ascii("sdizing"),
        dictgen::InsensitiveStr::Ascii("sdy"),
    ],
    values: &[
        &["subdirectory"],
        &["subsidized"],
        &["subsidizing"],
        &["subsidy"],
    ],
    range: 3..=7,
};

static WORD_SUBG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SUBG_CHILDREN),
    value: None,
};

pub static WORD_SUBG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("region")],
    values: &[&["subregion"]],
    range: 6..=6,
};

static WORD_SUBF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SUBF_CHILDREN),
    value: None,
};

pub static WORD_SUBF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("olfer"),
        dictgen::InsensitiveStr::Ascii("olfers"),
        dictgen::InsensitiveStr::Ascii("romat"),
        dictgen::InsensitiveStr::Ascii("romats"),
        dictgen::InsensitiveStr::Ascii("roms"),
    ],
    values: &[
        &["subfolder"],
        &["subfolders"],
        &["subformat"],
        &["subformats"],
        &["subforms"],
    ],
    range: 4..=6,
};

static WORD_SUBE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SUBE_CHILDREN),
    value: None,
};

pub static WORD_SUBE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("lemet"),
        dictgen::InsensitiveStr::Ascii("lemets"),
        dictgen::InsensitiveStr::Ascii("squent"),
        dictgen::InsensitiveStr::Ascii("squently"),
        dictgen::InsensitiveStr::Ascii("xperesion"),
        dictgen::InsensitiveStr::Ascii("xperesions"),
        dictgen::InsensitiveStr::Ascii("xperession"),
        dictgen::InsensitiveStr::Ascii("xperessions"),
        dictgen::InsensitiveStr::Ascii("xpersion"),
        dictgen::InsensitiveStr::Ascii("xpersions"),
        dictgen::InsensitiveStr::Ascii("xperssion"),
        dictgen::InsensitiveStr::Ascii("xperssions"),
        dictgen::InsensitiveStr::Ascii("xpession"),
        dictgen::InsensitiveStr::Ascii("xpessions"),
        dictgen::InsensitiveStr::Ascii("xpresssion"),
        dictgen::InsensitiveStr::Ascii("xpresssions"),
    ],
    values: &[
        &["subelement"],
        &["subelements"],
        &["subsequent"],
        &["subsequently"],
        &["subexpression"],
        &["subexpressions"],
        &["subexpression"],
        &["subexpressions"],
        &["subexpression"],
        &["subexpressions"],
        &["subexpression"],
        &["subexpressions"],
        &["subexpression"],
        &["subexpressions"],
        &["subexpression"],
        &["subexpressions"],
    ],
    range: 5..=11,
};

static WORD_SUBD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SUBD_CHILDREN),
    value: None,
};

pub static WORD_SUBD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("irectiories"),
        dictgen::InsensitiveStr::Ascii("irectoires"),
        dictgen::InsensitiveStr::Ascii("irectorys"),
        dictgen::InsensitiveStr::Ascii("irecty"),
        dictgen::InsensitiveStr::Ascii("ivisio"),
        dictgen::InsensitiveStr::Ascii("ivisiond"),
        dictgen::InsensitiveStr::Ascii("oamin"),
        dictgen::InsensitiveStr::Ascii("oamins"),
    ],
    values: &[
        &["subdirectories"],
        &["subdirectories"],
        &["subdirectories"],
        &["subdirectory"],
        &["subdivision"],
        &["subdivisioned"],
        &["subdomain"],
        &["subdomains"],
    ],
    range: 5..=11,
};

static WORD_SUBC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SUBC_CHILDREN),
    value: None,
};

pub static WORD_SUBC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("atagories"),
        dictgen::InsensitiveStr::Ascii("atagory"),
        dictgen::InsensitiveStr::Ascii("irucit"),
        dictgen::InsensitiveStr::Ascii("ommannd"),
        dictgen::InsensitiveStr::Ascii("ommnad"),
        dictgen::InsensitiveStr::Ascii("onchus"),
        dictgen::InsensitiveStr::Ascii("oncsious"),
        dictgen::InsensitiveStr::Ascii("oncsiously"),
        dictgen::InsensitiveStr::Ascii("onsciosly"),
        dictgen::InsensitiveStr::Ascii("onsciouly"),
        dictgen::InsensitiveStr::Ascii("onscius"),
        dictgen::InsensitiveStr::Ascii("onscous"),
        dictgen::InsensitiveStr::Ascii("onsicous"),
        dictgen::InsensitiveStr::Ascii("onsicously"),
        dictgen::InsensitiveStr::Ascii("onsiously"),
        dictgen::InsensitiveStr::Ascii("ouncious"),
        dictgen::InsensitiveStr::Ascii("ribe"),
        dictgen::InsensitiveStr::Ascii("ribed"),
        dictgen::InsensitiveStr::Ascii("ribes"),
        dictgen::InsensitiveStr::Ascii("ribing"),
        dictgen::InsensitiveStr::Ascii("ription"),
        dictgen::InsensitiveStr::Ascii("riptions"),
        dictgen::InsensitiveStr::Ascii("sription"),
        dictgen::InsensitiveStr::Ascii("ulter"),
        dictgen::InsensitiveStr::Ascii("ultuur"),
    ],
    values: &[
        &["subcategories"],
        &["subcategory"],
        &["subcircuit"],
        &["subcommand"],
        &["subcommand"],
        &["subconscious"],
        &["subconscious"],
        &["subconsciously"],
        &["subconsciously"],
        &["subconsciously"],
        &["subconscious"],
        &["subconscious"],
        &["subconscious"],
        &["subconsciously"],
        &["subconsciously"],
        &["subconscious"],
        &["subscribe"],
        &["subscribed"],
        &["subscribes"],
        &["subscribing"],
        &["subscription"],
        &["subscriptions"],
        &["subscriptions"],
        &["subculture"],
        &["subculture"],
    ],
    range: 4..=10,
};

static WORD_SUBB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SUBB_CHILDREN),
    value: None,
};

pub static WORD_SUBB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("tle")],
    values: &[&["subtle"]],
    range: 3..=3,
};

static WORD_SUBA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SUBA_CHILDREN),
    value: None,
};

pub static WORD_SUBA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("rmine"),
        dictgen::InsensitiveStr::Ascii("rmines"),
    ],
    values: &[&["submarine"], &["submarines"]],
    range: 5..=6,
};

static WORD_SUA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SUA_CHILDREN),
    value: None,
};

pub static WORD_SUA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("sage"),
        dictgen::InsensitiveStr::Ascii("sages"),
    ],
    values: &[&["sausage"], &["sausages"]],
    range: 4..=5,
};

static WORD_ST_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_ST_CHILDREN),
    value: None,
};

static WORD_ST_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_STA_NODE),
    None,
    Some(&WORD_STC_NODE),
    Some(&WORD_STD_NODE),
    Some(&WORD_STE_NODE),
    None,
    None,
    None,
    Some(&WORD_STI_NODE),
    None,
    None,
    Some(&WORD_STL_NODE),
    None,
    Some(&WORD_STN_NODE),
    Some(&WORD_STO_NODE),
    Some(&WORD_STP_NODE),
    None,
    Some(&WORD_STR_NODE),
    Some(&WORD_STS_NODE),
    Some(&WORD_STT_NODE),
    Some(&WORD_STU_NODE),
    None,
    None,
    None,
    Some(&WORD_STY_NODE),
    None,
];

static WORD_STY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_STY_CHILDREN),
    value: None,
};

pub static WORD_STY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("he"),
        dictgen::InsensitiveStr::Ascii("ilistic"),
        dictgen::InsensitiveStr::Ascii("lessheet"),
        dictgen::InsensitiveStr::Ascii("lessheets"),
        dictgen::InsensitiveStr::Ascii("lisch"),
        dictgen::InsensitiveStr::Ascii("rofaom"),
        dictgen::InsensitiveStr::Ascii("rofom"),
    ],
    values: &[
        &["style"],
        &["stylistic"],
        &["stylesheet", "stylesheets"],
        &["stylesheets"],
        &["stylish"],
        &["styrofoam"],
        &["styrofoam"],
    ],
    range: 2..=9,
};

static WORD_STU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_STU_CHILDREN),
    value: None,
};

pub static WORD_STU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ation"),
        dictgen::InsensitiveStr::Ascii("ations"),
        dictgen::InsensitiveStr::Ascii("bbon"),
        dictgen::InsensitiveStr::Ascii("bborness"),
        dictgen::InsensitiveStr::Ascii("bbron"),
        dictgen::InsensitiveStr::Ascii("bmled"),
        dictgen::InsensitiveStr::Ascii("cked"),
        dictgen::InsensitiveStr::Ascii("ckt"),
        dictgen::InsensitiveStr::Ascii("ct"),
        dictgen::InsensitiveStr::Ascii("cts"),
        dictgen::InsensitiveStr::Ascii("cture"),
        dictgen::InsensitiveStr::Ascii("ctured"),
        dictgen::InsensitiveStr::Ascii("ctures"),
        dictgen::InsensitiveStr::Ascii("ddy"),
        dictgen::InsensitiveStr::Ascii("detn"),
        dictgen::InsensitiveStr::Ascii("detns"),
        dictgen::InsensitiveStr::Ascii("di"),
        dictgen::InsensitiveStr::Ascii("ding"),
        dictgen::InsensitiveStr::Ascii("dioes"),
        dictgen::InsensitiveStr::Ascii("dis"),
        dictgen::InsensitiveStr::Ascii("doi"),
        dictgen::InsensitiveStr::Ascii("dois"),
        dictgen::InsensitiveStr::Ascii("ggling"),
        dictgen::InsensitiveStr::Ascii("ido"),
        dictgen::InsensitiveStr::Ascii("idos"),
        dictgen::InsensitiveStr::Ascii("ill"),
        dictgen::InsensitiveStr::Ascii("ipder"),
        dictgen::InsensitiveStr::Ascii("mbeld"),
        dictgen::InsensitiveStr::Ascii("mmac"),
        dictgen::InsensitiveStr::Ascii("nami"),
        dictgen::InsensitiveStr::Ascii("pdily"),
        dictgen::InsensitiveStr::Ascii("pidfree"),
        dictgen::InsensitiveStr::Ascii("piditiy"),
        dictgen::InsensitiveStr::Ascii("pidiy"),
        dictgen::InsensitiveStr::Ascii("pidr"),
        dictgen::InsensitiveStr::Ascii("pidy"),
        dictgen::InsensitiveStr::Ascii("pire"),
        dictgen::InsensitiveStr::Ascii("pitidy"),
        dictgen::InsensitiveStr::Ascii("rctural"),
        dictgen::InsensitiveStr::Ascii("rcture"),
        dictgen::InsensitiveStr::Ascii("rctures"),
        dictgen::InsensitiveStr::Ascii("rggled"),
        dictgen::InsensitiveStr::Ascii("rggles"),
        dictgen::InsensitiveStr::Ascii("rggling"),
        dictgen::InsensitiveStr::Ascii("rture"),
        dictgen::InsensitiveStr::Ascii("rtured"),
        dictgen::InsensitiveStr::Ascii("rtures"),
        dictgen::InsensitiveStr::Ascii("ructure"),
        dictgen::InsensitiveStr::Ascii("tdown"),
        dictgen::InsensitiveStr::Ascii("tterring"),
        dictgen::InsensitiveStr::Ascii("tus"),
    ],
    values: &[
        &["situation", "station"],
        &["situations", "stations"],
        &["stubborn"],
        &["stubbornness"],
        &["stubborn"],
        &["stumbled"],
        &["stuck"],
        &["stuck"],
        &["struct"],
        &["structs"],
        &["structure"],
        &["structured"],
        &["structures"],
        &["study"],
        &["student"],
        &["students"],
        &["study", "studio"],
        &["studying"],
        &["studios"],
        &["studies", "studios"],
        &["studio"],
        &["studios"],
        &["struggling"],
        &["studio"],
        &["studios"],
        &["still"],
        &["stupider"],
        &["stumbled"],
        &["stomach"],
        &["tsunami"],
        &["stupidly"],
        &["stupider"],
        &["stupidity"],
        &["stupidity"],
        &["stupider"],
        &["stupidly"],
        &["stupider"],
        &["stupidity"],
        &["structural"],
        &["structure"],
        &["structures"],
        &["struggled"],
        &["struggles"],
        &["struggling"],
        &["structure"],
        &["structured"],
        &["structures"],
        &["structure"],
        &["shutdown"],
        &["stuttering"],
        &["status"],
    ],
    range: 2..=8,
};

static WORD_STT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_STT_CHILDREN),
    value: None,
};

pub static WORD_STT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("eting"),
        dictgen::InsensitiveStr::Ascii("etings"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("ings"),
        dictgen::InsensitiveStr::Ascii("utering"),
    ],
    values: &[
        &["state"],
        &["setting"],
        &["settings"],
        &["string", "setting", "sitting"],
        &["strings", "settings", "sittings"],
        &["stuttering"],
    ],
    range: 1..=7,
};

static WORD_STS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_STS_CHILDREN),
    value: None,
};

pub static WORD_STS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("tion"),
        dictgen::InsensitiveStr::Ascii("tionary"),
        dictgen::InsensitiveStr::Ascii("tioned"),
        dictgen::InsensitiveStr::Ascii("tionery"),
        dictgen::InsensitiveStr::Ascii("tions"),
        dictgen::InsensitiveStr::Ascii("tr"),
    ],
    values: &[
        &["station"],
        &["stationary"],
        &["stationed"],
        &["stationery"],
        &["stations"],
        &["strstr"],
    ],
    range: 2..=7,
};

static WORD_STR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_STR_CHILDREN),
    value: None,
};

static WORD_STR_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_STRA_NODE),
    None,
    Some(&WORD_STRC_NODE),
    None,
    Some(&WORD_STRE_NODE),
    None,
    None,
    None,
    Some(&WORD_STRI_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_STRN_NODE),
    Some(&WORD_STRO_NODE),
    Some(&WORD_STRP_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_STRU_NODE),
    None,
    Some(&WORD_STRW_NODE),
    None,
    Some(&WORD_STRY_NODE),
    None,
];

static WORD_STRY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_STRY_CHILDREN),
    value: None,
};

pub static WORD_STRY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ofoam")],
    values: &[&["styrofoam"]],
    range: 5..=5,
};

static WORD_STRW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_STRW_CHILDREN),
    value: None,
};

pub static WORD_STRW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("aberry")],
    values: &[&["strawberry"]],
    range: 6..=6,
};

static WORD_STRU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_STRU_CHILDREN),
    value: None,
};

pub static WORD_STRU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("c"),
        dictgen::InsensitiveStr::Ascii("cgture"),
        dictgen::InsensitiveStr::Ascii("crure"),
        dictgen::InsensitiveStr::Ascii("crured"),
        dictgen::InsensitiveStr::Ascii("crures"),
        dictgen::InsensitiveStr::Ascii("cted"),
        dictgen::InsensitiveStr::Ascii("cter"),
        dictgen::InsensitiveStr::Ascii("ctere"),
        dictgen::InsensitiveStr::Ascii("ctered"),
        dictgen::InsensitiveStr::Ascii("cteres"),
        dictgen::InsensitiveStr::Ascii("ctetr"),
        dictgen::InsensitiveStr::Ascii("ctire"),
        dictgen::InsensitiveStr::Ascii("ctore"),
        dictgen::InsensitiveStr::Ascii("ctored"),
        dictgen::InsensitiveStr::Ascii("ctores"),
        dictgen::InsensitiveStr::Ascii("ctoring"),
        dictgen::InsensitiveStr::Ascii("ctre"),
        dictgen::InsensitiveStr::Ascii("ctred"),
        dictgen::InsensitiveStr::Ascii("ctres"),
        dictgen::InsensitiveStr::Ascii("ctrual"),
        dictgen::InsensitiveStr::Ascii("ctrue"),
        dictgen::InsensitiveStr::Ascii("ctrued"),
        dictgen::InsensitiveStr::Ascii("ctrues"),
        dictgen::InsensitiveStr::Ascii("ctual"),
        dictgen::InsensitiveStr::Ascii("ctue"),
        dictgen::InsensitiveStr::Ascii("ctued"),
        dictgen::InsensitiveStr::Ascii("ctues"),
        dictgen::InsensitiveStr::Ascii("ctur"),
        dictgen::InsensitiveStr::Ascii("cturel"),
        dictgen::InsensitiveStr::Ascii("cturels"),
        dictgen::InsensitiveStr::Ascii("cturs"),
        dictgen::InsensitiveStr::Ascii("cur"),
        dictgen::InsensitiveStr::Ascii("cure"),
        dictgen::InsensitiveStr::Ascii("cured"),
        dictgen::InsensitiveStr::Ascii("cures"),
        dictgen::InsensitiveStr::Ascii("curing"),
        dictgen::InsensitiveStr::Ascii("curs"),
        dictgen::InsensitiveStr::Ascii("cutral"),
        dictgen::InsensitiveStr::Ascii("cutre"),
        dictgen::InsensitiveStr::Ascii("cutred"),
        dictgen::InsensitiveStr::Ascii("cutres"),
        dictgen::InsensitiveStr::Ascii("cuture"),
        dictgen::InsensitiveStr::Ascii("ggel"),
        dictgen::InsensitiveStr::Ascii("ggeld"),
        dictgen::InsensitiveStr::Ascii("ggeled"),
        dictgen::InsensitiveStr::Ascii("ggeling"),
        dictgen::InsensitiveStr::Ascii("ggels"),
        dictgen::InsensitiveStr::Ascii("gglebus"),
        dictgen::InsensitiveStr::Ascii("ggleing"),
        dictgen::InsensitiveStr::Ascii("gglign"),
        dictgen::InsensitiveStr::Ascii("st"),
        dictgen::InsensitiveStr::Ascii("ttural"),
        dictgen::InsensitiveStr::Ascii("tture"),
        dictgen::InsensitiveStr::Ascii("ture"),
    ],
    values: &[
        &["struct"],
        &["structure"],
        &["structure"],
        &["structured"],
        &["structures"],
        &["structured"],
        &["structure"],
        &["structure"],
        &["structured"],
        &["structures"],
        &["structure"],
        &["structure"],
        &["structure"],
        &["structured"],
        &["structures"],
        &["structuring"],
        &["structure"],
        &["structured"],
        &["structures"],
        &["structural"],
        &["structure"],
        &["structured"],
        &["structures"],
        &["structural"],
        &["structure"],
        &["structured"],
        &["structures"],
        &["structure"],
        &["structural"],
        &["structures"],
        &["structures"],
        &["structure"],
        &["structure"],
        &["structured"],
        &["structures"],
        &["structuring"],
        &["structures"],
        &["structural"],
        &["structure"],
        &["structured"],
        &["structures"],
        &["structure"],
        &["struggle"],
        &["struggled"],
        &["struggled"],
        &["struggling"],
        &["struggles"],
        &["struggles"],
        &["struggling"],
        &["struggling"],
        &["strut", "trust"],
        &["structural"],
        &["structure"],
        &["structure"],
    ],
    range: 1..=7,
};

static WORD_STRP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_STRP_CHILDREN),
    value: None,
};

pub static WORD_STRP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("iped")],
    values: &[&["stripped"]],
    range: 4..=4,
};

static WORD_STRO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_STRO_CHILDREN),
    value: None,
};

pub static WORD_STRO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("age"),
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("med"),
        dictgen::InsensitiveStr::Ascii("mfront"),
        dictgen::InsensitiveStr::Ascii("nkhold"),
        dictgen::InsensitiveStr::Ascii("nlgy"),
        dictgen::InsensitiveStr::Ascii("nly"),
        dictgen::InsensitiveStr::Ascii("rage"),
        dictgen::InsensitiveStr::Ascii("re"),
        dictgen::InsensitiveStr::Ascii("red"),
        dictgen::InsensitiveStr::Ascii("res"),
        dictgen::InsensitiveStr::Ascii("ring"),
        dictgen::InsensitiveStr::Ascii("tage"),
        dictgen::InsensitiveStr::Ascii("y"),
        dictgen::InsensitiveStr::Ascii("yboard"),
        dictgen::InsensitiveStr::Ascii("yline"),
        dictgen::InsensitiveStr::Ascii("ylines"),
        dictgen::InsensitiveStr::Ascii("ytelling"),
    ],
    values: &[
        &["storage"],
        &["store"],
        &["storing"],
        &["stormed"],
        &["stormfront"],
        &["stronghold"],
        &["strongly"],
        &["strongly"],
        &["storage"],
        &["store"],
        &["stored"],
        &["stores"],
        &["storing"],
        &["storage"],
        &["story", "destroy"],
        &["storyboard"],
        &["storyline"],
        &["storylines"],
        &["storytelling"],
    ],
    range: 1..=8,
};

static WORD_STRN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_STRN_CHILDREN),
    value: None,
};

pub static WORD_STRN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ad"),
        dictgen::InsensitiveStr::Ascii("g"),
    ],
    values: &[&["strand"], &["string"]],
    range: 1..=2,
};

static WORD_STRI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_STRI_CHILDREN),
    value: None,
};

pub static WORD_STRI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aght"),
        dictgen::InsensitiveStr::Ascii("aghten"),
        dictgen::InsensitiveStr::Ascii("aghtens"),
        dictgen::InsensitiveStr::Ascii("aghtforward"),
        dictgen::InsensitiveStr::Ascii("aghts"),
        dictgen::InsensitiveStr::Ascii("ans"),
        dictgen::InsensitiveStr::Ascii("clty"),
        dictgen::InsensitiveStr::Ascii("cly"),
        dictgen::InsensitiveStr::Ascii("cteir"),
        dictgen::InsensitiveStr::Ascii("ctier"),
        dictgen::InsensitiveStr::Ascii("ctiest"),
        dictgen::InsensitiveStr::Ascii("ctist"),
        dictgen::InsensitiveStr::Ascii("cty"),
        dictgen::InsensitiveStr::Ascii("ekr"),
        dictgen::InsensitiveStr::Ascii("ekrs"),
        dictgen::InsensitiveStr::Ascii("g"),
        dictgen::InsensitiveStr::Ascii("gification"),
        dictgen::InsensitiveStr::Ascii("gifying"),
        dictgen::InsensitiveStr::Ascii("gn"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("ings"),
        dictgen::InsensitiveStr::Ascii("kely"),
        dictgen::InsensitiveStr::Ascii("nget"),
        dictgen::InsensitiveStr::Ascii("ngifed"),
        dictgen::InsensitiveStr::Ascii("ngnet"),
        dictgen::InsensitiveStr::Ascii("nsg"),
        dictgen::InsensitiveStr::Ascii("ppen"),
        dictgen::InsensitiveStr::Ascii("pt"),
        dictgen::InsensitiveStr::Ascii("pted"),
        dictgen::InsensitiveStr::Ascii("pting"),
        dictgen::InsensitiveStr::Ascii("pts"),
        dictgen::InsensitiveStr::Ascii("rngification"),
    ],
    values: &[
        &["straight"],
        &["straighten"],
        &["straightens"],
        &["straightforward"],
        &["straights"],
        &["strains"],
        &["strictly"],
        &["strictly"],
        &["stricter"],
        &["stricter"],
        &["strictest"],
        &["strictest"],
        &["strictly"],
        &["striker"],
        &["strikers"],
        &["string"],
        &["stringification"],
        &["stringifying"],
        &["string"],
        &["string"],
        &["strings"],
        &["strikingly"],
        &["stringent"],
        &["stringified"],
        &["stringent"],
        &["strings"],
        &["stripped"],
        &["stripped", "script"],
        &["scripted", "stripped"],
        &["scripting", "stripping"],
        &["scripts", "strips"],
        &["stringification"],
    ],
    range: 1..=12,
};

static WORD_STRE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_STRE_CHILDREN),
    value: None,
};

static WORD_STRE_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_STREA_NODE),
    None,
    Some(&WORD_STREC_NODE),
    None,
    Some(&WORD_STREE_NODE),
    None,
    Some(&WORD_STREG_NODE),
    None,
    Some(&WORD_STREI_NODE),
    None,
    None,
    None,
    Some(&WORD_STREM_NODE),
    Some(&WORD_STREN_NODE),
    Some(&WORD_STREO_NODE),
    None,
    None,
    Some(&WORD_STRER_NODE),
    Some(&WORD_STRES_NODE),
    Some(&WORD_STRET_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_STRET_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_STRET_CHILDREN),
    value: None,
};

pub static WORD_STRET_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("chs"),
        dictgen::InsensitiveStr::Ascii("egically"),
    ],
    values: &[&["stretches"], &["strategically"]],
    range: 3..=8,
};

static WORD_STRES_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_STRES_CHILDREN),
    value: None,
};

pub static WORD_STRES_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("sade"),
        dictgen::InsensitiveStr::Ascii("sende"),
        dictgen::InsensitiveStr::Ascii("sers"),
        dictgen::InsensitiveStr::Ascii("ss"),
    ],
    values: &[&["stressed"], &["stressed"], &["stresses"], &["stresses"]],
    range: 2..=5,
};

static WORD_STRER_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_STRER_CHILDREN),
    value: None,
};

pub static WORD_STRER_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("rror")],
    values: &[&["strerror"]],
    range: 4..=4,
};

static WORD_STREO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_STREO_CHILDREN),
    value: None,
};

pub static WORD_STREO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("id")],
    values: &[&["steroid"]],
    range: 2..=2,
};

static WORD_STREN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_STREN_CHILDREN),
    value: None,
};

pub static WORD_STREN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("gh"),
        dictgen::InsensitiveStr::Ascii("ghen"),
        dictgen::InsensitiveStr::Ascii("ghened"),
        dictgen::InsensitiveStr::Ascii("ghening"),
        dictgen::InsensitiveStr::Ascii("ght"),
        dictgen::InsensitiveStr::Ascii("ghten"),
        dictgen::InsensitiveStr::Ascii("ghtend"),
        dictgen::InsensitiveStr::Ascii("ghtened"),
        dictgen::InsensitiveStr::Ascii("ghtening"),
        dictgen::InsensitiveStr::Ascii("ghtens"),
        dictgen::InsensitiveStr::Ascii("ghts"),
        dictgen::InsensitiveStr::Ascii("gsten"),
        dictgen::InsensitiveStr::Ascii("gtened"),
        dictgen::InsensitiveStr::Ascii("gtheing"),
        dictgen::InsensitiveStr::Ascii("gthes"),
        dictgen::InsensitiveStr::Ascii("gthin"),
        dictgen::InsensitiveStr::Ascii("gthining"),
        dictgen::InsensitiveStr::Ascii("gthn"),
        dictgen::InsensitiveStr::Ascii("gts"),
        dictgen::InsensitiveStr::Ascii("ous"),
        dictgen::InsensitiveStr::Ascii("tgh"),
        dictgen::InsensitiveStr::Ascii("tghs"),
        dictgen::InsensitiveStr::Ascii("th"),
    ],
    values: &[
        &["strength"],
        &["strengthen"],
        &["strengthened"],
        &["strengthening"],
        &["strength"],
        &["strengthen"],
        &["strengthen"],
        &["strengthened"],
        &["strengthening"],
        &["strengthen"],
        &["strengths"],
        &["strengthen"],
        &["strengthened"],
        &["strengthening"],
        &["strengths"],
        &["strengthen"],
        &["strengthening"],
        &["strengthen"],
        &["strengths"],
        &["strenuous"],
        &["strength"],
        &["strengths"],
        &["strength"],
    ],
    range: 2..=8,
};

static WORD_STREM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_STREM_CHILDREN),
    value: Some(&["stream"]),
};

pub static WORD_STREM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("a"),
        dictgen::InsensitiveStr::Ascii("ear"),
    ],
    values: &[&["stream"], &["streamer"]],
    range: 1..=3,
};

static WORD_STREI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_STREI_CHILDREN),
    value: None,
};

pub static WORD_STREI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("chung"),
        dictgen::InsensitiveStr::Ascii("ght"),
        dictgen::InsensitiveStr::Ascii("ghtened"),
        dictgen::InsensitiveStr::Ascii("ghtish"),
        dictgen::InsensitiveStr::Ascii("ghtly"),
        dictgen::InsensitiveStr::Ascii("ghtness"),
        dictgen::InsensitiveStr::Ascii("ghts"),
        dictgen::InsensitiveStr::Ascii("gt"),
        dictgen::InsensitiveStr::Ascii("gtish"),
        dictgen::InsensitiveStr::Ascii("gtly"),
        dictgen::InsensitiveStr::Ascii("gtness"),
        dictgen::InsensitiveStr::Ascii("gts"),
    ],
    values: &[
        &["stretching"],
        &["straight", "strait"],
        &["straightened"],
        &["straightish"],
        &["straightly"],
        &["straightness"],
        &["straights", "straits"],
        &["straight", "strait"],
        &["straightish"],
        &["straightly"],
        &["straightness"],
        &["straights", "straits"],
    ],
    range: 2..=7,
};

static WORD_STREG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_STREG_CHILDREN),
    value: None,
};

pub static WORD_STREG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("nth"),
        dictgen::InsensitiveStr::Ascii("nthen"),
        dictgen::InsensitiveStr::Ascii("nthening"),
        dictgen::InsensitiveStr::Ascii("nths"),
        dictgen::InsensitiveStr::Ascii("th"),
    ],
    values: &[
        &["strength"],
        &["strengthen"],
        &["strengthening"],
        &["strengths"],
        &["strength"],
    ],
    range: 2..=8,
};

static WORD_STREE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_STREE_CHILDREN),
    value: None,
};

pub static WORD_STREE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("m"),
        dictgen::InsensitiveStr::Ascii("mlining"),
    ],
    values: &[&["stream"], &["streamlining"]],
    range: 1..=7,
};

static WORD_STREC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_STREC_CHILDREN),
    value: None,
};

pub static WORD_STREC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("h"),
        dictgen::InsensitiveStr::Ascii("hed"),
        dictgen::InsensitiveStr::Ascii("hes"),
        dictgen::InsensitiveStr::Ascii("hing"),
        dictgen::InsensitiveStr::Ascii("hted"),
        dictgen::InsensitiveStr::Ascii("htes"),
        dictgen::InsensitiveStr::Ascii("hting"),
        dictgen::InsensitiveStr::Ascii("tch"),
        dictgen::InsensitiveStr::Ascii("th"),
        dictgen::InsensitiveStr::Ascii("thed"),
        dictgen::InsensitiveStr::Ascii("thes"),
        dictgen::InsensitiveStr::Ascii("thing"),
    ],
    values: &[
        &["stretch"],
        &["stretched"],
        &["stretches"],
        &["stretching"],
        &["stretched"],
        &["stretches"],
        &["stretching"],
        &["stretch"],
        &["stretch"],
        &["stretched"],
        &["stretches"],
        &["stretching"],
    ],
    range: 1..=5,
};

static WORD_STREA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_STREA_CHILDREN),
    value: None,
};

pub static WORD_STREA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ching"),
        dictgen::InsensitiveStr::Ascii("made"),
        dictgen::InsensitiveStr::Ascii("mare"),
        dictgen::InsensitiveStr::Ascii("md"),
        dictgen::InsensitiveStr::Ascii("mear"),
        dictgen::InsensitiveStr::Ascii("mes"),
        dictgen::InsensitiveStr::Ascii("mm"),
        dictgen::InsensitiveStr::Ascii("mmed"),
        dictgen::InsensitiveStr::Ascii("mming"),
        dictgen::InsensitiveStr::Ascii("mos"),
        dictgen::InsensitiveStr::Ascii("mtrue"),
        dictgen::InsensitiveStr::Ascii("mus"),
        dictgen::InsensitiveStr::Ascii("mys"),
        dictgen::InsensitiveStr::Ascii("tched"),
        dictgen::InsensitiveStr::Ascii("tching"),
    ],
    values: &[
        &["stretching"],
        &["streamed"],
        &["streamer"],
        &["streamed"],
        &["streamer"],
        &["streams"],
        &["stream"],
        &["streamed"],
        &["streaming"],
        &["streams"],
        &["streamer"],
        &["streams"],
        &["streams"],
        &["stretched"],
        &["stretching"],
    ],
    range: 2..=6,
};

static WORD_STRC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_STRC_CHILDREN),
    value: None,
};

pub static WORD_STRC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("iter"),
        dictgen::InsensitiveStr::Ascii("ture"),
        dictgen::InsensitiveStr::Ascii("tures"),
        dictgen::InsensitiveStr::Ascii("utre"),
        dictgen::InsensitiveStr::Ascii("utural"),
        dictgen::InsensitiveStr::Ascii("uture"),
        dictgen::InsensitiveStr::Ascii("utures"),
    ],
    values: &[
        &["stricter"],
        &["structure"],
        &["structures"],
        &["structure"],
        &["structural"],
        &["structure"],
        &["structures"],
    ],
    range: 4..=6,
};

static WORD_STRA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_STRA_CHILDREN),
    value: None,
};

static WORD_STRA_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    Some(&WORD_STRAC_NODE),
    Some(&WORD_STRAD_NODE),
    None,
    None,
    Some(&WORD_STRAG_NODE),
    None,
    Some(&WORD_STRAI_NODE),
    None,
    None,
    None,
    Some(&WORD_STRAM_NODE),
    Some(&WORD_STRAN_NODE),
    None,
    None,
    None,
    Some(&WORD_STRAR_NODE),
    None,
    Some(&WORD_STRAT_NODE),
    None,
    Some(&WORD_STRAV_NODE),
    Some(&WORD_STRAW_NODE),
    None,
    None,
    None,
];

static WORD_STRAW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_STRAW_CHILDREN),
    value: None,
};

pub static WORD_STRAW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("barry"),
        dictgen::InsensitiveStr::Ascii("beary"),
        dictgen::InsensitiveStr::Ascii("beery"),
        dictgen::InsensitiveStr::Ascii("beries"),
        dictgen::InsensitiveStr::Ascii("berrries"),
        dictgen::InsensitiveStr::Ascii("berrry"),
        dictgen::InsensitiveStr::Ascii("bery"),
        dictgen::InsensitiveStr::Ascii("brary"),
        dictgen::InsensitiveStr::Ascii("brerry"),
        dictgen::InsensitiveStr::Ascii("burries"),
        dictgen::InsensitiveStr::Ascii("burry"),
    ],
    values: &[
        &["strawberry"],
        &["strawberry"],
        &["strawberry"],
        &["strawberries"],
        &["strawberries"],
        &["strawberry"],
        &["strawberry"],
        &["strawberry"],
        &["strawberry"],
        &["strawberries"],
        &["strawberry"],
    ],
    range: 4..=8,
};

static WORD_STRAV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_STRAV_CHILDREN),
    value: None,
};

pub static WORD_STRAV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ation")],
    values: &[&["starvation"]],
    range: 5..=5,
};

static WORD_STRAT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_STRAT_CHILDREN),
    value: Some(&["start", "strata"]),
};

pub static WORD_STRAT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("agically"),
        dictgen::InsensitiveStr::Ascii("agies"),
        dictgen::InsensitiveStr::Ascii("egems"),
        dictgen::InsensitiveStr::Ascii("egicaly"),
        dictgen::InsensitiveStr::Ascii("egice"),
        dictgen::InsensitiveStr::Ascii("egiclly"),
        dictgen::InsensitiveStr::Ascii("egis"),
        dictgen::InsensitiveStr::Ascii("egisch"),
        dictgen::InsensitiveStr::Ascii("egisk"),
        dictgen::InsensitiveStr::Ascii("egiske"),
        dictgen::InsensitiveStr::Ascii("gey"),
        dictgen::InsensitiveStr::Ascii("igically"),
        dictgen::InsensitiveStr::Ascii("led"),
    ],
    values: &[
        &["strategically"],
        &["strategies"],
        &["strategies"],
        &["strategically"],
        &["strategies"],
        &["strategically"],
        &["strategies"],
        &["strategic"],
        &["strategies"],
        &["strategies"],
        &["strategy"],
        &["strategically"],
        &["startled"],
    ],
    range: 3..=8,
};

static WORD_STRAR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_STRAR_CHILDREN),
    value: None,
};

pub static WORD_STRAR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("ted"),
        dictgen::InsensitiveStr::Ascii("ting"),
        dictgen::InsensitiveStr::Ascii("ts"),
    ],
    values: &[&["start"], &["started"], &["starting"], &["starts"]],
    range: 1..=4,
};

static WORD_STRAN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_STRAN_CHILDREN),
    value: Some(&["strand", "strain"]),
};

pub static WORD_STRAN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("gel"),
        dictgen::InsensitiveStr::Ascii("geshit"),
        dictgen::InsensitiveStr::Ascii("get"),
        dictgen::InsensitiveStr::Ascii("gets"),
        dictgen::InsensitiveStr::Ascii("glove"),
        dictgen::InsensitiveStr::Ascii("gly"),
        dictgen::InsensitiveStr::Ascii("gness"),
        dictgen::InsensitiveStr::Ascii("greal"),
    ],
    values: &[
        &["strangle"],
        &["strangest"],
        &["strangest"],
        &["strangest"],
        &["strangle"],
        &["strangely", "strange", "strangle"],
        &["strangeness"],
        &["strangle"],
    ],
    range: 3..=6,
};

static WORD_STRAM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_STRAM_CHILDREN),
    value: Some(&["steam", "stream", "tram"]),
};

pub static WORD_STRAM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("s"),
    ],
    values: &[&["streaming", "steaming"], &["steams", "streams", "trams"]],
    range: 1..=3,
};

static WORD_STRAI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_STRAI_CHILDREN),
    value: None,
};

pub static WORD_STRAI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ghforward"),
        dictgen::InsensitiveStr::Ascii("ghtden"),
        dictgen::InsensitiveStr::Ascii("ghted"),
        dictgen::InsensitiveStr::Ascii("ghtend"),
        dictgen::InsensitiveStr::Ascii("ghtenend"),
        dictgen::InsensitiveStr::Ascii("ghtforeward"),
        dictgen::InsensitiveStr::Ascii("ghtforwad"),
        dictgen::InsensitiveStr::Ascii("ghtfoward"),
        dictgen::InsensitiveStr::Ascii("ghtie"),
        dictgen::InsensitiveStr::Ascii("ghtin"),
        dictgen::InsensitiveStr::Ascii("ghtmen"),
        dictgen::InsensitiveStr::Ascii("ghtn"),
        dictgen::InsensitiveStr::Ascii("ghtned"),
        dictgen::InsensitiveStr::Ascii("ghtner"),
        dictgen::InsensitiveStr::Ascii("gnt"),
        dictgen::InsensitiveStr::Ascii("gntened"),
        dictgen::InsensitiveStr::Ascii("gt"),
        dictgen::InsensitiveStr::Ascii("gth"),
        dictgen::InsensitiveStr::Ascii("gthen"),
        dictgen::InsensitiveStr::Ascii("gthened"),
        dictgen::InsensitiveStr::Ascii("gthening"),
        dictgen::InsensitiveStr::Ascii("gthforward"),
        dictgen::InsensitiveStr::Ascii("nd"),
        dictgen::InsensitiveStr::Ascii("nes"),
        dictgen::InsensitiveStr::Ascii("ngs"),
        dictgen::InsensitiveStr::Ascii("tforward"),
    ],
    values: &[
        &["straightforward"],
        &["straightened"],
        &["straightened"],
        &["straightened"],
        &["straightened"],
        &["straightforward"],
        &["straightforward"],
        &["straightforward"],
        &["straighten"],
        &["straighten"],
        &["straighten"],
        &["straighten"],
        &["straightened"],
        &["straighten"],
        &["straighten"],
        &["straightened"],
        &["straight"],
        &["straight"],
        &["straighten"],
        &["straightened"],
        &["straightening"],
        &["straightforward"],
        &["strained"],
        &["strains"],
        &["strains"],
        &["straightforward"],
    ],
    range: 2..=11,
};

static WORD_STRAG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_STRAG_CHILDREN),
    value: None,
};

pub static WORD_STRAG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("edy"),
        dictgen::InsensitiveStr::Ascii("egically"),
        dictgen::InsensitiveStr::Ascii("egy"),
        dictgen::InsensitiveStr::Ascii("etic"),
        dictgen::InsensitiveStr::Ascii("etically"),
        dictgen::InsensitiveStr::Ascii("eties"),
        dictgen::InsensitiveStr::Ascii("ety"),
    ],
    values: &[
        &["storage", "strange"],
        &["strategy", "tragedy"],
        &["strategically"],
        &["strategy"],
        &["strategic"],
        &["strategically"],
        &["strategies"],
        &["strategy"],
    ],
    range: 1..=8,
};

static WORD_STRAD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_STRAD_CHILDREN),
    value: None,
};

pub static WORD_STRAD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("egies"),
        dictgen::InsensitiveStr::Ascii("egy"),
    ],
    values: &[&["strategies"], &["strategy"]],
    range: 3..=5,
};

static WORD_STRAC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_STRAC_CHILDREN),
    value: None,
};

pub static WORD_STRAC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("k")],
    values: &[&["stack", "track"]],
    range: 1..=1,
};

static WORD_STP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_STP_CHILDREN),
    value: None,
};

pub static WORD_STP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("iped"),
        dictgen::InsensitiveStr::Ascii("o"),
    ],
    values: &[&["stripped"], &["stop"]],
    range: 1..=4,
};

static WORD_STO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_STO_CHILDREN),
    value: None,
};

pub static WORD_STO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("age"),
        dictgen::InsensitiveStr::Ascii("ages"),
        dictgen::InsensitiveStr::Ascii("cahstic"),
        dictgen::InsensitiveStr::Ascii("castic"),
        dictgen::InsensitiveStr::Ascii("ckpilled"),
        dictgen::InsensitiveStr::Ascii("ckplie"),
        dictgen::InsensitiveStr::Ascii("er"),
        dictgen::InsensitiveStr::Ascii("ers"),
        dictgen::InsensitiveStr::Ascii("mache"),
        dictgen::InsensitiveStr::Ascii("mpted"),
        dictgen::InsensitiveStr::Ascii("mrfront"),
        dictgen::InsensitiveStr::Ascii("ng"),
        dictgen::InsensitiveStr::Ascii("ped"),
        dictgen::InsensitiveStr::Ascii("ping"),
        dictgen::InsensitiveStr::Ascii("pp"),
        dictgen::InsensitiveStr::Ascii("ppped"),
        dictgen::InsensitiveStr::Ascii("ppping"),
        dictgen::InsensitiveStr::Ascii("pps"),
        dictgen::InsensitiveStr::Ascii("pry"),
        dictgen::InsensitiveStr::Ascii("rag"),
        dictgen::InsensitiveStr::Ascii("reable"),
        dictgen::InsensitiveStr::Ascii("reage"),
        dictgen::InsensitiveStr::Ascii("ream"),
        dictgen::InsensitiveStr::Ascii("reble"),
        dictgen::InsensitiveStr::Ascii("reing"),
        dictgen::InsensitiveStr::Ascii("reis"),
        dictgen::InsensitiveStr::Ascii("relines"),
        dictgen::InsensitiveStr::Ascii("rge"),
        dictgen::InsensitiveStr::Ascii("rise"),
        dictgen::InsensitiveStr::Ascii("rmade"),
        dictgen::InsensitiveStr::Ascii("rmde"),
        dictgen::InsensitiveStr::Ascii("rmend"),
        dictgen::InsensitiveStr::Ascii("rmfornt"),
        dictgen::InsensitiveStr::Ascii("rmfromt"),
        dictgen::InsensitiveStr::Ascii("rmfrount"),
        dictgen::InsensitiveStr::Ascii("rnegst"),
        dictgen::InsensitiveStr::Ascii("rnfront"),
        dictgen::InsensitiveStr::Ascii("rnghold"),
        dictgen::InsensitiveStr::Ascii("rys"),
        dictgen::InsensitiveStr::Ascii("ryteling"),
        dictgen::InsensitiveStr::Ascii("rytellling"),
        dictgen::InsensitiveStr::Ascii("yr"),
    ],
    values: &[
        &["storage"],
        &["storages"],
        &["stochastic"],
        &["stochastic"],
        &["stockpile"],
        &["stockpile"],
        &["store"],
        &["stores"],
        &["stomach"],
        &["stomped"],
        &["stormfront"],
        &["strong"],
        &["stopped"],
        &["stopping"],
        &["stop"],
        &["stopped"],
        &["stopping"],
        &["stops"],
        &["story"],
        &["storage"],
        &["storable"],
        &["storage"],
        &["stream"],
        &["storable"],
        &["storing"],
        &["storeys", "stores"],
        &["storylines"],
        &["storage"],
        &["stories"],
        &["stormed"],
        &["stormed"],
        &["stormed"],
        &["stormfront"],
        &["stormfront"],
        &["stormfront"],
        &["strongest"],
        &["stormfront"],
        &["stronghold"],
        &["storeys"],
        &["storytelling"],
        &["storytelling"],
        &["story"],
    ],
    range: 2..=10,
};

static WORD_STN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_STN_CHILDREN),
    value: None,
};

pub static WORD_STN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ad"),
        dictgen::InsensitiveStr::Ascii("dard"),
    ],
    values: &[&["stand"], &["standard"]],
    range: 2..=4,
};

static WORD_STL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_STL_CHILDREN),
    value: None,
};

pub static WORD_STL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aker"),
        dictgen::InsensitiveStr::Ascii("akers"),
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("ye"),
        dictgen::InsensitiveStr::Ascii("yes"),
        dictgen::InsensitiveStr::Ascii("yish"),
    ],
    values: &[
        &["stalker"],
        &["stalkers"],
        &["style"],
        &["style"],
        &["styles"],
        &["stylish"],
    ],
    range: 1..=5,
};

static WORD_STI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_STI_CHILDREN),
    value: None,
};

pub static WORD_STI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("chted"),
        dictgen::InsensitiveStr::Ascii("chting"),
        dictgen::InsensitiveStr::Ascii("ckes"),
        dictgen::InsensitiveStr::Ascii("ckness"),
        dictgen::InsensitiveStr::Ascii("ckyness"),
        dictgen::InsensitiveStr::Ascii("cthed"),
        dictgen::InsensitiveStr::Ascii("cthes"),
        dictgen::InsensitiveStr::Ascii("cthing"),
        dictgen::InsensitiveStr::Ascii("ffneing"),
        dictgen::InsensitiveStr::Ascii("ky"),
        dictgen::InsensitiveStr::Ascii("l"),
        dictgen::InsensitiveStr::Ascii("lus"),
        dictgen::InsensitiveStr::Ascii("milants"),
        dictgen::InsensitiveStr::Ascii("milated"),
        dictgen::InsensitiveStr::Ascii("mluating"),
        dictgen::InsensitiveStr::Ascii("mualted"),
        dictgen::InsensitiveStr::Ascii("mualting"),
        dictgen::InsensitiveStr::Ascii("mualtion"),
        dictgen::InsensitiveStr::Ascii("mulai"),
        dictgen::InsensitiveStr::Ascii("mulans"),
        dictgen::InsensitiveStr::Ascii("mulantes"),
        dictgen::InsensitiveStr::Ascii("mulas"),
        dictgen::InsensitiveStr::Ascii("mulat"),
        dictgen::InsensitiveStr::Ascii("mulatie"),
        dictgen::InsensitiveStr::Ascii("mulatin"),
        dictgen::InsensitiveStr::Ascii("mulaton"),
        dictgen::InsensitiveStr::Ascii("mulents"),
        dictgen::InsensitiveStr::Ascii("mulli"),
        dictgen::InsensitiveStr::Ascii("ngent"),
        dictgen::InsensitiveStr::Ascii("p"),
        dictgen::InsensitiveStr::Ascii("pped"),
        dictgen::InsensitiveStr::Ascii("ring"),
        dictgen::InsensitiveStr::Ascii("rker"),
        dictgen::InsensitiveStr::Ascii("rkers"),
        dictgen::InsensitiveStr::Ascii("rng"),
        dictgen::InsensitiveStr::Ascii("rngs"),
        dictgen::InsensitiveStr::Ascii("rr"),
        dictgen::InsensitiveStr::Ascii("rrig"),
        dictgen::InsensitiveStr::Ascii("rrs"),
        dictgen::InsensitiveStr::Ascii("tchs"),
        dictgen::InsensitiveStr::Ascii("vk"),
        dictgen::InsensitiveStr::Ascii("vks"),
    ],
    values: &[
        &["stitched"],
        &["stitching"],
        &["stickers"],
        &["stickiness"],
        &["stickiness"],
        &["stitched"],
        &["stitches"],
        &["stitching"],
        &["stiffening"],
        &["sticky"],
        &["still"],
        &["stylus"],
        &["stimulants"],
        &["stimulated"],
        &["stimulating"],
        &["stimulated"],
        &["stimulating"],
        &["stimulation"],
        &["stimuli"],
        &["stimulants"],
        &["stimulants"],
        &["stimulants"],
        &["stimulants"],
        &["stimulated"],
        &["stimulation"],
        &["stimulation"],
        &["stimulants"],
        &["stimuli"],
        &["stringent"],
        &["stop", "strip"],
        &["stripped"],
        &["stirring"],
        &["striker"],
        &["strikers"],
        &["string"],
        &["strings"],
        &["stir"],
        &["stirring"],
        &["stirs"],
        &["stitches"],
        &["stick"],
        &["sticks"],
    ],
    range: 1..=8,
};

static WORD_STE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_STE_CHILDREN),
    value: None,
};

pub static WORD_STE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("adilly"),
        dictgen::InsensitiveStr::Ascii("adliy"),
        dictgen::InsensitiveStr::Ascii("alhty"),
        dictgen::InsensitiveStr::Ascii("althboy"),
        dictgen::InsensitiveStr::Ascii("althely"),
        dictgen::InsensitiveStr::Ascii("althify"),
        dictgen::InsensitiveStr::Ascii("althly"),
        dictgen::InsensitiveStr::Ascii("althray"),
        dictgen::InsensitiveStr::Ascii("alty"),
        dictgen::InsensitiveStr::Ascii("athly"),
        dictgen::InsensitiveStr::Ascii("eleries"),
        dictgen::InsensitiveStr::Ascii("eles"),
        dictgen::InsensitiveStr::Ascii("gnographic"),
        dictgen::InsensitiveStr::Ascii("gnography"),
        dictgen::InsensitiveStr::Ascii("lathy"),
        dictgen::InsensitiveStr::Ascii("ngth"),
        dictgen::InsensitiveStr::Ascii("orid"),
        dictgen::InsensitiveStr::Ascii("ram"),
        dictgen::InsensitiveStr::Ascii("ramed"),
        dictgen::InsensitiveStr::Ascii("ramer"),
        dictgen::InsensitiveStr::Ascii("raming"),
        dictgen::InsensitiveStr::Ascii("rams"),
        dictgen::InsensitiveStr::Ascii("reotipe"),
        dictgen::InsensitiveStr::Ascii("reotipical"),
        dictgen::InsensitiveStr::Ascii("reotpye"),
        dictgen::InsensitiveStr::Ascii("reotpyes"),
        dictgen::InsensitiveStr::Ascii("reotpyical"),
        dictgen::InsensitiveStr::Ascii("reotpying"),
        dictgen::InsensitiveStr::Ascii("reotying"),
        dictgen::InsensitiveStr::Ascii("reotypcial"),
        dictgen::InsensitiveStr::Ascii("reotypeing"),
        dictgen::InsensitiveStr::Ascii("reotypers"),
        dictgen::InsensitiveStr::Ascii("reotypian"),
        dictgen::InsensitiveStr::Ascii("reotypying"),
        dictgen::InsensitiveStr::Ascii("riel"),
        dictgen::InsensitiveStr::Ascii("rilze"),
        dictgen::InsensitiveStr::Ascii("rio"),
        dictgen::InsensitiveStr::Ascii("riods"),
        dictgen::InsensitiveStr::Ascii("riotype"),
        dictgen::InsensitiveStr::Ascii("riotypes"),
        dictgen::InsensitiveStr::Ascii("riotypical"),
        dictgen::InsensitiveStr::Ascii("riotyping"),
        dictgen::InsensitiveStr::Ascii("rlie"),
        dictgen::InsensitiveStr::Ascii("roetype"),
        dictgen::InsensitiveStr::Ascii("roetypes"),
        dictgen::InsensitiveStr::Ascii("roetypical"),
        dictgen::InsensitiveStr::Ascii("roetyping"),
        dictgen::InsensitiveStr::Ascii("rotype"),
        dictgen::InsensitiveStr::Ascii("rotypes"),
        dictgen::InsensitiveStr::Ascii("ryotype"),
        dictgen::InsensitiveStr::Ascii("ryotypes"),
        dictgen::InsensitiveStr::Ascii("ryotypical"),
        dictgen::InsensitiveStr::Ascii("ryotyping"),
    ],
    values: &[
        &["steadily"],
        &["steadily"],
        &["stealthy"],
        &["stealthy"],
        &["stealthy"],
        &["stealthy"],
        &["stealthy"],
        &["stealthy"],
        &["stealthy"],
        &["stealthy"],
        &["steelers"],
        &["steelers"],
        &["steganographic"],
        &["steganography"],
        &["stealthy"],
        &["strength"],
        &["steroid"],
        &["stream"],
        &["streamed"],
        &["streamer"],
        &["streaming"],
        &["streams"],
        &["stereotype"],
        &["stereotypical"],
        &["stereotypes"],
        &["stereotypes"],
        &["stereotypical"],
        &["stereotyping"],
        &["stereotyping"],
        &["stereotypical"],
        &["stereotyping"],
        &["stereotypes"],
        &["stereotyping"],
        &["stereotyping"],
        &["sterile"],
        &["sterile"],
        &["stereo"],
        &["steroids"],
        &["stereotype"],
        &["stereotypes"],
        &["stereotypical"],
        &["stereotyping"],
        &["sterile"],
        &["stereotype"],
        &["stereotypes"],
        &["stereotypical"],
        &["stereotyping"],
        &["stereotype"],
        &["stereotypes"],
        &["stereotype"],
        &["stereotypes"],
        &["stereotypical"],
        &["stereotyping"],
    ],
    range: 3..=10,
};

static WORD_STD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_STD_CHILDREN),
    value: None,
};

pub static WORD_STD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("anard"),
        dictgen::InsensitiveStr::Ascii("anards"),
        dictgen::InsensitiveStr::Ascii("errr"),
    ],
    values: &[&["standard"], &["standards"], &["stderr"]],
    range: 4..=6,
};

static WORD_STC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_STC_CHILDREN),
    value: None,
};

pub static WORD_STC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("okbrush")],
    values: &[&["stockbrush"]],
    range: 7..=7,
};

static WORD_STA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_STA_CHILDREN),
    value: None,
};

static WORD_STA_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    Some(&WORD_STAB_NODE),
    Some(&WORD_STAC_NODE),
    Some(&WORD_STAD_NODE),
    Some(&WORD_STAE_NODE),
    None,
    Some(&WORD_STAG_NODE),
    None,
    Some(&WORD_STAI_NODE),
    None,
    Some(&WORD_STAK_NODE),
    Some(&WORD_STAL_NODE),
    Some(&WORD_STAM_NODE),
    Some(&WORD_STAN_NODE),
    Some(&WORD_STAO_NODE),
    Some(&WORD_STAP_NODE),
    None,
    Some(&WORD_STAR_NODE),
    None,
    Some(&WORD_STAT_NODE),
    Some(&WORD_STAU_NODE),
    None,
    Some(&WORD_STAW_NODE),
    None,
    None,
    None,
];

static WORD_STAW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_STAW_CHILDREN),
    value: None,
};

pub static WORD_STAW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("berries"),
        dictgen::InsensitiveStr::Ascii("berry"),
        dictgen::InsensitiveStr::Ascii("k"),
    ],
    values: &[&["strawberries"], &["strawberry"], &["stalk"]],
    range: 1..=7,
};

static WORD_STAU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_STAU_CHILDREN),
    value: None,
};

pub static WORD_STAU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("lk"),
        dictgen::InsensitiveStr::Ascii("ration"),
        dictgen::InsensitiveStr::Ascii("rday"),
        dictgen::InsensitiveStr::Ascii("rdays"),
        dictgen::InsensitiveStr::Ascii("s"),
        dictgen::InsensitiveStr::Ascii("tes"),
    ],
    values: &[
        &["stalk"],
        &["saturation"],
        &["saturday"],
        &["saturdays"],
        &["status"],
        &["statues"],
    ],
    range: 1..=6,
};

static WORD_STAT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_STAT_CHILDREN),
    value: None,
};

static WORD_STAT_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_STATA_NODE),
    None,
    None,
    None,
    Some(&WORD_STATE_NODE),
    None,
    None,
    None,
    Some(&WORD_STATI_NODE),
    None,
    None,
    None,
    Some(&WORD_STATM_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_STATR_NODE),
    Some(&WORD_STATS_NODE),
    Some(&WORD_STATT_NODE),
    Some(&WORD_STATU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_STATU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_STATU_CHILDREN),
    value: Some(&["status"]),
};

pub static WORD_STATU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("bar"),
        dictgen::InsensitiveStr::Ascii("er"),
        dictgen::InsensitiveStr::Ascii("ets"),
        dictgen::InsensitiveStr::Ascii("line"),
        dictgen::InsensitiveStr::Ascii("lines"),
        dictgen::InsensitiveStr::Ascii("p"),
        dictgen::InsensitiveStr::Ascii("rday"),
        dictgen::InsensitiveStr::Ascii("se"),
        dictgen::InsensitiveStr::Ascii("ser"),
        dictgen::InsensitiveStr::Ascii("ss"),
        dictgen::InsensitiveStr::Ascii("sses"),
        dictgen::InsensitiveStr::Ascii("stics"),
        dictgen::InsensitiveStr::Ascii("ts"),
    ],
    values: &[
        &["statusbar"],
        &["stature"],
        &["statutes"],
        &["statusline"],
        &["statuslines"],
        &["startup"],
        &["saturday"],
        &["statutes"],
        &["stature"],
        &["status"],
        &["statuses"],
        &["statistics"],
        &["statutes"],
    ],
    range: 1..=5,
};

static WORD_STATT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_STATT_CHILDREN),
    value: None,
};

pub static WORD_STATT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("istic"),
        dictgen::InsensitiveStr::Ascii("ues"),
    ],
    values: &[&["statistic"], &["statutes"]],
    range: 3..=5,
};

static WORD_STATS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_STATS_CHILDREN),
    value: None,
};

pub static WORD_STATS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("it"),
        dictgen::InsensitiveStr::Ascii("itical"),
    ],
    values: &[&["statist"], &["statistical"]],
    range: 2..=6,
};

static WORD_STATR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_STATR_CHILDREN),
    value: None,
};

pub static WORD_STATR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("t")],
    values: &[&["start"]],
    range: 1..=1,
};

static WORD_STATM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_STATM_CHILDREN),
    value: None,
};

pub static WORD_STATM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("enet"),
        dictgen::InsensitiveStr::Ascii("enmt"),
        dictgen::InsensitiveStr::Ascii("ent"),
        dictgen::InsensitiveStr::Ascii("ents"),
    ],
    values: &[
        &["statement"],
        &["statement"],
        &["statement"],
        &["statements"],
    ],
    range: 3..=4,
};

static WORD_STATI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_STATI_CHILDREN),
    value: Some(&["statuses", "state"]),
};

pub static WORD_STATI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cly"),
        dictgen::InsensitiveStr::Ascii("ctic"),
        dictgen::InsensitiveStr::Ascii("ctics"),
        dictgen::InsensitiveStr::Ascii("cts"),
        dictgen::InsensitiveStr::Ascii("onair"),
        dictgen::InsensitiveStr::Ascii("onairy"),
        dictgen::InsensitiveStr::Ascii("ond"),
        dictgen::InsensitiveStr::Ascii("onerad"),
        dictgen::InsensitiveStr::Ascii("onnary"),
        dictgen::InsensitiveStr::Ascii("ony"),
        dictgen::InsensitiveStr::Ascii("sfied"),
        dictgen::InsensitiveStr::Ascii("sfies"),
        dictgen::InsensitiveStr::Ascii("sfy"),
        dictgen::InsensitiveStr::Ascii("sfying"),
        dictgen::InsensitiveStr::Ascii("sitc"),
        dictgen::InsensitiveStr::Ascii("sitcal"),
        dictgen::InsensitiveStr::Ascii("sitcally"),
        dictgen::InsensitiveStr::Ascii("sitcs"),
        dictgen::InsensitiveStr::Ascii("sitics"),
        dictgen::InsensitiveStr::Ascii("skt"),
        dictgen::InsensitiveStr::Ascii("stacally"),
        dictgen::InsensitiveStr::Ascii("stc"),
        dictgen::InsensitiveStr::Ascii("stcal"),
        dictgen::InsensitiveStr::Ascii("stct"),
        dictgen::InsensitiveStr::Ascii("sticaly"),
        dictgen::InsensitiveStr::Ascii("stices"),
        dictgen::InsensitiveStr::Ascii("sticly"),
        dictgen::InsensitiveStr::Ascii("stisch"),
        dictgen::InsensitiveStr::Ascii("stisk"),
        dictgen::InsensitiveStr::Ascii("tic"),
        dictgen::InsensitiveStr::Ascii("tics"),
        dictgen::InsensitiveStr::Ascii("ts"),
    ],
    values: &[
        &["statically"],
        &["statistic"],
        &["statistics"],
        &["statist"],
        &["stationary"],
        &["stationary"],
        &["stationed"],
        &["stationed"],
        &["stationary"],
        &["stationary"],
        &["satisfied"],
        &["satisfies"],
        &["satisfy"],
        &["satisfying"],
        &["statistic"],
        &["statistical"],
        &["statistically"],
        &["statistics"],
        &["statistics"],
        &["statist"],
        &["statistically"],
        &["statistic"],
        &["statistical"],
        &["statistic", "statistics"],
        &["statistically"],
        &["statistics"],
        &["statistical"],
        &["statistics"],
        &["statistics"],
        &["statistic"],
        &["statistics"],
        &["statist"],
    ],
    range: 2..=8,
};

static WORD_STATE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_STATE_CHILDREN),
    value: None,
};

pub static WORD_STATE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("gies"),
        dictgen::InsensitiveStr::Ascii("gise"),
        dictgen::InsensitiveStr::Ascii("gised"),
        dictgen::InsensitiveStr::Ascii("gize"),
        dictgen::InsensitiveStr::Ascii("gized"),
        dictgen::InsensitiveStr::Ascii("gy"),
        dictgen::InsensitiveStr::Ascii("man"),
        dictgen::InsensitiveStr::Ascii("manet"),
        dictgen::InsensitiveStr::Ascii("memts"),
        dictgen::InsensitiveStr::Ascii("men"),
        dictgen::InsensitiveStr::Ascii("menet"),
        dictgen::InsensitiveStr::Ascii("menets"),
        dictgen::InsensitiveStr::Ascii("mens"),
        dictgen::InsensitiveStr::Ascii("met"),
        dictgen::InsensitiveStr::Ascii("mets"),
        dictgen::InsensitiveStr::Ascii("mnet"),
        dictgen::InsensitiveStr::Ascii("mnts"),
    ],
    values: &[
        &["strategies"],
        &["strategise"],
        &["strategised"],
        &["strategize"],
        &["strategized"],
        &["strategy"],
        &["statesman"],
        &["statement"],
        &["statements"],
        &["statement"],
        &["statement"],
        &["statements"],
        &["statements"],
        &["statement"],
        &["statements"],
        &["statement"],
        &["statements"],
    ],
    range: 2..=6,
};

static WORD_STATA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_STATA_CHILDREN),
    value: None,
};

pub static WORD_STATA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("menet"),
        dictgen::InsensitiveStr::Ascii("menets"),
    ],
    values: &[&["statement"], &["statements"]],
    range: 5..=6,
};

static WORD_STAR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_STAR_CHILDREN),
    value: None,
};

pub static WORD_STAR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ation"),
        dictgen::InsensitiveStr::Ascii("d"),
        dictgen::InsensitiveStr::Ascii("dard"),
        dictgen::InsensitiveStr::Ascii("dardize"),
        dictgen::InsensitiveStr::Ascii("dardized"),
        dictgen::InsensitiveStr::Ascii("dardizes"),
        dictgen::InsensitiveStr::Ascii("dardizing"),
        dictgen::InsensitiveStr::Ascii("dards"),
        dictgen::InsensitiveStr::Ascii("ight"),
        dictgen::InsensitiveStr::Ascii("ighten"),
        dictgen::InsensitiveStr::Ascii("ightened"),
        dictgen::InsensitiveStr::Ascii("ightforward"),
        dictgen::InsensitiveStr::Ascii("igth"),
        dictgen::InsensitiveStr::Ascii("ined"),
        dictgen::InsensitiveStr::Ascii("ins"),
        dictgen::InsensitiveStr::Ascii("lted"),
        dictgen::InsensitiveStr::Ascii("nation"),
        dictgen::InsensitiveStr::Ascii("td"),
        dictgen::InsensitiveStr::Ascii("tde"),
        dictgen::InsensitiveStr::Ascii("tegic"),
        dictgen::InsensitiveStr::Ascii("tegically"),
        dictgen::InsensitiveStr::Ascii("tegies"),
        dictgen::InsensitiveStr::Ascii("tegy"),
        dictgen::InsensitiveStr::Ascii("teld"),
        dictgen::InsensitiveStr::Ascii("tet"),
        dictgen::InsensitiveStr::Ascii("tign"),
        dictgen::InsensitiveStr::Ascii("tin"),
        dictgen::InsensitiveStr::Ascii("tlisteneing"),
        dictgen::InsensitiveStr::Ascii("tlxde"),
        dictgen::InsensitiveStr::Ascii("tnig"),
        dictgen::InsensitiveStr::Ascii("tparanthesis"),
        dictgen::InsensitiveStr::Ascii("tsup"),
        dictgen::InsensitiveStr::Ascii("tted"),
        dictgen::InsensitiveStr::Ascii("tting"),
        dictgen::InsensitiveStr::Ascii("tupbus"),
        dictgen::InsensitiveStr::Ascii("tus"),
        dictgen::InsensitiveStr::Ascii("up"),
        dictgen::InsensitiveStr::Ascii("ups"),
        dictgen::InsensitiveStr::Ascii("wberries"),
        dictgen::InsensitiveStr::Ascii("wberry"),
    ],
    values: &[
        &["starvation"],
        &["start"],
        &["standard"],
        &["standardize"],
        &["standardized"],
        &["standardizes"],
        &["standardizing"],
        &["standards"],
        &["straight"],
        &["straighten"],
        &["straightened"],
        &["straightforward"],
        &["straight"],
        &["strained"],
        &["strains"],
        &["startled"],
        &["starvation"],
        &["started"],
        &["startled"],
        &["strategic"],
        &["strategically"],
        &["strategies"],
        &["strategy"],
        &["startled"],
        &["started"],
        &["starting"],
        &["starting"],
        &["startlistening"],
        &["startled"],
        &["starting"],
        &["startparentheses"],
        &["startups"],
        &["started"],
        &["starting"],
        &["startups"],
        &["startups"],
        &["startup"],
        &["startups"],
        &["strawberries"],
        &["strawberry"],
    ],
    range: 1..=12,
};

static WORD_STAP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_STAP_CHILDREN),
    value: Some(&["step", "stop"]),
};

pub static WORD_STAP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("s")],
    values: &[&["steps", "stops"]],
    range: 1..=1,
};

static WORD_STAO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_STAO_CHILDREN),
    value: None,
};

pub static WORD_STAO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("shi")],
    values: &[&["satoshi"]],
    range: 3..=3,
};

static WORD_STAN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_STAN_CHILDREN),
    value: None,
};

pub static WORD_STAN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("alone"),
        dictgen::InsensitiveStr::Ascii("ard"),
        dictgen::InsensitiveStr::Ascii("ards"),
        dictgen::InsensitiveStr::Ascii("cels"),
        dictgen::InsensitiveStr::Ascii("cers"),
        dictgen::InsensitiveStr::Ascii("dalown"),
        dictgen::InsensitiveStr::Ascii("dar"),
        dictgen::InsensitiveStr::Ascii("darad"),
        dictgen::InsensitiveStr::Ascii("dardss"),
        dictgen::InsensitiveStr::Ascii("darisation"),
        dictgen::InsensitiveStr::Ascii("darise"),
        dictgen::InsensitiveStr::Ascii("darised"),
        dictgen::InsensitiveStr::Ascii("darises"),
        dictgen::InsensitiveStr::Ascii("darising"),
        dictgen::InsensitiveStr::Ascii("darization"),
        dictgen::InsensitiveStr::Ascii("darize"),
        dictgen::InsensitiveStr::Ascii("darized"),
        dictgen::InsensitiveStr::Ascii("darizes"),
        dictgen::InsensitiveStr::Ascii("darizing"),
        dictgen::InsensitiveStr::Ascii("dars"),
        dictgen::InsensitiveStr::Ascii("dart"),
        dictgen::InsensitiveStr::Ascii("dartd"),
        dictgen::InsensitiveStr::Ascii("dartds"),
        dictgen::InsensitiveStr::Ascii("dartisation"),
        dictgen::InsensitiveStr::Ascii("dartisator"),
        dictgen::InsensitiveStr::Ascii("dartised"),
        dictgen::InsensitiveStr::Ascii("dartization"),
        dictgen::InsensitiveStr::Ascii("dartizator"),
        dictgen::InsensitiveStr::Ascii("dartized"),
        dictgen::InsensitiveStr::Ascii("darts"),
        dictgen::InsensitiveStr::Ascii("datd"),
        dictgen::InsensitiveStr::Ascii("dbay"),
        dictgen::InsensitiveStr::Ascii("dbuy"),
        dictgen::InsensitiveStr::Ascii("derd"),
        dictgen::InsensitiveStr::Ascii("derdized"),
        dictgen::InsensitiveStr::Ascii("derds"),
        dictgen::InsensitiveStr::Ascii("dlone"),
        dictgen::InsensitiveStr::Ascii("drat"),
        dictgen::InsensitiveStr::Ascii("drats"),
        dictgen::InsensitiveStr::Ascii("dtard"),
        dictgen::InsensitiveStr::Ascii("dy"),
        dictgen::InsensitiveStr::Ascii("gant"),
        dictgen::InsensitiveStr::Ascii("ge"),
        dictgen::InsensitiveStr::Ascii("p"),
    ],
    values: &[
        &["standalone"],
        &["standard"],
        &["standards"],
        &["stances"],
        &["stances"],
        &["standalone"],
        &["standard"],
        &["standard"],
        &["standards"],
        &["standardisation"],
        &["standardise"],
        &["standardised"],
        &["standardises"],
        &["standardising"],
        &["standardization"],
        &["standardize"],
        &["standardized"],
        &["standardizes"],
        &["standardizing"],
        &["standards", "standard"],
        &["standard"],
        &["standard"],
        &["standards"],
        &["standardisation"],
        &["standardiser"],
        &["standardised"],
        &["standardization"],
        &["standardizer"],
        &["standardized"],
        &["standards"],
        &["standard"],
        &["standby"],
        &["standby"],
        &["standard"],
        &["standardized"],
        &["standards"],
        &["standalone"],
        &["standard"],
        &["standards"],
        &["standard"],
        &["standby", "sandy", "standee"],
        &["stagnant"],
        &["strange"],
        &["stamp"],
    ],
    range: 1..=11,
};

static WORD_STAM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_STAM_CHILDREN),
    value: None,
};

pub static WORD_STAM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("entent"),
        dictgen::InsensitiveStr::Ascii("inia"),
        dictgen::InsensitiveStr::Ascii("nia"),
        dictgen::InsensitiveStr::Ascii("pade"),
        dictgen::InsensitiveStr::Ascii("peed"),
    ],
    values: &[
        &["statement"],
        &["stamina"],
        &["stamina"],
        &["stamped"],
        &["stamped"],
    ],
    range: 3..=6,
};

static WORD_STAL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_STAL_CHILDREN),
    value: None,
};

pub static WORD_STAL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("agtite"),
        dictgen::InsensitiveStr::Ascii("ekrs"),
        dictgen::InsensitiveStr::Ascii("kear"),
        dictgen::InsensitiveStr::Ascii("kes"),
    ],
    values: &[&["stalactite"], &["stalkers"], &["stalker"], &["stalkers"]],
    range: 3..=6,
};

static WORD_STAK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_STAK_CHILDREN),
    value: None,
};

pub static WORD_STAK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eboard"),
        dictgen::InsensitiveStr::Ascii("eboarding"),
        dictgen::InsensitiveStr::Ascii("ler"),
        dictgen::InsensitiveStr::Ascii("lers"),
    ],
    values: &[
        &["skateboard"],
        &["skateboarding"],
        &["stalker"],
        &["stalkers"],
    ],
    range: 3..=9,
};

static WORD_STAI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_STAI_CHILDREN),
    value: None,
};

pub static WORD_STAI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cally"),
        dictgen::InsensitiveStr::Ascii("dum"),
        dictgen::InsensitiveStr::Ascii("dums"),
        dictgen::InsensitiveStr::Ascii("nlees"),
        dictgen::InsensitiveStr::Ascii("on"),
        dictgen::InsensitiveStr::Ascii("onairy"),
        dictgen::InsensitiveStr::Ascii("onary"),
        dictgen::InsensitiveStr::Ascii("ons"),
        dictgen::InsensitiveStr::Ascii("tion"),
        dictgen::InsensitiveStr::Ascii("tions"),
    ],
    values: &[
        &["statically"],
        &["stadium"],
        &["stadiums"],
        &["stainless"],
        &["station"],
        &["stationary"],
        &["stationary"],
        &["stations"],
        &["station"],
        &["stations"],
    ],
    range: 2..=6,
};

static WORD_STAG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_STAG_CHILDREN),
    value: None,
};

pub static WORD_STAG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("garing"),
        dictgen::InsensitiveStr::Ascii("gerring"),
        dictgen::InsensitiveStr::Ascii("gerwing"),
        dictgen::InsensitiveStr::Ascii("nat"),
    ],
    values: &[
        &["staggering"],
        &["staggering"],
        &["staggering"],
        &["stagnant"],
    ],
    range: 3..=7,
};

static WORD_STAE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_STAE_CHILDREN),
    value: Some(&["state"]),
};

pub static WORD_STAE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ment")],
    values: &[&["statement"]],
    range: 4..=4,
};

static WORD_STAD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_STAD_CHILDREN),
    value: None,
};

pub static WORD_STAD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ard"),
        dictgen::InsensitiveStr::Ascii("ius"),
        dictgen::InsensitiveStr::Ascii("nard"),
        dictgen::InsensitiveStr::Ascii("nardisation"),
        dictgen::InsensitiveStr::Ascii("nardised"),
        dictgen::InsensitiveStr::Ascii("nardising"),
        dictgen::InsensitiveStr::Ascii("nardization"),
        dictgen::InsensitiveStr::Ascii("nardized"),
        dictgen::InsensitiveStr::Ascii("nardizing"),
        dictgen::InsensitiveStr::Ascii("nards"),
        dictgen::InsensitiveStr::Ascii("s"),
        dictgen::InsensitiveStr::Ascii("uim"),
        dictgen::InsensitiveStr::Ascii("uims"),
    ],
    values: &[
        &["standard"],
        &["stadiums"],
        &["standard"],
        &["standardisation"],
        &["standardised"],
        &["standardising"],
        &["standardization"],
        &["standardized"],
        &["standardizing"],
        &["standards"],
        &["stats", "stands"],
        &["stadium"],
        &["stadiums"],
    ],
    range: 1..=11,
};

static WORD_STAC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_STAC_CHILDREN),
    value: None,
};

pub static WORD_STAC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("h"),
        dictgen::InsensitiveStr::Ascii("ionary"),
        dictgen::InsensitiveStr::Ascii("kk"),
    ],
    values: &[&["stack"], &["stationary"], &["stack"]],
    range: 1..=6,
};

static WORD_STAB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_STAB_CHILDREN),
    value: None,
};

pub static WORD_STAB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("alization"),
        dictgen::InsensitiveStr::Ascii("alized"),
        dictgen::InsensitiveStr::Ascii("el"),
        dictgen::InsensitiveStr::Ascii("elized"),
        dictgen::InsensitiveStr::Ascii("ilitation"),
        dictgen::InsensitiveStr::Ascii("ilite"),
        dictgen::InsensitiveStr::Ascii("ilited"),
        dictgen::InsensitiveStr::Ascii("ilites"),
        dictgen::InsensitiveStr::Ascii("iliting"),
        dictgen::InsensitiveStr::Ascii("ilizare"),
        dictgen::InsensitiveStr::Ascii("ilizied"),
        dictgen::InsensitiveStr::Ascii("ilizier"),
        dictgen::InsensitiveStr::Ascii("ilizies"),
        dictgen::InsensitiveStr::Ascii("illity"),
        dictgen::InsensitiveStr::Ascii("ilty"),
        dictgen::InsensitiveStr::Ascii("ilzied"),
        dictgen::InsensitiveStr::Ascii("liize"),
        dictgen::InsensitiveStr::Ascii("lility"),
        dictgen::InsensitiveStr::Ascii("lilization"),
        dictgen::InsensitiveStr::Ascii("lize"),
        dictgen::InsensitiveStr::Ascii("lizied"),
    ],
    values: &[
        &["stabilization"],
        &["stabilized"],
        &["stable"],
        &["stabilized"],
        &["stabilization"],
        &["stabilize"],
        &["stabilized"],
        &["stabilizes"],
        &["stabilizing"],
        &["stabilize"],
        &["stabilize"],
        &["stabilize"],
        &["stabilize"],
        &["stability"],
        &["stability"],
        &["stabilized"],
        &["stabilize"],
        &["stability"],
        &["stabilization"],
        &["stabilize"],
        &["stabilized"],
    ],
    range: 2..=10,
};

static WORD_SS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SS_CHILDREN),
    value: None,
};

pub static WORD_SS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ame"),
        dictgen::InsensitiveStr::Ascii("ee"),
        dictgen::InsensitiveStr::Ascii("oaiating"),
        dictgen::InsensitiveStr::Ascii("ome"),
        dictgen::InsensitiveStr::Ascii("udo"),
    ],
    values: &[&["same"], &["see"], &["associating"], &["some"], &["sudo"]],
    range: 2..=8,
};

static WORD_SR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SR_CHILDREN),
    value: None,
};

pub static WORD_SR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cipt"),
        dictgen::InsensitiveStr::Ascii("cipts"),
        dictgen::InsensitiveStr::Ascii("eampropinfo"),
        dictgen::InsensitiveStr::Ascii("eenshot"),
        dictgen::InsensitiveStr::Ascii("eenshots"),
        dictgen::InsensitiveStr::Ascii("eturns"),
        dictgen::InsensitiveStr::Ascii("ew"),
        dictgen::InsensitiveStr::Ascii("iarcha"),
        dictgen::InsensitiveStr::Ascii("ikeout"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("ings"),
        dictgen::InsensitiveStr::Ascii("ink"),
        dictgen::InsensitiveStr::Ascii("inkd"),
        dictgen::InsensitiveStr::Ascii("inked"),
        dictgen::InsensitiveStr::Ascii("inking"),
        dictgen::InsensitiveStr::Ascii("ipt"),
        dictgen::InsensitiveStr::Ascii("ipts"),
        dictgen::InsensitiveStr::Ascii("iraca"),
        dictgen::InsensitiveStr::Ascii("irachia"),
        dictgen::InsensitiveStr::Ascii("irachra"),
        dictgen::InsensitiveStr::Ascii("ollbar"),
        dictgen::InsensitiveStr::Ascii("ouce"),
        dictgen::InsensitiveStr::Ascii("pouts"),
        dictgen::InsensitiveStr::Ascii("riacha"),
        dictgen::InsensitiveStr::Ascii("tifact"),
        dictgen::InsensitiveStr::Ascii("tifacts"),
        dictgen::InsensitiveStr::Ascii("ting"),
        dictgen::InsensitiveStr::Ascii("tings"),
        dictgen::InsensitiveStr::Ascii("tructure"),
        dictgen::InsensitiveStr::Ascii("ttings"),
        dictgen::InsensitiveStr::Ascii("ucture"),
        dictgen::InsensitiveStr::Ascii("uctures"),
        dictgen::InsensitiveStr::Ascii("unk"),
        dictgen::InsensitiveStr::Ascii("unken"),
        dictgen::InsensitiveStr::Ascii("unkn"),
        dictgen::InsensitiveStr::Ascii("yacuse"),
        dictgen::InsensitiveStr::Ascii("yians"),
        dictgen::InsensitiveStr::Ascii("yinge"),
    ],
    values: &[
        &["script"],
        &["scripts"],
        &["streampropinfo"],
        &["screenshot"],
        &["screenshots"],
        &["returns"],
        &["screw", "shrew", "sew"],
        &["sriracha"],
        &["strikeout"],
        &["string"],
        &["strings"],
        &["shrink"],
        &["shrunk"],
        &["shrunk"],
        &["shrinking"],
        &["script"],
        &["scripts"],
        &["sriracha"],
        &["sriracha"],
        &["sriracha"],
        &["scrollbar"],
        &["source"],
        &["sprouts"],
        &["sriracha"],
        &["artifact"],
        &["artifacts"],
        &["string", "sorting"],
        &["strings"],
        &["structure"],
        &["settings"],
        &["structure"],
        &["structures"],
        &["shrunk"],
        &["shrunken"],
        &["shrunken"],
        &["syracuse"],
        &["syrians"],
        &["syringe"],
    ],
    range: 2..=11,
};

static WORD_SQ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SQ_CHILDREN),
    value: None,
};

pub static WORD_SQ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("are"),
        dictgen::InsensitiveStr::Ascii("ared"),
        dictgen::InsensitiveStr::Ascii("ares"),
        dictgen::InsensitiveStr::Ascii("ash"),
        dictgen::InsensitiveStr::Ascii("ashed"),
        dictgen::InsensitiveStr::Ascii("ashing"),
        dictgen::InsensitiveStr::Ascii("audron"),
        dictgen::InsensitiveStr::Ascii("aure"),
        dictgen::InsensitiveStr::Ascii("aured"),
        dictgen::InsensitiveStr::Ascii("aurely"),
        dictgen::InsensitiveStr::Ascii("aures"),
        dictgen::InsensitiveStr::Ascii("euaky"),
        dictgen::InsensitiveStr::Ascii("euence"),
        dictgen::InsensitiveStr::Ascii("iurtle"),
        dictgen::InsensitiveStr::Ascii("iushy"),
        dictgen::InsensitiveStr::Ascii("uadroon"),
        dictgen::InsensitiveStr::Ascii("uardon"),
        dictgen::InsensitiveStr::Ascii("uareds"),
        dictgen::InsensitiveStr::Ascii("uarey"),
        dictgen::InsensitiveStr::Ascii("uarley"),
        dictgen::InsensitiveStr::Ascii("uashgin"),
        dictgen::InsensitiveStr::Ascii("ueakey"),
        dictgen::InsensitiveStr::Ascii("ueakly"),
        dictgen::InsensitiveStr::Ascii("uence"),
        dictgen::InsensitiveStr::Ascii("uirel"),
        dictgen::InsensitiveStr::Ascii("uirl"),
        dictgen::InsensitiveStr::Ascii("uirle"),
        dictgen::InsensitiveStr::Ascii("uirlte"),
        dictgen::InsensitiveStr::Ascii("uirrelies"),
        dictgen::InsensitiveStr::Ascii("uirrelius"),
        dictgen::InsensitiveStr::Ascii("uirrells"),
        dictgen::InsensitiveStr::Ascii("uirrelus"),
        dictgen::InsensitiveStr::Ascii("uirrl"),
        dictgen::InsensitiveStr::Ascii("uirrle"),
        dictgen::InsensitiveStr::Ascii("uirrles"),
        dictgen::InsensitiveStr::Ascii("uirrtle"),
        dictgen::InsensitiveStr::Ascii("uirte"),
        dictgen::InsensitiveStr::Ascii("uirtel"),
        dictgen::InsensitiveStr::Ascii("uishey"),
        dictgen::InsensitiveStr::Ascii("uishly"),
        dictgen::InsensitiveStr::Ascii("urared"),
        dictgen::InsensitiveStr::Ascii("ure"),
        dictgen::InsensitiveStr::Ascii("uritle"),
        dictgen::InsensitiveStr::Ascii("urriel"),
        dictgen::InsensitiveStr::Ascii("urriels"),
        dictgen::InsensitiveStr::Ascii("urtile"),
        dictgen::InsensitiveStr::Ascii("ushed"),
        dictgen::InsensitiveStr::Ascii("usihy"),
    ],
    values: &[
        &["square"],
        &["squared"],
        &["squares"],
        &["squash"],
        &["squashed"],
        &["squashing"],
        &["squadron"],
        &["square"],
        &["squared"],
        &["squarely"],
        &["squares"],
        &["squeaky"],
        &["sequence"],
        &["squirtle"],
        &["squishy"],
        &["squadron"],
        &["squadron"],
        &["squares"],
        &["squarely"],
        &["squarely"],
        &["squashing"],
        &["squeaky"],
        &["squeaky"],
        &["sequence"],
        &["squirtle", "squirrel"],
        &["squirrel"],
        &["squirrel"],
        &["squirtle"],
        &["squirrels"],
        &["squirrels"],
        &["squirrels"],
        &["squirrels"],
        &["squirrel"],
        &["squirrel"],
        &["squirrels"],
        &["squirrel"],
        &["squirtle"],
        &["squirtle"],
        &["squishy"],
        &["squishy"],
        &["squared"],
        &["square"],
        &["squirtle"],
        &["squirrel"],
        &["squirrels"],
        &["squirtle"],
        &["squashed"],
        &["squishy"],
    ],
    range: 3..=9,
};

static WORD_SP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_SP_CHILDREN),
    value: None,
};

static WORD_SP_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_SPA_NODE),
    None,
    Some(&WORD_SPC_NODE),
    None,
    Some(&WORD_SPE_NODE),
    None,
    None,
    Some(&WORD_SPH_NODE),
    Some(&WORD_SPI_NODE),
    None,
    None,
    Some(&WORD_SPL_NODE),
    None,
    None,
    Some(&WORD_SPO_NODE),
    Some(&WORD_SPP_NODE),
    None,
    Some(&WORD_SPR_NODE),
    Some(&WORD_SPS_NODE),
    Some(&WORD_SPT_NODE),
    Some(&WORD_SPU_NODE),
    None,
    Some(&WORD_SPW_NODE),
    None,
    None,
    None,
];

static WORD_SPW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SPW_CHILDREN),
    value: None,
};

pub static WORD_SPW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("an"),
        dictgen::InsensitiveStr::Ascii("aned"),
        dictgen::InsensitiveStr::Ascii("aning"),
        dictgen::InsensitiveStr::Ascii("ans"),
    ],
    values: &[&["spawn"], &["spawned"], &["spawning"], &["spawns"]],
    range: 2..=5,
};

static WORD_SPU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SPU_CHILDREN),
    value: None,
};

pub static WORD_SPU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("rios"),
        dictgen::InsensitiveStr::Ascii("rrious"),
    ],
    values: &[&["spurious"], &["spurious"]],
    range: 4..=6,
};

static WORD_SPT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SPT_CHILDREN),
    value: None,
};

pub static WORD_SPT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("intf")],
    values: &[&["sprintf"]],
    range: 4..=4,
};

static WORD_SPS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SPS_CHILDREN),
    value: None,
};

pub static WORD_SPS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ace"),
        dictgen::InsensitiveStr::Ascii("aced"),
        dictgen::InsensitiveStr::Ascii("aces"),
        dictgen::InsensitiveStr::Ascii("acing"),
    ],
    values: &[&["space"], &["spaced"], &["spaces"], &["spacing"]],
    range: 3..=5,
};

static WORD_SPR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SPR_CHILDREN),
    value: None,
};

pub static WORD_SPR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("akling"),
        dictgen::InsensitiveStr::Ascii("ayade"),
        dictgen::InsensitiveStr::Ascii("eaded"),
        dictgen::InsensitiveStr::Ascii("eadhseet"),
        dictgen::InsensitiveStr::Ascii("eadhseets"),
        dictgen::InsensitiveStr::Ascii("eadsheat"),
        dictgen::InsensitiveStr::Ascii("eadsheats"),
        dictgen::InsensitiveStr::Ascii("eadsheeds"),
        dictgen::InsensitiveStr::Ascii("eadsheeet"),
        dictgen::InsensitiveStr::Ascii("eadsheeters"),
        dictgen::InsensitiveStr::Ascii("eadsheeticus"),
        dictgen::InsensitiveStr::Ascii("eadshet"),
        dictgen::InsensitiveStr::Ascii("eadshets"),
        dictgen::InsensitiveStr::Ascii("easheet"),
        dictgen::InsensitiveStr::Ascii("easheets"),
        dictgen::InsensitiveStr::Ascii("ech"),
        dictgen::InsensitiveStr::Ascii("ecial"),
        dictgen::InsensitiveStr::Ascii("ecialized"),
        dictgen::InsensitiveStr::Ascii("ecially"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("edsheet"),
        dictgen::InsensitiveStr::Ascii("eedsheet"),
        dictgen::InsensitiveStr::Ascii("inf"),
        dictgen::InsensitiveStr::Ascii("ingfeild"),
        dictgen::InsensitiveStr::Ascii("ingfeld"),
        dictgen::InsensitiveStr::Ascii("ingfied"),
        dictgen::InsensitiveStr::Ascii("ingfiled"),
        dictgen::InsensitiveStr::Ascii("ingst"),
        dictgen::InsensitiveStr::Ascii("inke"),
        dictgen::InsensitiveStr::Ascii("inkel"),
        dictgen::InsensitiveStr::Ascii("inkeld"),
        dictgen::InsensitiveStr::Ascii("inklered"),
        dictgen::InsensitiveStr::Ascii("intas"),
        dictgen::InsensitiveStr::Ascii("ipt"),
        dictgen::InsensitiveStr::Ascii("ipted"),
        dictgen::InsensitiveStr::Ascii("ipting"),
        dictgen::InsensitiveStr::Ascii("ipts"),
        dictgen::InsensitiveStr::Ascii("irious"),
        dictgen::InsensitiveStr::Ascii("iritual"),
        dictgen::InsensitiveStr::Ascii("itual"),
        dictgen::InsensitiveStr::Ascii("oels"),
        dictgen::InsensitiveStr::Ascii("oon"),
        dictgen::InsensitiveStr::Ascii("otsmanship"),
        dictgen::InsensitiveStr::Ascii("outes"),
    ],
    values: &[
        &["sparkling"],
        &["sprayed"],
        &["spread"],
        &["spreadsheet"],
        &["spreadsheets"],
        &["spreadsheet"],
        &["spreadsheets"],
        &["spreadsheets"],
        &["spreadsheets"],
        &["spreadsheets"],
        &["spreadsheets"],
        &["spreadsheet"],
        &["spreadsheets"],
        &["spreadsheet"],
        &["spreadsheets"],
        &["speech"],
        &["special"],
        &["specialized"],
        &["specially"],
        &["spread"],
        &["spreadsheet"],
        &["spreadsheet"],
        &["sprintf"],
        &["springfield"],
        &["springfield"],
        &["springfield"],
        &["springfield"],
        &["sprints"],
        &["sprinkle"],
        &["sprinkle"],
        &["sprinkled"],
        &["sprinkled"],
        &["sprints"],
        &["script"],
        &["scripted"],
        &["scripting"],
        &["scripts"],
        &["spurious"],
        &["spiritual"],
        &["spiritual"],
        &["sproles"],
        &["spoon"],
        &["sportsmanship"],
        &["sprouts"],
    ],
    range: 2..=12,
};

static WORD_SPP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SPP_CHILDREN),
    value: None,
};

pub static WORD_SPP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eches"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("ort"),
        dictgen::InsensitiveStr::Ascii("orted"),
        dictgen::InsensitiveStr::Ascii("orting"),
        dictgen::InsensitiveStr::Ascii("orts"),
    ],
    values: &[
        &["speeches"],
        &["speed", "sped", "sipped", "sapped", "supped", "sopped"],
        &["support"],
        &["supported"],
        &["supporting"],
        &["supports"],
    ],
    range: 2..=6,
};

static WORD_SPO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SPO_CHILDREN),
    value: None,
};

pub static WORD_SPO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ace"),
        dictgen::InsensitiveStr::Ascii("aced"),
        dictgen::InsensitiveStr::Ascii("aces"),
        dictgen::InsensitiveStr::Ascii("acing"),
        dictgen::InsensitiveStr::Ascii("ilerd"),
        dictgen::InsensitiveStr::Ascii("iles"),
        dictgen::InsensitiveStr::Ascii("itfy"),
        dictgen::InsensitiveStr::Ascii("lied"),
        dictgen::InsensitiveStr::Ascii("liers"),
        dictgen::InsensitiveStr::Ascii("natenous"),
        dictgen::InsensitiveStr::Ascii("natenously"),
        dictgen::InsensitiveStr::Ascii("natneous"),
        dictgen::InsensitiveStr::Ascii("nosred"),
        dictgen::InsensitiveStr::Ascii("nser"),
        dictgen::InsensitiveStr::Ascii("nsered"),
        dictgen::InsensitiveStr::Ascii("nsers"),
        dictgen::InsensitiveStr::Ascii("nsership"),
        dictgen::InsensitiveStr::Ascii("nsord"),
        dictgen::InsensitiveStr::Ascii("nsorees"),
        dictgen::InsensitiveStr::Ascii("nsores"),
        dictgen::InsensitiveStr::Ascii("nsorhip"),
        dictgen::InsensitiveStr::Ascii("nsorhips"),
        dictgen::InsensitiveStr::Ascii("nsorhsip"),
        dictgen::InsensitiveStr::Ascii("nsorise"),
        dictgen::InsensitiveStr::Ascii("nsorshop"),
        dictgen::InsensitiveStr::Ascii("ntaenous"),
        dictgen::InsensitiveStr::Ascii("ntaenously"),
        dictgen::InsensitiveStr::Ascii("ntainous"),
        dictgen::InsensitiveStr::Ascii("ntainously"),
        dictgen::InsensitiveStr::Ascii("ntaneos"),
        dictgen::InsensitiveStr::Ascii("ntaneosly"),
        dictgen::InsensitiveStr::Ascii("ntaneoulsy"),
        dictgen::InsensitiveStr::Ascii("ntaneouly"),
        dictgen::InsensitiveStr::Ascii("ntanes"),
        dictgen::InsensitiveStr::Ascii("ntaneuos"),
        dictgen::InsensitiveStr::Ascii("ntaneuosly"),
        dictgen::InsensitiveStr::Ascii("ntaneus"),
        dictgen::InsensitiveStr::Ascii("ntanious"),
        dictgen::InsensitiveStr::Ascii("ntaniously"),
        dictgen::InsensitiveStr::Ascii("ntanous"),
        dictgen::InsensitiveStr::Ascii("ntanuously"),
        dictgen::InsensitiveStr::Ascii("nteanous"),
        dictgen::InsensitiveStr::Ascii("nteanously"),
        dictgen::InsensitiveStr::Ascii("nteneous"),
        dictgen::InsensitiveStr::Ascii("nteneously"),
        dictgen::InsensitiveStr::Ascii("nzored"),
        dictgen::InsensitiveStr::Ascii("onfulls"),
        dictgen::InsensitiveStr::Ascii("ranos"),
        dictgen::InsensitiveStr::Ascii("ratic"),
        dictgen::InsensitiveStr::Ascii("rious"),
        dictgen::InsensitiveStr::Ascii("rles"),
        dictgen::InsensitiveStr::Ascii("rstmanship"),
        dictgen::InsensitiveStr::Ascii("rtmansship"),
        dictgen::InsensitiveStr::Ascii("rtsmamship"),
        dictgen::InsensitiveStr::Ascii("rtsmansship"),
        dictgen::InsensitiveStr::Ascii("rtsmenship"),
        dictgen::InsensitiveStr::Ascii("ruts"),
        dictgen::InsensitiveStr::Ascii("tfiy"),
        dictgen::InsensitiveStr::Ascii("tifiy"),
        dictgen::InsensitiveStr::Ascii("tifty"),
    ],
    values: &[
        &["space"],
        &["spaced"],
        &["spaces"],
        &["spacing"],
        &["spoiled"],
        &["spoilers"],
        &["spotify"],
        &["spoiled"],
        &["spoilers"],
        &["spontaneous"],
        &["spontaneously"],
        &["spontaneous"],
        &["sponsored"],
        &["sponsor"],
        &["sponsored"],
        &["sponsors"],
        &["sponsorship"],
        &["sponsored"],
        &["sponsors"],
        &["sponsors"],
        &["sponsorship"],
        &["sponsorship"],
        &["sponsorship"],
        &["sponsors"],
        &["sponsorship"],
        &["spontaneous"],
        &["spontaneously"],
        &["spontaneous"],
        &["spontaneously"],
        &["spontaneous"],
        &["spontaneously"],
        &["spontaneously"],
        &["spontaneously"],
        &["spontaneous"],
        &["spontaneous"],
        &["spontaneously"],
        &["spontaneous"],
        &["spontaneous"],
        &["spontaneously"],
        &["spontaneous"],
        &["spontaneously"],
        &["spontaneous"],
        &["spontaneously"],
        &["spontaneous"],
        &["spontaneously"],
        &["sponsored"],
        &["spoonfuls"],
        &["sopranos"],
        &["sporadic"],
        &["spurious"],
        &["sproles"],
        &["sportsmanship"],
        &["sportsmanship"],
        &["sportsmanship"],
        &["sportsmanship"],
        &["sportsmanship"],
        &["sprouts"],
        &["spotify"],
        &["spotify"],
        &["spotify"],
    ],
    range: 3..=11,
};

static WORD_SPL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SPL_CHILDREN),
    value: None,
};

pub static WORD_SPL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aton"),
        dictgen::InsensitiveStr::Ascii("atooon"),
        dictgen::InsensitiveStr::Ascii("eling"),
        dictgen::InsensitiveStr::Ascii("ig"),
        dictgen::InsensitiveStr::Ascii("igs"),
        dictgen::InsensitiveStr::Ascii("iiter"),
        dictgen::InsensitiveStr::Ascii("iitting"),
        dictgen::InsensitiveStr::Ascii("ite"),
        dictgen::InsensitiveStr::Ascii("ited"),
        dictgen::InsensitiveStr::Ascii("iting"),
        dictgen::InsensitiveStr::Ascii("itner"),
        dictgen::InsensitiveStr::Ascii("itted"),
        dictgen::InsensitiveStr::Ascii("ittng"),
        dictgen::InsensitiveStr::Ascii("ittr"),
        dictgen::InsensitiveStr::Ascii("litting"),
    ],
    values: &[
        &["splatoon"],
        &["splatoon"],
        &["spelling"],
        &["split", "splign"],
        &["splits"],
        &["splitter"],
        &["splitting"],
        &["split", "splits", "splice"],
        &["split"],
        &["splitting"],
        &["splinter"],
        &["split"],
        &["splitting"],
        &["splitter"],
        &["splitting"],
    ],
    range: 2..=7,
};

static WORD_SPI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SPI_CHILDREN),
    value: None,
};

pub static WORD_SPI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cific"),
        dictgen::InsensitiveStr::Ascii("cified"),
        dictgen::InsensitiveStr::Ascii("cify"),
        dictgen::InsensitiveStr::Ascii("le"),
        dictgen::InsensitiveStr::Ascii("lnter"),
        dictgen::InsensitiveStr::Ascii("ltter"),
        dictgen::InsensitiveStr::Ascii("ltting"),
        dictgen::InsensitiveStr::Ascii("ndel"),
        dictgen::InsensitiveStr::Ascii("ndels"),
        dictgen::InsensitiveStr::Ascii("ndrel"),
        dictgen::InsensitiveStr::Ascii("nlcok"),
        dictgen::InsensitiveStr::Ascii("nock"),
        dictgen::InsensitiveStr::Ascii("ritd"),
        dictgen::InsensitiveStr::Ascii("rites"),
        dictgen::InsensitiveStr::Ascii("ritis"),
        dictgen::InsensitiveStr::Ascii("ritualiy"),
        dictgen::InsensitiveStr::Ascii("rituallity"),
        dictgen::InsensitiveStr::Ascii("rituallly"),
        dictgen::InsensitiveStr::Ascii("ritualty"),
        dictgen::InsensitiveStr::Ascii("ritualy"),
        dictgen::InsensitiveStr::Ascii("rituella"),
        dictgen::InsensitiveStr::Ascii("ritus"),
        dictgen::InsensitiveStr::Ascii("rtied"),
        dictgen::InsensitiveStr::Ascii("rtiuality"),
        dictgen::InsensitiveStr::Ascii("rtiually"),
        dictgen::InsensitiveStr::Ascii("rutuality"),
        dictgen::InsensitiveStr::Ascii("rutually"),
        dictgen::InsensitiveStr::Ascii("tirually"),
    ],
    values: &[
        &["specific"],
        &["specified"],
        &["specify"],
        &["spite", "spiral"],
        &["splinter"],
        &["splitter"],
        &["splitting"],
        &["spindle"],
        &["spindles"],
        &["spindle"],
        &["spinlock"],
        &["spinlock"],
        &["spirited"],
        &["spirits"],
        &["spirits"],
        &["spiritually"],
        &["spiritually"],
        &["spiritually"],
        &["spirituality"],
        &["spiritually"],
        &["spiritually"],
        &["spirits"],
        &["spirited"],
        &["spirituality"],
        &["spiritually"],
        &["spirituality"],
        &["spiritually"],
        &["spiritually"],
    ],
    range: 2..=10,
};

static WORD_SPH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SPH_CHILDREN),
    value: None,
};

pub static WORD_SPH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("agetti"),
        dictgen::InsensitiveStr::Ascii("ereos"),
    ],
    values: &[&["spaghetti"], &["spheres"]],
    range: 5..=6,
};

static WORD_SPE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_SPE_CHILDREN),
    value: None,
};

static WORD_SPE_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_SPEA_NODE),
    None,
    Some(&WORD_SPEC_NODE),
    Some(&WORD_SPED_NODE),
    Some(&WORD_SPEE_NODE),
    Some(&WORD_SPEF_NODE),
    None,
    Some(&WORD_SPEH_NODE),
    Some(&WORD_SPEI_NODE),
    None,
    None,
    Some(&WORD_SPEL_NODE),
    None,
    Some(&WORD_SPEN_NODE),
    None,
    Some(&WORD_SPEP_NODE),
    None,
    Some(&WORD_SPER_NODE),
    Some(&WORD_SPES_NODE),
    Some(&WORD_SPET_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_SPEZ_NODE),
];

static WORD_SPEZ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SPEZ_CHILDREN),
    value: None,
};

pub static WORD_SPEZ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ialisation"),
        dictgen::InsensitiveStr::Ascii("ific"),
        dictgen::InsensitiveStr::Ascii("ified"),
        dictgen::InsensitiveStr::Ascii("ify"),
    ],
    values: &[
        &["specialisation"],
        &["specific"],
        &["specified"],
        &["specify"],
    ],
    range: 3..=10,
};

static WORD_SPET_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SPET_CHILDREN),
    value: None,
};

pub static WORD_SPET_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ember"),
        dictgen::InsensitiveStr::Ascii("ial"),
        dictgen::InsensitiveStr::Ascii("sific"),
        dictgen::InsensitiveStr::Ascii("sified"),
    ],
    values: &[
        &["september"],
        &["spatial", "special"],
        &["specific"],
        &["specified"],
    ],
    range: 3..=6,
};

static WORD_SPES_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SPES_CHILDREN),
    value: None,
};

pub static WORD_SPES_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("hal"),
        dictgen::InsensitiveStr::Ascii("hally"),
        dictgen::InsensitiveStr::Ascii("hel"),
        dictgen::InsensitiveStr::Ascii("helly"),
        dictgen::InsensitiveStr::Ascii("ialisation"),
        dictgen::InsensitiveStr::Ascii("ific"),
        dictgen::InsensitiveStr::Ascii("ifical"),
        dictgen::InsensitiveStr::Ascii("ifically"),
        dictgen::InsensitiveStr::Ascii("ificaly"),
        dictgen::InsensitiveStr::Ascii("ification"),
        dictgen::InsensitiveStr::Ascii("ifications"),
        dictgen::InsensitiveStr::Ascii("ifics"),
        dictgen::InsensitiveStr::Ascii("ified"),
        dictgen::InsensitiveStr::Ascii("ifities"),
        dictgen::InsensitiveStr::Ascii("ify"),
    ],
    values: &[
        &["special"],
        &["specially", "especially"],
        &["special"],
        &["specially", "especially"],
        &["specialisation"],
        &["specific"],
        &["specific"],
        &["specifically"],
        &["specifically"],
        &["specification"],
        &["specifications"],
        &["specifics"],
        &["specified"],
        &["specifics"],
        &["specify"],
    ],
    range: 3..=10,
};

static WORD_SPER_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SPER_CHILDREN),
    value: None,
};

pub static WORD_SPER_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ate"),
        dictgen::InsensitiveStr::Ascii("ately"),
        dictgen::InsensitiveStr::Ascii("hical"),
        dictgen::InsensitiveStr::Ascii("matozoan"),
    ],
    values: &[
        &["separate"],
        &["separately"],
        &["spherical"],
        &["spermatozoon"],
    ],
    range: 3..=8,
};

static WORD_SPEP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SPEP_CHILDREN),
    value: None,
};

pub static WORD_SPEP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("arate"),
        dictgen::InsensitiveStr::Ascii("arated"),
        dictgen::InsensitiveStr::Ascii("arating"),
        dictgen::InsensitiveStr::Ascii("aration"),
        dictgen::InsensitiveStr::Ascii("arator"),
        dictgen::InsensitiveStr::Ascii("c"),
        dictgen::InsensitiveStr::Ascii("eratd"),
        dictgen::InsensitiveStr::Ascii("erate"),
        dictgen::InsensitiveStr::Ascii("erateing"),
        dictgen::InsensitiveStr::Ascii("erater"),
        dictgen::InsensitiveStr::Ascii("erates"),
        dictgen::InsensitiveStr::Ascii("erating"),
        dictgen::InsensitiveStr::Ascii("erator"),
        dictgen::InsensitiveStr::Ascii("erats"),
    ],
    values: &[
        &["separate"],
        &["separated"],
        &["separating"],
        &["separation"],
        &["separator"],
        &["spec"],
        &["separated"],
        &["separate"],
        &["separating"],
        &["separator"],
        &["separates"],
        &["separating"],
        &["separator"],
        &["separates"],
    ],
    range: 1..=8,
};

static WORD_SPEN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SPEN_CHILDREN),
    value: None,
};

pub static WORD_SPEN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("dour")],
    values: &[&["splendour"]],
    range: 4..=4,
};

static WORD_SPEL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SPEL_CHILDREN),
    value: None,
};

pub static WORD_SPEL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("lig"),
        dictgen::InsensitiveStr::Ascii("lign"),
        dictgen::InsensitiveStr::Ascii("lshecking"),
    ],
    values: &[
        &["spelling"],
        &["spelling"],
        &["spelling"],
        &["spellchecking"],
    ],
    range: 3..=9,
};

static WORD_SPEI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SPEI_CHILDREN),
    value: None,
};

pub static WORD_SPEI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cal"),
        dictgen::InsensitiveStr::Ascii("calist"),
        dictgen::InsensitiveStr::Ascii("cally"),
        dictgen::InsensitiveStr::Ascii("cals"),
        dictgen::InsensitiveStr::Ascii("ces"),
        dictgen::InsensitiveStr::Ascii("cfied"),
        dictgen::InsensitiveStr::Ascii("cific"),
        dictgen::InsensitiveStr::Ascii("cified"),
        dictgen::InsensitiveStr::Ascii("cify"),
    ],
    values: &[
        &["special"],
        &["specialist"],
        &["specially"],
        &["specials"],
        &["species"],
        &["specified"],
        &["specific"],
        &["specified"],
        &["specify"],
    ],
    range: 3..=6,
};

static WORD_SPEH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SPEH_CHILDREN),
    value: None,
};

pub static WORD_SPEH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("erical"),
        dictgen::InsensitiveStr::Ascii("res"),
        dictgen::InsensitiveStr::Ascii("rical"),
    ],
    values: &[&["spherical"], &["spheres"], &["spherical"]],
    range: 3..=6,
};

static WORD_SPEF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_SPEF_CHILDREN),
    value: None,
};

static WORD_SPEF_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_SPEFA_NODE),
    None,
    Some(&WORD_SPEFC_NODE),
    None,
    Some(&WORD_SPEFE_NODE),
    None,
    None,
    None,
    Some(&WORD_SPEFI_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_SPEFY_NODE),
    None,
];

static WORD_SPEFY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SPEFY_CHILDREN),
    value: Some(&["specify"]),
};

pub static WORD_SPEFY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ing")],
    values: &[&["specifying"]],
    range: 3..=3,
};

static WORD_SPEFI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_SPEFI_CHILDREN),
    value: None,
};

static WORD_SPEFI_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_SPEFIA_NODE),
    None,
    Some(&WORD_SPEFIC_NODE),
    None,
    Some(&WORD_SPEFIE_NODE),
    Some(&WORD_SPEFIF_NODE),
    None,
    None,
    Some(&WORD_SPEFII_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_SPEFIX_NODE),
    Some(&WORD_SPEFIY_NODE),
    None,
];

static WORD_SPEFIY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SPEFIY_CHILDREN),
    value: Some(&["specify"]),
};

pub static WORD_SPEFIY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ing")],
    values: &[&["specifying"]],
    range: 3..=3,
};

static WORD_SPEFIX_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SPEFIX_CHILDREN),
    value: None,
};

pub static WORD_SPEFIX_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ally"),
        dictgen::InsensitiveStr::Ascii("ation"),
        dictgen::InsensitiveStr::Ascii("ations"),
        dictgen::InsensitiveStr::Ascii("eid"),
        dictgen::InsensitiveStr::Ascii("eir"),
        dictgen::InsensitiveStr::Ascii("eirs"),
        dictgen::InsensitiveStr::Ascii("eis"),
        dictgen::InsensitiveStr::Ascii("iable"),
        dictgen::InsensitiveStr::Ascii("ic"),
        dictgen::InsensitiveStr::Ascii("ically"),
        dictgen::InsensitiveStr::Ascii("ication"),
        dictgen::InsensitiveStr::Ascii("ications"),
        dictgen::InsensitiveStr::Ascii("ics"),
        dictgen::InsensitiveStr::Ascii("ied"),
        dictgen::InsensitiveStr::Ascii("ier"),
        dictgen::InsensitiveStr::Ascii("iers"),
        dictgen::InsensitiveStr::Ascii("ies"),
        dictgen::InsensitiveStr::Ascii("ifed"),
        dictgen::InsensitiveStr::Ascii("ifer"),
        dictgen::InsensitiveStr::Ascii("ifers"),
        dictgen::InsensitiveStr::Ascii("ifes"),
        dictgen::InsensitiveStr::Ascii("y"),
        dictgen::InsensitiveStr::Ascii("ying"),
    ],
    values: &[
        &["specifically"],
        &["specification"],
        &["specifications"],
        &["specified"],
        &["specifier"],
        &["specifiers"],
        &["specifies"],
        &["specifiable"],
        &["specific"],
        &["specifically"],
        &["specification"],
        &["specifications"],
        &["specifics"],
        &["specified"],
        &["specifier"],
        &["specifiers"],
        &["specifies"],
        &["specified"],
        &["specifier"],
        &["specifiers"],
        &["specifies"],
        &["specify"],
        &["specifying"],
    ],
    range: 1..=8,
};

static WORD_SPEFII_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SPEFII_CHILDREN),
    value: None,
};

pub static WORD_SPEFII_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("able"),
        dictgen::InsensitiveStr::Ascii("c"),
        dictgen::InsensitiveStr::Ascii("cally"),
        dictgen::InsensitiveStr::Ascii("cation"),
        dictgen::InsensitiveStr::Ascii("cations"),
        dictgen::InsensitiveStr::Ascii("cs"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("er"),
        dictgen::InsensitiveStr::Ascii("ers"),
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("fally"),
        dictgen::InsensitiveStr::Ascii("fation"),
        dictgen::InsensitiveStr::Ascii("fations"),
        dictgen::InsensitiveStr::Ascii("feid"),
        dictgen::InsensitiveStr::Ascii("feir"),
        dictgen::InsensitiveStr::Ascii("feirs"),
        dictgen::InsensitiveStr::Ascii("feis"),
        dictgen::InsensitiveStr::Ascii("fiable"),
        dictgen::InsensitiveStr::Ascii("fic"),
        dictgen::InsensitiveStr::Ascii("fically"),
        dictgen::InsensitiveStr::Ascii("fication"),
        dictgen::InsensitiveStr::Ascii("fications"),
        dictgen::InsensitiveStr::Ascii("fics"),
        dictgen::InsensitiveStr::Ascii("fied"),
        dictgen::InsensitiveStr::Ascii("fier"),
        dictgen::InsensitiveStr::Ascii("fiers"),
        dictgen::InsensitiveStr::Ascii("fies"),
        dictgen::InsensitiveStr::Ascii("fifed"),
        dictgen::InsensitiveStr::Ascii("fifer"),
        dictgen::InsensitiveStr::Ascii("fifers"),
        dictgen::InsensitiveStr::Ascii("fifes"),
        dictgen::InsensitiveStr::Ascii("fy"),
        dictgen::InsensitiveStr::Ascii("fying"),
    ],
    values: &[
        &["specifiable"],
        &["specific"],
        &["specifically"],
        &["specification"],
        &["specifications"],
        &["specifics"],
        &["specified"],
        &["specifier"],
        &["specifiers"],
        &["specifies"],
        &["specifically"],
        &["specification"],
        &["specifications"],
        &["specified"],
        &["specifier"],
        &["specifiers"],
        &["specifies"],
        &["specifiable"],
        &["specific"],
        &["specifically"],
        &["specification"],
        &["specifications"],
        &["specifics"],
        &["specified"],
        &["specifier"],
        &["specifiers"],
        &["specifies"],
        &["specified"],
        &["specifier"],
        &["specifiers"],
        &["specifies"],
        &["specify"],
        &["specifying"],
    ],
    range: 1..=9,
};

static WORD_SPEFIF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SPEFIF_CHILDREN),
    value: None,
};

pub static WORD_SPEFIF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ally"),
        dictgen::InsensitiveStr::Ascii("ation"),
        dictgen::InsensitiveStr::Ascii("ations"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("eid"),
        dictgen::InsensitiveStr::Ascii("eir"),
        dictgen::InsensitiveStr::Ascii("eirs"),
        dictgen::InsensitiveStr::Ascii("eis"),
        dictgen::InsensitiveStr::Ascii("er"),
        dictgen::InsensitiveStr::Ascii("ers"),
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("iable"),
        dictgen::InsensitiveStr::Ascii("ic"),
        dictgen::InsensitiveStr::Ascii("ically"),
        dictgen::InsensitiveStr::Ascii("ication"),
        dictgen::InsensitiveStr::Ascii("ications"),
        dictgen::InsensitiveStr::Ascii("ics"),
        dictgen::InsensitiveStr::Ascii("ied"),
        dictgen::InsensitiveStr::Ascii("ier"),
        dictgen::InsensitiveStr::Ascii("iers"),
        dictgen::InsensitiveStr::Ascii("ies"),
        dictgen::InsensitiveStr::Ascii("ifed"),
        dictgen::InsensitiveStr::Ascii("ifer"),
        dictgen::InsensitiveStr::Ascii("ifers"),
        dictgen::InsensitiveStr::Ascii("ifes"),
        dictgen::InsensitiveStr::Ascii("y"),
        dictgen::InsensitiveStr::Ascii("ying"),
    ],
    values: &[
        &["specifically"],
        &["specification"],
        &["specifications"],
        &["specified"],
        &["specified"],
        &["specifier"],
        &["specifiers"],
        &["specifies"],
        &["specifier"],
        &["specifiers"],
        &["specifies"],
        &["specifiable"],
        &["specific"],
        &["specifically"],
        &["specification"],
        &["specifications"],
        &["specifics"],
        &["specified"],
        &["specifier"],
        &["specifiers"],
        &["specifies"],
        &["specified"],
        &["specifier"],
        &["specifiers"],
        &["specifies"],
        &["specify"],
        &["specifying"],
    ],
    range: 1..=8,
};

static WORD_SPEFIE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SPEFIE_CHILDREN),
    value: None,
};

pub static WORD_SPEFIE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("d"),
        dictgen::InsensitiveStr::Ascii("r"),
        dictgen::InsensitiveStr::Ascii("rs"),
        dictgen::InsensitiveStr::Ascii("s"),
    ],
    values: &[
        &["specified"],
        &["specifier"],
        &["specifiers"],
        &["specifies"],
    ],
    range: 1..=2,
};

static WORD_SPEFIC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_SPEFIC_CHILDREN),
    value: Some(&["specific"]),
};

static WORD_SPEFIC_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_SPEFICA_NODE),
    None,
    None,
    None,
    Some(&WORD_SPEFICE_NODE),
    None,
    None,
    None,
    Some(&WORD_SPEFICI_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_SPEFICS_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_SPEFICY_NODE),
    None,
];

static WORD_SPEFICY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SPEFICY_CHILDREN),
    value: Some(&["specify"]),
};

pub static WORD_SPEFICY_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[dictgen::InsensitiveStr::Ascii("ing")],
        values: &[&["specifying"]],
        range: 3..=3,
    };

static WORD_SPEFICS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SPEFICS_CHILDREN),
    value: Some(&["specifics"]),
};

pub static WORD_SPEFICS_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[],
        values: &[],
        range: 0..=0,
    };

static WORD_SPEFICI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_SPEFICI_CHILDREN),
    value: None,
};

static WORD_SPEFICI_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_SPEFICIA_NODE),
    None,
    Some(&WORD_SPEFICIC_NODE),
    None,
    Some(&WORD_SPEFICIE_NODE),
    Some(&WORD_SPEFICIF_NODE),
    None,
    None,
    Some(&WORD_SPEFICII_NODE),
    None,
    None,
    Some(&WORD_SPEFICIL_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_SPEFICIT_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_SPEFICIY_NODE),
    None,
];

static WORD_SPEFICIY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SPEFICIY_CHILDREN),
    value: Some(&["specify"]),
};

pub static WORD_SPEFICIY_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[dictgen::InsensitiveStr::Ascii("ing")],
        values: &[&["specifying"]],
        range: 3..=3,
    };

static WORD_SPEFICIT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SPEFICIT_CHILDREN),
    value: None,
};

pub static WORD_SPEFICIT_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("ally"),
            dictgen::InsensitiveStr::Ascii("ation"),
            dictgen::InsensitiveStr::Ascii("ations"),
            dictgen::InsensitiveStr::Ascii("eid"),
            dictgen::InsensitiveStr::Ascii("eir"),
            dictgen::InsensitiveStr::Ascii("eirs"),
            dictgen::InsensitiveStr::Ascii("eis"),
            dictgen::InsensitiveStr::Ascii("iable"),
            dictgen::InsensitiveStr::Ascii("ic"),
            dictgen::InsensitiveStr::Ascii("ically"),
            dictgen::InsensitiveStr::Ascii("ication"),
            dictgen::InsensitiveStr::Ascii("ications"),
            dictgen::InsensitiveStr::Ascii("ics"),
            dictgen::InsensitiveStr::Ascii("ied"),
            dictgen::InsensitiveStr::Ascii("ier"),
            dictgen::InsensitiveStr::Ascii("iers"),
            dictgen::InsensitiveStr::Ascii("ies"),
            dictgen::InsensitiveStr::Ascii("ifed"),
            dictgen::InsensitiveStr::Ascii("ifer"),
            dictgen::InsensitiveStr::Ascii("ifers"),
            dictgen::InsensitiveStr::Ascii("ifes"),
            dictgen::InsensitiveStr::Ascii("y"),
        ],
        values: &[
            &["specifically"],
            &["specification"],
            &["specifications"],
            &["specified"],
            &["specifier"],
            &["specifiers"],
            &["specifies"],
            &["specifiable"],
            &["specific"],
            &["specifically"],
            &["specification"],
            &["specifications"],
            &["specifics"],
            &["specified"],
            &["specifier"],
            &["specifiers"],
            &["specificities"],
            &["specified"],
            &["specifier"],
            &["specifiers"],
            &["specifies"],
            &["specificity"],
        ],
        range: 1..=8,
    };

static WORD_SPEFICIL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SPEFICIL_CHILDREN),
    value: None,
};

pub static WORD_SPEFICIL_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("lally"),
            dictgen::InsensitiveStr::Ascii("lation"),
            dictgen::InsensitiveStr::Ascii("lations"),
            dictgen::InsensitiveStr::Ascii("leid"),
            dictgen::InsensitiveStr::Ascii("leir"),
            dictgen::InsensitiveStr::Ascii("leirs"),
            dictgen::InsensitiveStr::Ascii("leis"),
            dictgen::InsensitiveStr::Ascii("liable"),
            dictgen::InsensitiveStr::Ascii("lic"),
            dictgen::InsensitiveStr::Ascii("lically"),
            dictgen::InsensitiveStr::Ascii("lication"),
            dictgen::InsensitiveStr::Ascii("lications"),
            dictgen::InsensitiveStr::Ascii("lics"),
            dictgen::InsensitiveStr::Ascii("lied"),
            dictgen::InsensitiveStr::Ascii("lier"),
            dictgen::InsensitiveStr::Ascii("liers"),
            dictgen::InsensitiveStr::Ascii("lies"),
            dictgen::InsensitiveStr::Ascii("lifed"),
            dictgen::InsensitiveStr::Ascii("lifer"),
            dictgen::InsensitiveStr::Ascii("lifers"),
            dictgen::InsensitiveStr::Ascii("lifes"),
            dictgen::InsensitiveStr::Ascii("ly"),
        ],
        values: &[
            &["specifically"],
            &["specification"],
            &["specifications"],
            &["specified"],
            &["specifier"],
            &["specifiers"],
            &["specifies"],
            &["specifiable"],
            &["specific"],
            &["specifically"],
            &["specification"],
            &["specifications"],
            &["specifics"],
            &["specified"],
            &["specifier"],
            &["specifiers"],
            &["specifies"],
            &["specified"],
            &["specifier"],
            &["specifiers"],
            &["specifies"],
            &["specifically"],
        ],
        range: 2..=9,
    };

static WORD_SPEFICII_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SPEFICII_CHILDREN),
    value: None,
};

pub static WORD_SPEFICII_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("able"),
            dictgen::InsensitiveStr::Ascii("c"),
            dictgen::InsensitiveStr::Ascii("cally"),
            dictgen::InsensitiveStr::Ascii("cation"),
            dictgen::InsensitiveStr::Ascii("cations"),
            dictgen::InsensitiveStr::Ascii("cs"),
            dictgen::InsensitiveStr::Ascii("ed"),
            dictgen::InsensitiveStr::Ascii("er"),
            dictgen::InsensitiveStr::Ascii("ers"),
            dictgen::InsensitiveStr::Ascii("es"),
            dictgen::InsensitiveStr::Ascii("fed"),
            dictgen::InsensitiveStr::Ascii("fer"),
            dictgen::InsensitiveStr::Ascii("fers"),
            dictgen::InsensitiveStr::Ascii("fes"),
        ],
        values: &[
            &["specifiable"],
            &["specific"],
            &["specifically"],
            &["specification"],
            &["specifications"],
            &["specifics"],
            &["specified"],
            &["specifier"],
            &["specifiers"],
            &["specifies"],
            &["specified"],
            &["specifier"],
            &["specifiers"],
            &["specifies"],
        ],
        range: 1..=7,
    };

static WORD_SPEFICIF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SPEFICIF_CHILDREN),
    value: None,
};

pub static WORD_SPEFICIF_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("ally"),
            dictgen::InsensitiveStr::Ascii("ation"),
            dictgen::InsensitiveStr::Ascii("ations"),
            dictgen::InsensitiveStr::Ascii("c"),
            dictgen::InsensitiveStr::Ascii("cally"),
            dictgen::InsensitiveStr::Ascii("cation"),
            dictgen::InsensitiveStr::Ascii("cations"),
            dictgen::InsensitiveStr::Ascii("cs"),
            dictgen::InsensitiveStr::Ascii("ed"),
            dictgen::InsensitiveStr::Ascii("eid"),
            dictgen::InsensitiveStr::Ascii("eir"),
            dictgen::InsensitiveStr::Ascii("eirs"),
            dictgen::InsensitiveStr::Ascii("eis"),
            dictgen::InsensitiveStr::Ascii("er"),
            dictgen::InsensitiveStr::Ascii("ers"),
            dictgen::InsensitiveStr::Ascii("es"),
            dictgen::InsensitiveStr::Ascii("iable"),
            dictgen::InsensitiveStr::Ascii("ic"),
            dictgen::InsensitiveStr::Ascii("ically"),
            dictgen::InsensitiveStr::Ascii("ication"),
            dictgen::InsensitiveStr::Ascii("ications"),
            dictgen::InsensitiveStr::Ascii("ics"),
            dictgen::InsensitiveStr::Ascii("ied"),
            dictgen::InsensitiveStr::Ascii("ier"),
            dictgen::InsensitiveStr::Ascii("iers"),
            dictgen::InsensitiveStr::Ascii("ies"),
            dictgen::InsensitiveStr::Ascii("ifed"),
            dictgen::InsensitiveStr::Ascii("ifer"),
            dictgen::InsensitiveStr::Ascii("ifers"),
            dictgen::InsensitiveStr::Ascii("ifes"),
            dictgen::InsensitiveStr::Ascii("y"),
            dictgen::InsensitiveStr::Ascii("ying"),
        ],
        values: &[
            &["specifically"],
            &["specification"],
            &["specifications"],
            &["specific"],
            &["specifically"],
            &["specification"],
            &["specifications"],
            &["specifics"],
            &["specified"],
            &["specified"],
            &["specifier"],
            &["specifiers"],
            &["specifies"],
            &["specifier"],
            &["specifiers"],
            &["specifies"],
            &["specifiable"],
            &["specific"],
            &["specifically"],
            &["specification"],
            &["specifications"],
            &["specifics"],
            &["specified"],
            &["specifier"],
            &["specifiers"],
            &["specifies"],
            &["specified"],
            &["specifier"],
            &["specifiers"],
            &["specifies"],
            &["specify"],
            &["specifying"],
        ],
        range: 1..=8,
    };

static WORD_SPEFICIE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SPEFICIE_CHILDREN),
    value: None,
};

pub static WORD_SPEFICIE_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("d"),
            dictgen::InsensitiveStr::Ascii("id"),
            dictgen::InsensitiveStr::Ascii("ir"),
            dictgen::InsensitiveStr::Ascii("irs"),
            dictgen::InsensitiveStr::Ascii("is"),
            dictgen::InsensitiveStr::Ascii("r"),
            dictgen::InsensitiveStr::Ascii("rs"),
            dictgen::InsensitiveStr::Ascii("s"),
        ],
        values: &[
            &["specified"],
            &["specified"],
            &["specifier"],
            &["specifiers"],
            &["specifies"],
            &["specifier"],
            &["specifiers"],
            &["specifies"],
        ],
        range: 1..=3,
    };

static WORD_SPEFICIC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SPEFICIC_CHILDREN),
    value: Some(&["specific"]),
};

pub static WORD_SPEFICIC_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("ally"),
            dictgen::InsensitiveStr::Ascii("ation"),
            dictgen::InsensitiveStr::Ascii("ations"),
            dictgen::InsensitiveStr::Ascii("s"),
        ],
        values: &[
            &["specifically"],
            &["specification"],
            &["specifications"],
            &["specifics"],
        ],
        range: 1..=6,
    };

static WORD_SPEFICIA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SPEFICIA_CHILDREN),
    value: None,
};

pub static WORD_SPEFICIA_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("ble"),
            dictgen::InsensitiveStr::Ascii("llally"),
            dictgen::InsensitiveStr::Ascii("llation"),
            dictgen::InsensitiveStr::Ascii("llations"),
            dictgen::InsensitiveStr::Ascii("lleid"),
            dictgen::InsensitiveStr::Ascii("lleir"),
            dictgen::InsensitiveStr::Ascii("lleirs"),
            dictgen::InsensitiveStr::Ascii("lleis"),
            dictgen::InsensitiveStr::Ascii("lliable"),
            dictgen::InsensitiveStr::Ascii("llic"),
            dictgen::InsensitiveStr::Ascii("llically"),
            dictgen::InsensitiveStr::Ascii("llication"),
            dictgen::InsensitiveStr::Ascii("llications"),
            dictgen::InsensitiveStr::Ascii("llics"),
            dictgen::InsensitiveStr::Ascii("llied"),
            dictgen::InsensitiveStr::Ascii("llier"),
            dictgen::InsensitiveStr::Ascii("lliers"),
            dictgen::InsensitiveStr::Ascii("llies"),
            dictgen::InsensitiveStr::Ascii("llifed"),
            dictgen::InsensitiveStr::Ascii("llifer"),
            dictgen::InsensitiveStr::Ascii("llifers"),
            dictgen::InsensitiveStr::Ascii("llifes"),
            dictgen::InsensitiveStr::Ascii("lly"),
            dictgen::InsensitiveStr::Ascii("tion"),
            dictgen::InsensitiveStr::Ascii("tions"),
        ],
        values: &[
            &["specifiable"],
            &["specifically"],
            &["specification"],
            &["specifications"],
            &["specified"],
            &["specifier"],
            &["specifiers"],
            &["specifies"],
            &["specifiable"],
            &["specific"],
            &["specifically"],
            &["specification"],
            &["specifications"],
            &["specifics"],
            &["specified"],
            &["specifier"],
            &["specifiers"],
            &["specifies"],
            &["specified"],
            &["specifier"],
            &["specifiers"],
            &["specifies"],
            &["specifically"],
            &["specification"],
            &["specifications"],
        ],
        range: 3..=10,
    };

static WORD_SPEFICE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SPEFICE_CHILDREN),
    value: None,
};

pub static WORD_SPEFICE_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("d"),
            dictgen::InsensitiveStr::Ascii("id"),
            dictgen::InsensitiveStr::Ascii("ir"),
            dictgen::InsensitiveStr::Ascii("irs"),
            dictgen::InsensitiveStr::Ascii("is"),
            dictgen::InsensitiveStr::Ascii("r"),
            dictgen::InsensitiveStr::Ascii("rs"),
            dictgen::InsensitiveStr::Ascii("s"),
        ],
        values: &[
            &["specified"],
            &["specified"],
            &["specifier"],
            &["specifiers"],
            &["specifies"],
            &["specifier"],
            &["specifiers"],
            &["specifies"],
        ],
        range: 1..=3,
    };

static WORD_SPEFICA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SPEFICA_CHILDREN),
    value: None,
};

pub static WORD_SPEFICA_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("ble"),
            dictgen::InsensitiveStr::Ascii("lly"),
            dictgen::InsensitiveStr::Ascii("tion"),
            dictgen::InsensitiveStr::Ascii("tions"),
        ],
        values: &[
            &["specifiable"],
            &["specifically"],
            &["specification"],
            &["specifications"],
        ],
        range: 3..=5,
    };

static WORD_SPEFIA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SPEFIA_CHILDREN),
    value: None,
};

pub static WORD_SPEFIA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ble"),
        dictgen::InsensitiveStr::Ascii("l"),
    ],
    values: &[&["specifiable"], &["special"]],
    range: 1..=3,
};

static WORD_SPEFE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SPEFE_CHILDREN),
    value: None,
};

pub static WORD_SPEFE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("id"),
        dictgen::InsensitiveStr::Ascii("ir"),
        dictgen::InsensitiveStr::Ascii("irs"),
        dictgen::InsensitiveStr::Ascii("is"),
    ],
    values: &[
        &["specified"],
        &["specifier"],
        &["specifiers"],
        &["specifies"],
    ],
    range: 2..=3,
};

static WORD_SPEFC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SPEFC_CHILDREN),
    value: None,
};

pub static WORD_SPEFC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ifiable"),
        dictgen::InsensitiveStr::Ascii("ific"),
        dictgen::InsensitiveStr::Ascii("ifically"),
        dictgen::InsensitiveStr::Ascii("ification"),
        dictgen::InsensitiveStr::Ascii("ifications"),
        dictgen::InsensitiveStr::Ascii("ifics"),
        dictgen::InsensitiveStr::Ascii("ifieid"),
        dictgen::InsensitiveStr::Ascii("ifieir"),
        dictgen::InsensitiveStr::Ascii("ifieirs"),
        dictgen::InsensitiveStr::Ascii("ifieis"),
        dictgen::InsensitiveStr::Ascii("ifiy"),
        dictgen::InsensitiveStr::Ascii("ifiying"),
    ],
    values: &[
        &["specifiable"],
        &["specific"],
        &["specifically"],
        &["specification"],
        &["specifications"],
        &["specifics"],
        &["specified"],
        &["specifier"],
        &["specifiers"],
        &["specifies"],
        &["specify"],
        &["specifying"],
    ],
    range: 4..=10,
};

static WORD_SPEFA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SPEFA_CHILDREN),
    value: None,
};

pub static WORD_SPEFA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("lly"),
        dictgen::InsensitiveStr::Ascii("tion"),
        dictgen::InsensitiveStr::Ascii("tions"),
    ],
    values: &[
        &["specially", "specifically"],
        &["separation", "specification"],
        &["separations", "specifications"],
    ],
    range: 3..=5,
};

static WORD_SPEE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SPEE_CHILDREN),
    value: None,
};

pub static WORD_SPEE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ak"),
        dictgen::InsensitiveStr::Ascii("aking"),
        dictgen::InsensitiveStr::Ascii("cheasy"),
        dictgen::InsensitiveStr::Ascii("chers"),
        dictgen::InsensitiveStr::Ascii("chs"),
        dictgen::InsensitiveStr::Ascii("ling"),
        dictgen::InsensitiveStr::Ascii("lling"),
        dictgen::InsensitiveStr::Ascii("p"),
        dictgen::InsensitiveStr::Ascii("ped"),
        dictgen::InsensitiveStr::Ascii("ping"),
    ],
    values: &[
        &["speak"],
        &["speaking"],
        &["speeches"],
        &["speeches"],
        &["speeches"],
        &["spelling"],
        &["spelling"],
        &["sleep"],
        &["sped"],
        &["sleeping"],
    ],
    range: 1..=6,
};

static WORD_SPED_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SPED_CHILDREN),
    value: None,
};

pub static WORD_SPED_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ific"),
        dictgen::InsensitiveStr::Ascii("ified"),
        dictgen::InsensitiveStr::Ascii("ify"),
    ],
    values: &[&["specific"], &["specified"], &["specify"]],
    range: 3..=5,
};

static WORD_SPEC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_SPEC_CHILDREN),
    value: None,
};

static WORD_SPEC_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_SPECA_NODE),
    None,
    None,
    None,
    Some(&WORD_SPECE_NODE),
    Some(&WORD_SPECF_NODE),
    None,
    None,
    Some(&WORD_SPECI_NODE),
    None,
    Some(&WORD_SPECK_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_SPECR_NODE),
    None,
    Some(&WORD_SPECT_NODE),
    Some(&WORD_SPECU_NODE),
    None,
    None,
    None,
    Some(&WORD_SPECY_NODE),
    None,
];

static WORD_SPECY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SPECY_CHILDREN),
    value: None,
};

pub static WORD_SPECY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("fing")],
    values: &[&["specifying"]],
    range: 4..=4,
};

static WORD_SPECU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SPECU_CHILDREN),
    value: None,
};

pub static WORD_SPECU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("alte"),
        dictgen::InsensitiveStr::Ascii("alting"),
        dictgen::InsensitiveStr::Ascii("altion"),
        dictgen::InsensitiveStr::Ascii("altions"),
        dictgen::InsensitiveStr::Ascii("altive"),
        dictgen::InsensitiveStr::Ascii("fies"),
        dictgen::InsensitiveStr::Ascii("fy"),
        dictgen::InsensitiveStr::Ascii("larite"),
        dictgen::InsensitiveStr::Ascii("latie"),
        dictgen::InsensitiveStr::Ascii("laties"),
        dictgen::InsensitiveStr::Ascii("latin"),
    ],
    values: &[
        &["speculate"],
        &["speculating"],
        &["speculation"],
        &["speculation"],
        &["speculative"],
        &["specifies"],
        &["specify"],
        &["speculative"],
        &["speculative"],
        &["speculative"],
        &["speculation"],
    ],
    range: 2..=7,
};

static WORD_SPECT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SPECT_CHILDREN),
    value: None,
};

pub static WORD_SPECT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("acuarly"),
        dictgen::InsensitiveStr::Ascii("aculair"),
        dictgen::InsensitiveStr::Ascii("aculaire"),
        dictgen::InsensitiveStr::Ascii("aculalry"),
        dictgen::InsensitiveStr::Ascii("acularely"),
        dictgen::InsensitiveStr::Ascii("acularily"),
        dictgen::InsensitiveStr::Ascii("aculary"),
        dictgen::InsensitiveStr::Ascii("acullar"),
        dictgen::InsensitiveStr::Ascii("arors"),
        dictgen::InsensitiveStr::Ascii("aters"),
        dictgen::InsensitiveStr::Ascii("atores"),
        dictgen::InsensitiveStr::Ascii("atular"),
        dictgen::InsensitiveStr::Ascii("atularly"),
        dictgen::InsensitiveStr::Ascii("auclar"),
        dictgen::InsensitiveStr::Ascii("aulars"),
        dictgen::InsensitiveStr::Ascii("ecular"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("ification"),
        dictgen::InsensitiveStr::Ascii("ifications"),
        dictgen::InsensitiveStr::Ascii("ified"),
        dictgen::InsensitiveStr::Ascii("ifies"),
        dictgen::InsensitiveStr::Ascii("ify"),
        dictgen::InsensitiveStr::Ascii("ifying"),
        dictgen::InsensitiveStr::Ascii("racal"),
        dictgen::InsensitiveStr::Ascii("rail"),
        dictgen::InsensitiveStr::Ascii("raply"),
        dictgen::InsensitiveStr::Ascii("rolab"),
        dictgen::InsensitiveStr::Ascii("s"),
        dictgen::InsensitiveStr::Ascii("ular"),
        dictgen::InsensitiveStr::Ascii("ularly"),
        dictgen::InsensitiveStr::Ascii("um"),
        dictgen::InsensitiveStr::Ascii("urm"),
    ],
    values: &[
        &["spectacular"],
        &["spectacular"],
        &["spectacular"],
        &["spectacularly"],
        &["spectacularly"],
        &["spectacularly"],
        &["spectacularly"],
        &["spectacularly"],
        &["spectators"],
        &["spectators"],
        &["spectators"],
        &["spectacular"],
        &["spectacularly"],
        &["spectacular"],
        &["spectaculars"],
        &["spectacular"],
        &["expected", "spectated"],
        &["specification"],
        &["specifications"],
        &["specified"],
        &["specifies"],
        &["specify"],
        &["specifying"],
        &["spectral"],
        &["spectral"],
        &["spectral"],
        &["spectral"],
        &["aspects", "expects", "specs"],
        &["spectacular"],
        &["spectacularly"],
        &["spectrum"],
        &["spectrum"],
    ],
    range: 1..=10,
};

static WORD_SPECR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SPECR_CHILDREN),
    value: None,
};

pub static WORD_SPECR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("tal")],
    values: &[&["spectral"]],
    range: 3..=3,
};

static WORD_SPECK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SPECK_CHILDREN),
    value: None,
};

pub static WORD_SPECK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("tor")],
    values: &[&["specter"]],
    range: 3..=3,
};

static WORD_SPECI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_SPECI_CHILDREN),
    value: None,
};

static WORD_SPECI_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_SPECIA_NODE),
    None,
    Some(&WORD_SPECIC_NODE),
    Some(&WORD_SPECID_NODE),
    Some(&WORD_SPECIE_NODE),
    Some(&WORD_SPECIF_NODE),
    None,
    None,
    Some(&WORD_SPECII_NODE),
    None,
    None,
    Some(&WORD_SPECIL_NODE),
    Some(&WORD_SPECIM_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_SPECIR_NODE),
    Some(&WORD_SPECIS_NODE),
    None,
    None,
    Some(&WORD_SPECIV_NODE),
    None,
    None,
    Some(&WORD_SPECIY_NODE),
    None,
];

static WORD_SPECIY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SPECIY_CHILDREN),
    value: Some(&["specify"]),
};

pub static WORD_SPECIY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("fing"),
        dictgen::InsensitiveStr::Ascii("fying"),
        dictgen::InsensitiveStr::Ascii("ing"),
    ],
    values: &[&["specifying"], &["specifying"], &["specifying"]],
    range: 3..=5,
};

static WORD_SPECIV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SPECIV_CHILDREN),
    value: None,
};

pub static WORD_SPECIV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ied")],
    values: &[&["specified"]],
    range: 3..=3,
};

static WORD_SPECIS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SPECIS_CHILDREN),
    value: None,
};

pub static WORD_SPECIS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("l")],
    values: &[&["specials"]],
    range: 1..=1,
};

static WORD_SPECIR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SPECIR_CHILDREN),
    value: None,
};

pub static WORD_SPECIR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ies"),
        dictgen::InsensitiveStr::Ascii("y"),
    ],
    values: &[&["specifies"], &["specify"]],
    range: 1..=3,
};

static WORD_SPECIM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SPECIM_CHILDREN),
    value: None,
};

pub static WORD_SPECIM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("an"),
        dictgen::InsensitiveStr::Ascii("ine"),
        dictgen::InsensitiveStr::Ascii("ines"),
    ],
    values: &[&["specimen"], &["specimen"], &["specimen"]],
    range: 2..=4,
};

static WORD_SPECIL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SPECIL_CHILDREN),
    value: None,
};

pub static WORD_SPECIL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aized"),
        dictgen::InsensitiveStr::Ascii("iast"),
        dictgen::InsensitiveStr::Ascii("iazation"),
        dictgen::InsensitiveStr::Ascii("iazed"),
        dictgen::InsensitiveStr::Ascii("isation"),
        dictgen::InsensitiveStr::Ascii("isations"),
        dictgen::InsensitiveStr::Ascii("ization"),
        dictgen::InsensitiveStr::Ascii("izations"),
        dictgen::InsensitiveStr::Ascii("ized"),
    ],
    values: &[
        &["specialize"],
        &["specialists"],
        &["specialization"],
        &["specialize"],
        &["specialisation"],
        &["specialisations"],
        &["specialization"],
        &["specializations"],
        &["specialized"],
    ],
    range: 4..=8,
};

static WORD_SPECII_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SPECII_CHILDREN),
    value: None,
};

pub static WORD_SPECII_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("c"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("fc"),
        dictgen::InsensitiveStr::Ascii("fed"),
    ],
    values: &[&["specific"], &["specified"], &["specific"], &["specified"]],
    range: 1..=3,
};

static WORD_SPECIF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_SPECIF_CHILDREN),
    value: None,
};

static WORD_SPECIF_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_SPECIFA_NODE),
    None,
    Some(&WORD_SPECIFC_NODE),
    None,
    Some(&WORD_SPECIFE_NODE),
    Some(&WORD_SPECIFF_NODE),
    None,
    None,
    Some(&WORD_SPECIFI_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_SPECIFR_NODE),
    None,
    Some(&WORD_SPECIFT_NODE),
    None,
    Some(&WORD_SPECIFV_NODE),
    None,
    None,
    Some(&WORD_SPECIFY_NODE),
    None,
];

static WORD_SPECIFY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SPECIFY_CHILDREN),
    value: None,
};

pub static WORD_SPECIFY_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("ed"),
            dictgen::InsensitiveStr::Ascii("ied"),
            dictgen::InsensitiveStr::Ascii("ig"),
            dictgen::InsensitiveStr::Ascii("inhg"),
        ],
        values: &[
            &["specified"],
            &["specified"],
            &["specifying"],
            &["specifying"],
        ],
        range: 2..=4,
    };

static WORD_SPECIFV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SPECIFV_CHILDREN),
    value: Some(&["specific"]),
};

pub static WORD_SPECIFV_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[],
        values: &[],
        range: 0..=0,
    };

static WORD_SPECIFT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SPECIFT_CHILDREN),
    value: Some(&["specify"]),
};

pub static WORD_SPECIFT_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[],
        values: &[],
        range: 0..=0,
    };

static WORD_SPECIFR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SPECIFR_CHILDREN),
    value: None,
};

pub static WORD_SPECIFR_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[dictgen::InsensitiveStr::Ascii("ic")],
        values: &[&["specific"]],
        range: 2..=2,
    };

static WORD_SPECIFI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SPECIFI_CHILDREN),
    value: Some(&["specific", "specify"]),
};

pub static WORD_SPECIFI_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("ally"),
            dictgen::InsensitiveStr::Ascii("caiton"),
            dictgen::InsensitiveStr::Ascii("caitons"),
            dictgen::InsensitiveStr::Ascii("callly"),
            dictgen::InsensitiveStr::Ascii("caly"),
            dictgen::InsensitiveStr::Ascii("cated"),
            dictgen::InsensitiveStr::Ascii("cateion"),
            dictgen::InsensitiveStr::Ascii("catin"),
            dictgen::InsensitiveStr::Ascii("cato"),
            dictgen::InsensitiveStr::Ascii("caton"),
            dictgen::InsensitiveStr::Ascii("catons"),
            dictgen::InsensitiveStr::Ascii("ced"),
            dictgen::InsensitiveStr::Ascii("cer"),
            dictgen::InsensitiveStr::Ascii("ces"),
            dictgen::InsensitiveStr::Ascii("ch"),
            dictgen::InsensitiveStr::Ascii("cially"),
            dictgen::InsensitiveStr::Ascii("ciation"),
            dictgen::InsensitiveStr::Ascii("ciations"),
            dictgen::InsensitiveStr::Ascii("cically"),
            dictgen::InsensitiveStr::Ascii("cied"),
            dictgen::InsensitiveStr::Ascii("cies"),
            dictgen::InsensitiveStr::Ascii("cl"),
            dictgen::InsensitiveStr::Ascii("cly"),
            dictgen::InsensitiveStr::Ascii("ction"),
            dictgen::InsensitiveStr::Ascii("ctions"),
            dictgen::InsensitiveStr::Ascii("cy"),
            dictgen::InsensitiveStr::Ascii("d"),
            dictgen::InsensitiveStr::Ascii("ec"),
            dictgen::InsensitiveStr::Ascii("ecally"),
            dictgen::InsensitiveStr::Ascii("ecation"),
            dictgen::InsensitiveStr::Ascii("ecations"),
            dictgen::InsensitiveStr::Ascii("ecd"),
            dictgen::InsensitiveStr::Ascii("eced"),
            dictgen::InsensitiveStr::Ascii("ecs"),
            dictgen::InsensitiveStr::Ascii("eed"),
            dictgen::InsensitiveStr::Ascii("ees"),
            dictgen::InsensitiveStr::Ascii("fed"),
            dictgen::InsensitiveStr::Ascii("g"),
            dictgen::InsensitiveStr::Ascii("gation"),
            dictgen::InsensitiveStr::Ascii("gations"),
            dictgen::InsensitiveStr::Ascii("ing"),
            dictgen::InsensitiveStr::Ascii("kation"),
            dictgen::InsensitiveStr::Ascii("ng"),
            dictgen::InsensitiveStr::Ascii("ties"),
            dictgen::InsensitiveStr::Ascii("ty"),
            dictgen::InsensitiveStr::Ascii("x"),
            dictgen::InsensitiveStr::Ascii("y"),
            dictgen::InsensitiveStr::Ascii("ying"),
            dictgen::InsensitiveStr::Ascii("yng"),
        ],
        values: &[
            &["specifically"],
            &["specifications", "specification"],
            &["specification", "specifications"],
            &["specifically"],
            &["specifically"],
            &["specified"],
            &["specification"],
            &["specification"],
            &["specification"],
            &["specification"],
            &["specifications"],
            &["specified"],
            &["specifier"],
            &["specifics", "specifies"],
            &["specify", "specific"],
            &["specifically"],
            &["specification"],
            &["specifications"],
            &["specifically"],
            &["specified"],
            &["specifics", "specifies"],
            &["specific"],
            &["specifically"],
            &["specification"],
            &["specifications"],
            &["specify", "specificity", "specifically"],
            &["specified"],
            &["specific"],
            &["specifically"],
            &["specification"],
            &["specifications"],
            &["specified"],
            &["specified"],
            &["specifics"],
            &["specified"],
            &["specifies"],
            &["specified"],
            &["specific"],
            &["specification"],
            &["specifications"],
            &["specifying"],
            &["specification"],
            &["specifying"],
            &["specifics"],
            &["specificity"],
            &["specific", "specifics"],
            &["specify"],
            &["specifying"],
            &["specifying"],
        ],
        range: 1..=8,
    };

static WORD_SPECIFF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SPECIFF_CHILDREN),
    value: None,
};

pub static WORD_SPECIFF_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("ic"),
            dictgen::InsensitiveStr::Ascii("ically"),
        ],
        values: &[&["specific"], &["specifically"]],
        range: 2..=6,
    };

static WORD_SPECIFE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SPECIFE_CHILDREN),
    value: None,
};

pub static WORD_SPECIFE_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("d"),
            dictgen::InsensitiveStr::Ascii("s"),
        ],
        values: &[&["specified"], &["specifies"]],
        range: 1..=1,
    };

static WORD_SPECIFC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SPECIFC_CHILDREN),
    value: Some(&["specific"]),
};

pub static WORD_SPECIFC_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("ally"),
            dictgen::InsensitiveStr::Ascii("ation"),
            dictgen::InsensitiveStr::Ascii("ations"),
            dictgen::InsensitiveStr::Ascii("ied"),
            dictgen::InsensitiveStr::Ascii("lly"),
        ],
        values: &[
            &["specifically"],
            &["specification"],
            &["specifications"],
            &["specified"],
            &["specifically"],
        ],
        range: 3..=6,
    };

static WORD_SPECIFA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SPECIFA_CHILDREN),
    value: None,
};

pub static WORD_SPECIFA_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[dictgen::InsensitiveStr::Ascii("ctions")],
        values: &[&["specifications"]],
        range: 6..=6,
    };

static WORD_SPECIE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SPECIE_CHILDREN),
    value: None,
};

pub static WORD_SPECIE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("d"),
        dictgen::InsensitiveStr::Ascii("fied"),
    ],
    values: &[&["specified"], &["specified"]],
    range: 1..=4,
};

static WORD_SPECID_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SPECID_CHILDREN),
    value: None,
};

pub static WORD_SPECID_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ic")],
    values: &[&["specific"]],
    range: 2..=2,
};

static WORD_SPECIC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SPECIC_CHILDREN),
    value: Some(&["specific"]),
};

pub static WORD_SPECIC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("al"),
        dictgen::InsensitiveStr::Ascii("ation"),
    ],
    values: &[&["special"], &["specification"]],
    range: 2..=5,
};

static WORD_SPECIA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SPECIA_CHILDREN),
    value: None,
};

pub static WORD_SPECIA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("al"),
        dictgen::InsensitiveStr::Ascii("fied"),
        dictgen::InsensitiveStr::Ascii("lazation"),
        dictgen::InsensitiveStr::Ascii("les"),
        dictgen::InsensitiveStr::Ascii("lication"),
        dictgen::InsensitiveStr::Ascii("lice"),
        dictgen::InsensitiveStr::Ascii("liced"),
        dictgen::InsensitiveStr::Ascii("lices"),
        dictgen::InsensitiveStr::Ascii("lied"),
        dictgen::InsensitiveStr::Ascii("lies"),
        dictgen::InsensitiveStr::Ascii("lis"),
        dictgen::InsensitiveStr::Ascii("lisaiton"),
        dictgen::InsensitiveStr::Ascii("lisaitons"),
        dictgen::InsensitiveStr::Ascii("listes"),
        dictgen::InsensitiveStr::Ascii("lites"),
        dictgen::InsensitiveStr::Ascii("lits"),
        dictgen::InsensitiveStr::Ascii("litzed"),
        dictgen::InsensitiveStr::Ascii("lizaiton"),
        dictgen::InsensitiveStr::Ascii("lizaitons"),
        dictgen::InsensitiveStr::Ascii("lizare"),
        dictgen::InsensitiveStr::Ascii("lizate"),
        dictgen::InsensitiveStr::Ascii("lizaton"),
        dictgen::InsensitiveStr::Ascii("lizeds"),
        dictgen::InsensitiveStr::Ascii("lizied"),
        dictgen::InsensitiveStr::Ascii("ll"),
        dictgen::InsensitiveStr::Ascii("llist"),
        dictgen::InsensitiveStr::Ascii("llity"),
        dictgen::InsensitiveStr::Ascii("llize"),
        dictgen::InsensitiveStr::Ascii("llized"),
        dictgen::InsensitiveStr::Ascii("llly"),
        dictgen::InsensitiveStr::Ascii("llty"),
        dictgen::InsensitiveStr::Ascii("lops"),
        dictgen::InsensitiveStr::Ascii("lsts"),
        dictgen::InsensitiveStr::Ascii("lt"),
        dictgen::InsensitiveStr::Ascii("ltys"),
        dictgen::InsensitiveStr::Ascii("ly"),
        dictgen::InsensitiveStr::Ascii("lz"),
        dictgen::InsensitiveStr::Ascii("lzed"),
        dictgen::InsensitiveStr::Ascii("lzes"),
        dictgen::InsensitiveStr::Ascii("lzied"),
        dictgen::InsensitiveStr::Ascii("s"),
        dictgen::InsensitiveStr::Ascii("tly"),
    ],
    values: &[
        &["special"],
        &["specified"],
        &["specialization"],
        &["specials"],
        &["specialization"],
        &["specialize"],
        &["specialized", "specialised"],
        &["specializes"],
        &["specialized"],
        &["specializes"],
        &["specials"],
        &["specialisation"],
        &["specialisations"],
        &["specialists"],
        &["specializes"],
        &["specials"],
        &["specialized"],
        &["specialization"],
        &["specializations"],
        &["specialize"],
        &["specialize"],
        &["specialization"],
        &["specializes"],
        &["specialize"],
        &["special", "specially"],
        &["specialist"],
        &["specially"],
        &["specialize"],
        &["specialized"],
        &["specially"],
        &["specially"],
        &["specials"],
        &["specialists"],
        &["specialist"],
        &["specials"],
        &["specially"],
        &["specialize"],
        &["specialized"],
        &["specializes"],
        &["specialized"],
        &["specials"],
        &["specialty"],
    ],
    range: 1..=9,
};

static WORD_SPECF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SPECF_CHILDREN),
    value: None,
};

pub static WORD_SPECF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ic"),
        dictgen::InsensitiveStr::Ascii("ically"),
        dictgen::InsensitiveStr::Ascii("ication"),
        dictgen::InsensitiveStr::Ascii("ications"),
        dictgen::InsensitiveStr::Ascii("icication"),
        dictgen::InsensitiveStr::Ascii("icications"),
        dictgen::InsensitiveStr::Ascii("icied"),
        dictgen::InsensitiveStr::Ascii("icies"),
        dictgen::InsensitiveStr::Ascii("icy"),
        dictgen::InsensitiveStr::Ascii("icying"),
        dictgen::InsensitiveStr::Ascii("ied"),
        dictgen::InsensitiveStr::Ascii("ield"),
        dictgen::InsensitiveStr::Ascii("ies"),
        dictgen::InsensitiveStr::Ascii("ifies"),
        dictgen::InsensitiveStr::Ascii("ify"),
        dictgen::InsensitiveStr::Ascii("ifying"),
        dictgen::InsensitiveStr::Ascii("iied"),
        dictgen::InsensitiveStr::Ascii("y"),
        dictgen::InsensitiveStr::Ascii("ying"),
    ],
    values: &[
        &["specific"],
        &["specifically"],
        &["specification"],
        &["specifications"],
        &["specification"],
        &["specifications"],
        &["specified"],
        &["specifies"],
        &["specify"],
        &["specifying"],
        &["specified"],
        &["specified"],
        &["specifies"],
        &["specifies"],
        &["specify"],
        &["specifying"],
        &["specified"],
        &["specify"],
        &["specifying"],
    ],
    range: 1..=10,
};

static WORD_SPECE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SPECE_CHILDREN),
    value: Some(&["space", "spice"]),
};

pub static WORD_SPECE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("fic"),
        dictgen::InsensitiveStr::Ascii("fically"),
        dictgen::InsensitiveStr::Ascii("ficly"),
        dictgen::InsensitiveStr::Ascii("fied"),
        dictgen::InsensitiveStr::Ascii("min"),
    ],
    values: &[
        &["specific"],
        &["specifically"],
        &["specifically"],
        &["specified"],
        &["specimen"],
    ],
    range: 3..=7,
};

static WORD_SPECA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SPECA_CHILDREN),
    value: None,
};

pub static WORD_SPECA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("il"),
        dictgen::InsensitiveStr::Ascii("ilist"),
        dictgen::InsensitiveStr::Ascii("ilists"),
        dictgen::InsensitiveStr::Ascii("ilization"),
        dictgen::InsensitiveStr::Ascii("ilize"),
        dictgen::InsensitiveStr::Ascii("ilized"),
        dictgen::InsensitiveStr::Ascii("ilizes"),
        dictgen::InsensitiveStr::Ascii("illy"),
        dictgen::InsensitiveStr::Ascii("ilty"),
        dictgen::InsensitiveStr::Ascii("lity"),
        dictgen::InsensitiveStr::Ascii("tcular"),
    ],
    values: &[
        &["special"],
        &["specialist"],
        &["specialists"],
        &["specialization"],
        &["specializes"],
        &["specialized"],
        &["specializes"],
        &["specially"],
        &["specialty"],
        &["speciality"],
        &["spectacular"],
    ],
    range: 2..=9,
};

static WORD_SPEA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SPEA_CHILDREN),
    value: None,
};

pub static WORD_SPEA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ce"),
        dictgen::InsensitiveStr::Ascii("ced"),
        dictgen::InsensitiveStr::Ascii("ces"),
        dictgen::InsensitiveStr::Ascii("ch"),
        dictgen::InsensitiveStr::Ascii("cial"),
        dictgen::InsensitiveStr::Ascii("cing"),
        dictgen::InsensitiveStr::Ascii("rate"),
        dictgen::InsensitiveStr::Ascii("rated"),
        dictgen::InsensitiveStr::Ascii("rates"),
        dictgen::InsensitiveStr::Ascii("rating"),
        dictgen::InsensitiveStr::Ascii("rator"),
        dictgen::InsensitiveStr::Ascii("rators"),
    ],
    values: &[
        &["peace", "space"],
        &["spaced"],
        &["spaces", "species"],
        &["speech"],
        &["special", "spacial"],
        &["spacing"],
        &["separate"],
        &["separated"],
        &["separates"],
        &["separating"],
        &["separator"],
        &["separators"],
    ],
    range: 2..=6,
};

static WORD_SPC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SPC_CHILDREN),
    value: None,
};

pub static WORD_SPC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ae"),
        dictgen::InsensitiveStr::Ascii("aed"),
        dictgen::InsensitiveStr::Ascii("aes"),
        dictgen::InsensitiveStr::Ascii("aing"),
        dictgen::InsensitiveStr::Ascii("ecified"),
        dictgen::InsensitiveStr::Ascii("ial"),
        dictgen::InsensitiveStr::Ascii("ific"),
        dictgen::InsensitiveStr::Ascii("ification"),
        dictgen::InsensitiveStr::Ascii("ifications"),
        dictgen::InsensitiveStr::Ascii("ified"),
        dictgen::InsensitiveStr::Ascii("ifies"),
        dictgen::InsensitiveStr::Ascii("ify"),
    ],
    values: &[
        &["space"],
        &["spaced"],
        &["spaces"],
        &["spacing"],
        &["specified"],
        &["special"],
        &["specific"],
        &["specification"],
        &["specifications"],
        &["specified"],
        &["specifies"],
        &["specify"],
    ],
    range: 2..=10,
};

static WORD_SPA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SPA_CHILDREN),
    value: None,
};

pub static WORD_SPA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cebr"),
        dictgen::InsensitiveStr::Ascii("cegoat"),
        dictgen::InsensitiveStr::Ascii("cific"),
        dictgen::InsensitiveStr::Ascii("cification"),
        dictgen::InsensitiveStr::Ascii("cifications"),
        dictgen::InsensitiveStr::Ascii("cifics"),
        dictgen::InsensitiveStr::Ascii("cified"),
        dictgen::InsensitiveStr::Ascii("cifies"),
        dictgen::InsensitiveStr::Ascii("ece"),
        dictgen::InsensitiveStr::Ascii("eced"),
        dictgen::InsensitiveStr::Ascii("eces"),
        dictgen::InsensitiveStr::Ascii("ecing"),
        dictgen::InsensitiveStr::Ascii("gehtti"),
        dictgen::InsensitiveStr::Ascii("geti"),
        dictgen::InsensitiveStr::Ascii("getti"),
        dictgen::InsensitiveStr::Ascii("gheti"),
        dictgen::InsensitiveStr::Ascii("gnum"),
        dictgen::InsensitiveStr::Ascii("hgetti"),
        dictgen::InsensitiveStr::Ascii("inish"),
        dictgen::InsensitiveStr::Ascii("insh"),
        dictgen::InsensitiveStr::Ascii("ltoon"),
        dictgen::InsensitiveStr::Ascii("mmade"),
        dictgen::InsensitiveStr::Ascii("mmare"),
        dictgen::InsensitiveStr::Ascii("mmear"),
        dictgen::InsensitiveStr::Ascii("mmend"),
        dictgen::InsensitiveStr::Ascii("mmeur"),
        dictgen::InsensitiveStr::Ascii("ning"),
        dictgen::InsensitiveStr::Ascii("nisch"),
        dictgen::InsensitiveStr::Ascii("nsih"),
        dictgen::InsensitiveStr::Ascii("nwed"),
        dictgen::InsensitiveStr::Ascii("rate"),
        dictgen::InsensitiveStr::Ascii("rated"),
        dictgen::InsensitiveStr::Ascii("rately"),
        dictgen::InsensitiveStr::Ascii("rkel"),
        dictgen::InsensitiveStr::Ascii("rklie"),
        dictgen::InsensitiveStr::Ascii("rlking"),
        dictgen::InsensitiveStr::Ascii("rtaniis"),
        dictgen::InsensitiveStr::Ascii("rtanops"),
        dictgen::InsensitiveStr::Ascii("rtants"),
        dictgen::InsensitiveStr::Ascii("rtas"),
        dictgen::InsensitiveStr::Ascii("rtsn"),
        dictgen::InsensitiveStr::Ascii("ryed"),
        dictgen::InsensitiveStr::Ascii("sh"),
        dictgen::InsensitiveStr::Ascii("shed"),
        dictgen::InsensitiveStr::Ascii("shes"),
        dictgen::InsensitiveStr::Ascii("w"),
        dictgen::InsensitiveStr::Ascii("wed"),
        dictgen::InsensitiveStr::Ascii("wend"),
        dictgen::InsensitiveStr::Ascii("wing"),
        dictgen::InsensitiveStr::Ascii("wining"),
        dictgen::InsensitiveStr::Ascii("wnig"),
        dictgen::InsensitiveStr::Ascii("wnign"),
        dictgen::InsensitiveStr::Ascii("wnve"),
        dictgen::InsensitiveStr::Ascii("ws"),
    ],
    values: &[
        &["spacebar"],
        &["scapegoat"],
        &["specific"],
        &["specification"],
        &["specifications"],
        &["specifics"],
        &["specified"],
        &["specifies"],
        &["space"],
        &["spaced"],
        &["spaces"],
        &["spacing"],
        &["spaghetti"],
        &["spaghetti"],
        &["spaghetti"],
        &["spaghetti"],
        &["sphagnum"],
        &["spaghetti"],
        &["spanish"],
        &["spanish"],
        &["splatoon"],
        &["spammed"],
        &["spammer"],
        &["spammer"],
        &["spammed"],
        &["spammer"],
        &["spanning"],
        &["spanish"],
        &["spanish"],
        &["spawned"],
        &["separate"],
        &["separated"],
        &["separately"],
        &["sparkle"],
        &["sparkle"],
        &["sparkling"],
        &["spartans"],
        &["spartans"],
        &["spartans"],
        &["spartans"],
        &["spartans"],
        &["sprayed"],
        &["splash"],
        &["splashed"],
        &["splashes"],
        &["spawn"],
        &["spawned"],
        &["spawned"],
        &["spawning"],
        &["spawning"],
        &["spawning"],
        &["spawning"],
        &["spawn"],
        &["spawns"],
    ],
    range: 1..=11,
};

static WORD_SO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_SO_CHILDREN),
    value: None,
};

static WORD_SO_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_SOA_NODE),
    Some(&WORD_SOB_NODE),
    Some(&WORD_SOC_NODE),
    Some(&WORD_SOD_NODE),
    Some(&WORD_SOE_NODE),
    Some(&WORD_SOF_NODE),
    None,
    Some(&WORD_SOH_NODE),
    Some(&WORD_SOI_NODE),
    None,
    Some(&WORD_SOK_NODE),
    Some(&WORD_SOL_NODE),
    Some(&WORD_SOM_NODE),
    Some(&WORD_SON_NODE),
    Some(&WORD_SOO_NODE),
    Some(&WORD_SOP_NODE),
    None,
    Some(&WORD_SOR_NODE),
    Some(&WORD_SOS_NODE),
    Some(&WORD_SOT_NODE),
    Some(&WORD_SOU_NODE),
    Some(&WORD_SOV_NODE),
    Some(&WORD_SOW_NODE),
    None,
    None,
    None,
];

static WORD_SOW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SOW_CHILDREN),
    value: None,
};

pub static WORD_SOW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("e")],
    values: &[&["sow"]],
    range: 1..=1,
};

static WORD_SOV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SOV_CHILDREN),
    value: None,
};

pub static WORD_SOV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eits"),
        dictgen::InsensitiveStr::Ascii("er"),
        dictgen::InsensitiveStr::Ascii("eregin"),
        dictgen::InsensitiveStr::Ascii("eregnity"),
        dictgen::InsensitiveStr::Ascii("ereighnty"),
        dictgen::InsensitiveStr::Ascii("ereighty"),
        dictgen::InsensitiveStr::Ascii("ereignety"),
        dictgen::InsensitiveStr::Ascii("ereignity"),
        dictgen::InsensitiveStr::Ascii("ereigny"),
        dictgen::InsensitiveStr::Ascii("erein"),
        dictgen::InsensitiveStr::Ascii("ereing"),
        dictgen::InsensitiveStr::Ascii("ereingty"),
        dictgen::InsensitiveStr::Ascii("ereinity"),
        dictgen::InsensitiveStr::Ascii("ereinty"),
        dictgen::InsensitiveStr::Ascii("eriegn"),
        dictgen::InsensitiveStr::Ascii("eriegnty"),
        dictgen::InsensitiveStr::Ascii("eriengty"),
        dictgen::InsensitiveStr::Ascii("erign"),
        dictgen::InsensitiveStr::Ascii("erignity"),
        dictgen::InsensitiveStr::Ascii("erignty"),
        dictgen::InsensitiveStr::Ascii("ietes"),
        dictgen::InsensitiveStr::Ascii("le"),
        dictgen::InsensitiveStr::Ascii("led"),
        dictgen::InsensitiveStr::Ascii("ren"),
    ],
    values: &[
        &["soviets"],
        &["solver"],
        &["sovereign"],
        &["sovereignty"],
        &["sovereignty"],
        &["sovereignty"],
        &["sovereignty"],
        &["sovereignty"],
        &["sovereignty"],
        &["sovereign"],
        &["sovereign"],
        &["sovereignty"],
        &["sovereignty"],
        &["sovereignty"],
        &["sovereign"],
        &["sovereignty"],
        &["sovereignty"],
        &["sovereign"],
        &["sovereignty"],
        &["sovereignty"],
        &["soviets"],
        &["solve"],
        &["solved"],
        &["sovereign"],
    ],
    range: 2..=9,
};

static WORD_SOU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SOU_CHILDREN),
    value: None,
};

pub static WORD_SOU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ce"),
        dictgen::InsensitiveStr::Ascii("ces"),
        dictgen::InsensitiveStr::Ascii("ch"),
        dictgen::InsensitiveStr::Ascii("cre"),
        dictgen::InsensitiveStr::Ascii("cres"),
        dictgen::InsensitiveStr::Ascii("dn"),
        dictgen::InsensitiveStr::Ascii("dns"),
        dictgen::InsensitiveStr::Ascii("dntrack"),
        dictgen::InsensitiveStr::Ascii("ld"),
        dictgen::InsensitiveStr::Ascii("ltion"),
        dictgen::InsensitiveStr::Ascii("ltions"),
        dictgen::InsensitiveStr::Ascii("ndard"),
        dictgen::InsensitiveStr::Ascii("ndrtack"),
        dictgen::InsensitiveStr::Ascii("ndtracs"),
        dictgen::InsensitiveStr::Ascii("ndtrak"),
        dictgen::InsensitiveStr::Ascii("ndtrakc"),
        dictgen::InsensitiveStr::Ascii("ndtrakcs"),
        dictgen::InsensitiveStr::Ascii("ndtrakk"),
        dictgen::InsensitiveStr::Ascii("ndtraks"),
        dictgen::InsensitiveStr::Ascii("ntrack"),
        dictgen::InsensitiveStr::Ascii("rbraten"),
        dictgen::InsensitiveStr::Ascii("rc"),
        dictgen::InsensitiveStr::Ascii("rcd"),
        dictgen::InsensitiveStr::Ascii("rcde"),
        dictgen::InsensitiveStr::Ascii("rcedrectory"),
        dictgen::InsensitiveStr::Ascii("rcee"),
        dictgen::InsensitiveStr::Ascii("rcees"),
        dictgen::InsensitiveStr::Ascii("rcs"),
        dictgen::InsensitiveStr::Ascii("rcse"),
        dictgen::InsensitiveStr::Ascii("rct"),
        dictgen::InsensitiveStr::Ascii("re"),
        dictgen::InsensitiveStr::Ascii("res"),
        dictgen::InsensitiveStr::Ascii("rrounding"),
        dictgen::InsensitiveStr::Ascii("rt"),
        dictgen::InsensitiveStr::Ascii("rth"),
        dictgen::InsensitiveStr::Ascii("rthern"),
        dictgen::InsensitiveStr::Ascii("thampon"),
        dictgen::InsensitiveStr::Ascii("thamption"),
        dictgen::InsensitiveStr::Ascii("thamton"),
        dictgen::InsensitiveStr::Ascii("thamtpon"),
        dictgen::InsensitiveStr::Ascii("thanpton"),
        dictgen::InsensitiveStr::Ascii("thapmton"),
        dictgen::InsensitiveStr::Ascii("thbrige"),
        dictgen::InsensitiveStr::Ascii("then"),
        dictgen::InsensitiveStr::Ascii("therers"),
        dictgen::InsensitiveStr::Ascii("thernerns"),
        dictgen::InsensitiveStr::Ascii("thernes"),
        dictgen::InsensitiveStr::Ascii("thernese"),
        dictgen::InsensitiveStr::Ascii("therness"),
        dictgen::InsensitiveStr::Ascii("thernest"),
        dictgen::InsensitiveStr::Ascii("thernors"),
        dictgen::InsensitiveStr::Ascii("therton"),
        dictgen::InsensitiveStr::Ascii("thmapton"),
        dictgen::InsensitiveStr::Ascii("thren"),
        dictgen::InsensitiveStr::Ascii("thtampon"),
        dictgen::InsensitiveStr::Ascii("venier"),
        dictgen::InsensitiveStr::Ascii("veniers"),
        dictgen::InsensitiveStr::Ascii("vinear"),
        dictgen::InsensitiveStr::Ascii("vinears"),
        dictgen::InsensitiveStr::Ascii("vineer"),
        dictgen::InsensitiveStr::Ascii("vineers"),
        dictgen::InsensitiveStr::Ascii("vinneer"),
        dictgen::InsensitiveStr::Ascii("vinneers"),
    ],
    values: &[
        &["source"],
        &["sources"],
        &["pouch", "sough", "such", "touch"],
        &["source"],
        &["sources"],
        &["sound"],
        &["sounds"],
        &["soundtrack"],
        &["could", "should", "sold"],
        &["solution"],
        &["solutions"],
        &["soundcard"],
        &["soundtracks"],
        &["soundtracks"],
        &["soundtrack"],
        &["soundtracks"],
        &["soundtracks"],
        &["soundtrack"],
        &["soundtracks"],
        &["soundtrack"],
        &["sauerbraten"],
        &["source"],
        &["sourced", "source"],
        &["sourced", "source"],
        &["sourcedirectory"],
        &["source"],
        &["sources"],
        &["sources", "source"],
        &["sources", "source"],
        &["source"],
        &["source", "sure", "sore", "sour", "soured"],
        &["sources", "sores", "sours", "soured"],
        &["surrounding"],
        &["sort", "south", "sour"],
        &["south"],
        &["southern"],
        &["southampton"],
        &["southampton"],
        &["southampton"],
        &["southampton"],
        &["southampton"],
        &["southampton"],
        &["southbridge"],
        &["southern"],
        &["southerners"],
        &["southerners"],
        &["southerners"],
        &["southerners"],
        &["southerners"],
        &["southerners"],
        &["southerners"],
        &["southern"],
        &["southampton"],
        &["southern"],
        &["southampton"],
        &["souvenir"],
        &["souvenirs"],
        &["souvenir"],
        &["souvenirs"],
        &["souvenir"],
        &["souvenirs"],
        &["souvenir"],
        &["souvenirs"],
    ],
    range: 2..=11,
};

static WORD_SOT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SOT_CHILDREN),
    value: None,
};

pub static WORD_SOT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("erd"),
        dictgen::InsensitiveStr::Ascii("fware"),
        dictgen::InsensitiveStr::Ascii("rage"),
        dictgen::InsensitiveStr::Ascii("red"),
        dictgen::InsensitiveStr::Ascii("res"),
        dictgen::InsensitiveStr::Ascii("ring"),
        dictgen::InsensitiveStr::Ascii("rmfront"),
        dictgen::InsensitiveStr::Ascii("ry"),
        dictgen::InsensitiveStr::Ascii("ryline"),
        dictgen::InsensitiveStr::Ascii("rylines"),
        dictgen::InsensitiveStr::Ascii("yr"),
    ],
    values: &[
        &["stored", "sorted"],
        &["software"],
        &["storage", "shortage"],
        &["sorted", "stored"],
        &["stores"],
        &["storing", "sorting"],
        &["stormfront"],
        &["story", "sorry"],
        &["storyline"],
        &["storylines"],
        &["satyr", "story"],
    ],
    range: 2..=7,
};

static WORD_SOS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SOS_CHILDREN),
    value: None,
};

pub static WORD_SOS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("cket")],
    values: &[&["socket"]],
    range: 4..=4,
};

static WORD_SOR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SOR_CHILDREN),
    value: None,
};

pub static WORD_SOR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ce"),
        dictgen::InsensitiveStr::Ascii("cercy"),
        dictgen::InsensitiveStr::Ascii("cerey"),
        dictgen::InsensitiveStr::Ascii("ceror"),
        dictgen::InsensitiveStr::Ascii("cerry"),
        dictgen::InsensitiveStr::Ascii("kflow"),
        dictgen::InsensitiveStr::Ascii("panos"),
        dictgen::InsensitiveStr::Ascii("rogate"),
        dictgen::InsensitiveStr::Ascii("rounding"),
        dictgen::InsensitiveStr::Ascii("tig"),
        dictgen::InsensitiveStr::Ascii("tings"),
        dictgen::InsensitiveStr::Ascii("tlst"),
        dictgen::InsensitiveStr::Ascii("tner"),
        dictgen::InsensitiveStr::Ascii("tnr"),
        dictgen::InsensitiveStr::Ascii("trage"),
        dictgen::InsensitiveStr::Ascii("uce"),
        dictgen::InsensitiveStr::Ascii("uces"),
    ],
    values: &[
        &["source", "force"],
        &["sorcery"],
        &["sorcery"],
        &["sorcerer"],
        &["sorcery"],
        &["workflow"],
        &["sopranos"],
        &["surrogate"],
        &["surrounding"],
        &["sorting"],
        &["sorting"],
        &["sortlist"],
        &["sorter"],
        &["sorter"],
        &["storage", "shortage"],
        &["source", "spruce"],
        &["sources", "spruces"],
    ],
    range: 2..=8,
};

static WORD_SOP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SOP_CHILDREN),
    value: None,
};

pub static WORD_SOP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("arnos"),
        dictgen::InsensitiveStr::Ascii("hicated"),
        dictgen::InsensitiveStr::Ascii("hisicated"),
        dictgen::InsensitiveStr::Ascii("hisitcated"),
        dictgen::InsensitiveStr::Ascii("histacated"),
        dictgen::InsensitiveStr::Ascii("histicaed"),
        dictgen::InsensitiveStr::Ascii("histicted"),
        dictgen::InsensitiveStr::Ascii("histocated"),
        dictgen::InsensitiveStr::Ascii("hmore"),
        dictgen::InsensitiveStr::Ascii("hmores"),
        dictgen::InsensitiveStr::Ascii("hosticated"),
        dictgen::InsensitiveStr::Ascii("ohmore"),
        dictgen::InsensitiveStr::Ascii("und"),
        dictgen::InsensitiveStr::Ascii("unded"),
        dictgen::InsensitiveStr::Ascii("unding"),
        dictgen::InsensitiveStr::Ascii("unds"),
    ],
    values: &[
        &["sopranos"],
        &["sophisticated"],
        &["sophisticated"],
        &["sophisticated"],
        &["sophisticated"],
        &["sophisticated"],
        &["sophisticated"],
        &["sophisticated"],
        &["sophomore"],
        &["sophomores"],
        &["sophisticated"],
        &["sophomore"],
        &["sound"],
        &["sounded"],
        &["sounding"],
        &["sounds"],
    ],
    range: 3..=10,
};

static WORD_SOO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SOO_CHILDREN),
    value: None,
};

pub static WORD_SOO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aside"),
        dictgen::InsensitiveStr::Ascii("donim"),
        dictgen::InsensitiveStr::Ascii("it"),
        dictgen::InsensitiveStr::Ascii("p"),
        dictgen::InsensitiveStr::Ascii("urce"),
        dictgen::InsensitiveStr::Ascii("vinear"),
        dictgen::InsensitiveStr::Ascii("vinears"),
        dictgen::InsensitiveStr::Ascii("vineer"),
        dictgen::InsensitiveStr::Ascii("vineers"),
        dictgen::InsensitiveStr::Ascii("vinneer"),
        dictgen::InsensitiveStr::Ascii("vinneers"),
    ],
    values: &[
        &["suicide"],
        &["pseudonym"],
        &["suet", "suit", "soot"],
        &["soup", "scoop", "snoop", "soap"],
        &["source"],
        &["souvenir"],
        &["souvenirs"],
        &["souvenir"],
        &["souvenirs"],
        &["souvenir"],
        &["souvenirs"],
    ],
    range: 1..=8,
};

static WORD_SON_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SON_CHILDREN),
    value: None,
};

pub static WORD_SON_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ething"),
        dictgen::InsensitiveStr::Ascii("glar"),
        dictgen::InsensitiveStr::Ascii("gle"),
        dictgen::InsensitiveStr::Ascii("gled"),
        dictgen::InsensitiveStr::Ascii("gles"),
        dictgen::InsensitiveStr::Ascii("gling"),
    ],
    values: &[
        &["something"],
        &["singular"],
        &["single", "dongle"],
        &["singled", "dongled"],
        &["singles", "dongles"],
        &["singling", "dongling"],
    ],
    range: 3..=6,
};

static WORD_SOM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_SOM_CHILDREN),
    value: Some(&["some"]),
};

static WORD_SOM_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_SOMA_NODE),
    None,
    None,
    None,
    Some(&WORD_SOME_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_SOMM_NODE),
    None,
    Some(&WORD_SOMO_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_SOMT_NODE),
    None,
    None,
    Some(&WORD_SOMW_NODE),
    None,
    None,
    None,
];

static WORD_SOMW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SOMW_CHILDREN),
    value: None,
};

pub static WORD_SOMW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("hat"),
        dictgen::InsensitiveStr::Ascii("here"),
        dictgen::InsensitiveStr::Ascii("ho"),
        dictgen::InsensitiveStr::Ascii("how"),
    ],
    values: &[&["somewhat"], &["somewhere"], &["somehow"], &["somehow"]],
    range: 2..=4,
};

static WORD_SOMT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SOMT_CHILDREN),
    value: None,
};

pub static WORD_SOMT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("hign"),
        dictgen::InsensitiveStr::Ascii("hing"),
        dictgen::InsensitiveStr::Ascii("hingelse"),
        dictgen::InsensitiveStr::Ascii("imes"),
    ],
    values: &[
        &["something"],
        &["something"],
        &["somethingelse"],
        &["sometimes"],
    ],
    range: 4..=8,
};

static WORD_SOMO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SOMO_CHILDREN),
    value: None,
};

pub static WORD_SOMO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("enes")],
    values: &[&["someones"]],
    range: 4..=4,
};

static WORD_SOMM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SOMM_CHILDREN),
    value: None,
};

pub static WORD_SOMM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("e")],
    values: &[&["some"]],
    range: 1..=1,
};

static WORD_SOME_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SOME_CHILDREN),
    value: None,
};

pub static WORD_SOME_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("boby"),
        dictgen::InsensitiveStr::Ascii("ghing"),
        dictgen::InsensitiveStr::Ascii("hing"),
        dictgen::InsensitiveStr::Ascii("htin"),
        dictgen::InsensitiveStr::Ascii("hting"),
        dictgen::InsensitiveStr::Ascii("htings"),
        dictgen::InsensitiveStr::Ascii("hwat"),
        dictgen::InsensitiveStr::Ascii("hwere"),
        dictgen::InsensitiveStr::Ascii("hwo"),
        dictgen::InsensitiveStr::Ascii("ne"),
        dictgen::InsensitiveStr::Ascii("none"),
        dictgen::InsensitiveStr::Ascii("oene"),
        dictgen::InsensitiveStr::Ascii("oens"),
        dictgen::InsensitiveStr::Ascii("on"),
        dictgen::InsensitiveStr::Ascii("oneis"),
        dictgen::InsensitiveStr::Ascii("onelse"),
        dictgen::InsensitiveStr::Ascii("ons"),
        dictgen::InsensitiveStr::Ascii("s"),
        dictgen::InsensitiveStr::Ascii("thibng"),
        dictgen::InsensitiveStr::Ascii("thig"),
        dictgen::InsensitiveStr::Ascii("thign"),
        dictgen::InsensitiveStr::Ascii("thigng"),
        dictgen::InsensitiveStr::Ascii("thigns"),
        dictgen::InsensitiveStr::Ascii("thihng"),
        dictgen::InsensitiveStr::Ascii("thiing"),
        dictgen::InsensitiveStr::Ascii("thijng"),
        dictgen::InsensitiveStr::Ascii("thikng"),
        dictgen::InsensitiveStr::Ascii("thimes"),
        dictgen::InsensitiveStr::Ascii("thimg"),
        dictgen::InsensitiveStr::Ascii("thimng"),
        dictgen::InsensitiveStr::Ascii("thinbg"),
        dictgen::InsensitiveStr::Ascii("thines"),
        dictgen::InsensitiveStr::Ascii("thinfg"),
        dictgen::InsensitiveStr::Ascii("thingest"),
        dictgen::InsensitiveStr::Ascii("thingis"),
        dictgen::InsensitiveStr::Ascii("thinhg"),
        dictgen::InsensitiveStr::Ascii("thinig"),
        dictgen::InsensitiveStr::Ascii("thinkg"),
        dictgen::InsensitiveStr::Ascii("thinks"),
        dictgen::InsensitiveStr::Ascii("thinmg"),
        dictgen::InsensitiveStr::Ascii("thinng"),
        dictgen::InsensitiveStr::Ascii("thins"),
        dictgen::InsensitiveStr::Ascii("thintg"),
        dictgen::InsensitiveStr::Ascii("thiong"),
        dictgen::InsensitiveStr::Ascii("this"),
        dictgen::InsensitiveStr::Ascii("thiung"),
        dictgen::InsensitiveStr::Ascii("thn"),
        dictgen::InsensitiveStr::Ascii("tiem"),
        dictgen::InsensitiveStr::Ascii("tiems"),
        dictgen::InsensitiveStr::Ascii("tihing"),
        dictgen::InsensitiveStr::Ascii("tihn"),
        dictgen::InsensitiveStr::Ascii("tihng"),
        dictgen::InsensitiveStr::Ascii("tiles"),
        dictgen::InsensitiveStr::Ascii("tims"),
        dictgen::InsensitiveStr::Ascii("tines"),
        dictgen::InsensitiveStr::Ascii("ting"),
        dictgen::InsensitiveStr::Ascii("tinh"),
        dictgen::InsensitiveStr::Ascii("tinhg"),
        dictgen::InsensitiveStr::Ascii("tring"),
        dictgen::InsensitiveStr::Ascii("trings"),
        dictgen::InsensitiveStr::Ascii("were"),
        dictgen::InsensitiveStr::Ascii("wher"),
        dictgen::InsensitiveStr::Ascii("who"),
    ],
    values: &[
        &["somebody"],
        &["something"],
        &["something"],
        &["something"],
        &["something"],
        &["somethings"],
        &["somewhat"],
        &["somewhere"],
        &["somehow"],
        &["someone"],
        &["someone"],
        &["someone"],
        &["someones"],
        &["someone"],
        &["someones"],
        &["someones"],
        &["someones"],
        &["some", "sums"],
        &["something"],
        &["something"],
        &["something"],
        &["something"],
        &["somethings"],
        &["something"],
        &["something"],
        &["something"],
        &["somethin"],
        &["sometimes"],
        &["something"],
        &["something"],
        &["somethings"],
        &["somethings"],
        &["somethings"],
        &["somethings"],
        &["somethings"],
        &["somethings"],
        &["somethings"],
        &["somethings"],
        &["somethings"],
        &["somethings"],
        &["somethings"],
        &["somethings"],
        &["somethings"],
        &["something"],
        &["somethings"],
        &["something"],
        &["something"],
        &["sometime", "sometimes"],
        &["sometimes"],
        &["something"],
        &["something"],
        &["something"],
        &["sometimes"],
        &["sometimes"],
        &["sometimes"],
        &["something"],
        &["something"],
        &["something"],
        &["something"],
        &["somethings"],
        &["somewhere"],
        &["somewhere"],
        &["somehow"],
    ],
    range: 1..=8,
};

static WORD_SOMA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SOMA_CHILDREN),
    value: None,
};

pub static WORD_SOMA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ila"),
        dictgen::InsensitiveStr::Ascii("lija"),
    ],
    values: &[&["somalia"], &["somalia"]],
    range: 3..=4,
};

static WORD_SOL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SOL_CHILDREN),
    value: None,
};

pub static WORD_SOL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("armutx"),
        dictgen::InsensitiveStr::Ascii("ataire"),
        dictgen::InsensitiveStr::Ascii("atare"),
        dictgen::InsensitiveStr::Ascii("atary"),
        dictgen::InsensitiveStr::Ascii("ate"),
        dictgen::InsensitiveStr::Ascii("ated"),
        dictgen::InsensitiveStr::Ascii("ates"),
        dictgen::InsensitiveStr::Ascii("ating"),
        dictgen::InsensitiveStr::Ascii("deirs"),
        dictgen::InsensitiveStr::Ascii("dger"),
        dictgen::InsensitiveStr::Ascii("dgered"),
        dictgen::InsensitiveStr::Ascii("dgering"),
        dictgen::InsensitiveStr::Ascii("dgers"),
        dictgen::InsensitiveStr::Ascii("diarity"),
        dictgen::InsensitiveStr::Ascii("dies"),
        dictgen::InsensitiveStr::Ascii("dily"),
        dictgen::InsensitiveStr::Ascii("er"),
        dictgen::InsensitiveStr::Ascii("ey"),
        dictgen::InsensitiveStr::Ascii("f"),
        dictgen::InsensitiveStr::Ascii("fed"),
        dictgen::InsensitiveStr::Ascii("fer"),
        dictgen::InsensitiveStr::Ascii("fes"),
        dictgen::InsensitiveStr::Ascii("fing"),
        dictgen::InsensitiveStr::Ascii("fs"),
        dictgen::InsensitiveStr::Ascii("ger"),
        dictgen::InsensitiveStr::Ascii("gered"),
        dictgen::InsensitiveStr::Ascii("gering"),
        dictgen::InsensitiveStr::Ascii("gers"),
        dictgen::InsensitiveStr::Ascii("idairty"),
        dictgen::InsensitiveStr::Ascii("idariety"),
        dictgen::InsensitiveStr::Ascii("iders"),
        dictgen::InsensitiveStr::Ascii("iditary"),
        dictgen::InsensitiveStr::Ascii("ification"),
        dictgen::InsensitiveStr::Ascii("iliquy"),
        dictgen::InsensitiveStr::Ascii("itare"),
        dictgen::InsensitiveStr::Ascii("itudine"),
        dictgen::InsensitiveStr::Ascii("tion"),
        dictgen::InsensitiveStr::Ascii("tuion"),
        dictgen::InsensitiveStr::Ascii("tuions"),
        dictgen::InsensitiveStr::Ascii("uable"),
        dictgen::InsensitiveStr::Ascii("um"),
        dictgen::InsensitiveStr::Ascii("utide"),
        dictgen::InsensitiveStr::Ascii("utiin"),
        dictgen::InsensitiveStr::Ascii("uton"),
        dictgen::InsensitiveStr::Ascii("utons"),
        dictgen::InsensitiveStr::Ascii("veable"),
        dictgen::InsensitiveStr::Ascii("veing"),
        dictgen::InsensitiveStr::Ascii("wed"),
    ],
    values: &[
        &["solarmutex"],
        &["solitaire"],
        &["solitaire"],
        &["solitary"],
        &["isolate"],
        &["isolated"],
        &["isolates"],
        &["isolating"],
        &["soldiers"],
        &["soldier"],
        &["soldiered"],
        &["soldiering"],
        &["soldiers"],
        &["solidarity"],
        &["soldiers"],
        &["solidly"],
        &["solver", "solar", "solely"],
        &["solely"],
        &["solve", "sold"],
        &["solved"],
        &["solver", "solder"],
        &["solves"],
        &["solving"],
        &["solves"],
        &["soldier"],
        &["soldiered"],
        &["soldiering"],
        &["soldiers"],
        &["solidarity"],
        &["solidarity"],
        &["soldiers"],
        &["solidarity"],
        &["solidification"],
        &["soliloquy"],
        &["solitaire", "solitary"],
        &["solitude"],
        &["solution"],
        &["solution"],
        &["solutions"],
        &["soluble"],
        &["solemn"],
        &["solitude"],
        &["solution"],
        &["solution"],
        &["solutions"],
        &["solvable"],
        &["solving"],
        &["solved"],
    ],
    range: 1..=9,
};

static WORD_SOK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SOK_CHILDREN),
    value: None,
};

pub static WORD_SOK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("et"),
        dictgen::InsensitiveStr::Ascii("ets"),
    ],
    values: &[&["socket"], &["sockets"]],
    range: 2..=3,
};

static WORD_SOI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SOI_CHILDREN),
    value: None,
};

pub static WORD_SOI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("lders"),
        dictgen::InsensitiveStr::Ascii("ldly"),
        dictgen::InsensitiveStr::Ascii("urce"),
    ],
    values: &[&["soldiers"], &["solidly"], &["source"]],
    range: 4..=5,
};

static WORD_SOH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SOH_CHILDREN),
    value: None,
};

pub static WORD_SOH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("pisticated"),
        dictgen::InsensitiveStr::Ascii("pomore"),
        dictgen::InsensitiveStr::Ascii("w"),
    ],
    values: &[&["sophisticated"], &["sophomore"], &["show"]],
    range: 1..=10,
};

static WORD_SOF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SOF_CHILDREN),
    value: None,
};

pub static WORD_SOF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("isticated"),
        dictgen::InsensitiveStr::Ascii("lty"),
        dictgen::InsensitiveStr::Ascii("more"),
        dictgen::InsensitiveStr::Ascii("mores"),
        dictgen::InsensitiveStr::Ascii("omore"),
        dictgen::InsensitiveStr::Ascii("omores"),
        dictgen::InsensitiveStr::Ascii("tend"),
        dictgen::InsensitiveStr::Ascii("twade"),
        dictgen::InsensitiveStr::Ascii("twares"),
        dictgen::InsensitiveStr::Ascii("twre"),
        dictgen::InsensitiveStr::Ascii("ware"),
        dictgen::InsensitiveStr::Ascii("wtare"),
    ],
    values: &[
        &["sophisticated"],
        &["softly"],
        &["sophomore"],
        &["sophomores"],
        &["sophomore"],
        &["sophomores"],
        &["softened"],
        &["software"],
        &["software"],
        &["software"],
        &["software"],
        &["software"],
    ],
    range: 3..=9,
};

static WORD_SOE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SOE_CHILDREN),
    value: None,
};

pub static WORD_SOE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cialize"),
        dictgen::InsensitiveStr::Ascii("m"),
        dictgen::InsensitiveStr::Ascii("mthin"),
        dictgen::InsensitiveStr::Ascii("mthing"),
        dictgen::InsensitiveStr::Ascii("mthings"),
        dictgen::InsensitiveStr::Ascii("mwhere"),
    ],
    values: &[
        &["specialized"],
        &["some"],
        &["somethin"],
        &["something"],
        &["somethings"],
        &["somewhere"],
    ],
    range: 1..=7,
};

static WORD_SOD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SOD_CHILDREN),
    value: None,
};

pub static WORD_SOD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("der"),
        dictgen::InsensitiveStr::Ascii("dered"),
        dictgen::InsensitiveStr::Ascii("dering"),
        dictgen::InsensitiveStr::Ascii("ders"),
        dictgen::InsensitiveStr::Ascii("o"),
        dictgen::InsensitiveStr::Ascii("u"),
    ],
    values: &[
        &["solder"],
        &["soldered"],
        &["soldering"],
        &["solders"],
        &["dodo", "sod", "soda", "sods", "solo", "sudo"],
        &["sod", "soda", "sods", "sudo"],
    ],
    range: 1..=6,
};

static WORD_SOC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SOC_CHILDREN),
    value: None,
};

pub static WORD_SOC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ail"),
        dictgen::InsensitiveStr::Ascii("ailism"),
        dictgen::InsensitiveStr::Ascii("ailist"),
        dictgen::InsensitiveStr::Ascii("ailists"),
        dictgen::InsensitiveStr::Ascii("ailize"),
        dictgen::InsensitiveStr::Ascii("ailized"),
        dictgen::InsensitiveStr::Ascii("ailizing"),
        dictgen::InsensitiveStr::Ascii("ailly"),
        dictgen::InsensitiveStr::Ascii("alism"),
        dictgen::InsensitiveStr::Ascii("alist"),
        dictgen::InsensitiveStr::Ascii("alists"),
        dictgen::InsensitiveStr::Ascii("artes"),
        dictgen::InsensitiveStr::Ascii("eities"),
        dictgen::InsensitiveStr::Ascii("ekts"),
        dictgen::InsensitiveStr::Ascii("ialicing"),
        dictgen::InsensitiveStr::Ascii("ialim"),
        dictgen::InsensitiveStr::Ascii("ialini"),
        dictgen::InsensitiveStr::Ascii("ialisim"),
        dictgen::InsensitiveStr::Ascii("ialiss"),
        dictgen::InsensitiveStr::Ascii("ialistes"),
        dictgen::InsensitiveStr::Ascii("ialistisk"),
        dictgen::InsensitiveStr::Ascii("ialistos"),
        dictgen::InsensitiveStr::Ascii("ializare"),
        dictgen::InsensitiveStr::Ascii("ializng"),
        dictgen::InsensitiveStr::Ascii("ialogical"),
        dictgen::InsensitiveStr::Ascii("ialsim"),
        dictgen::InsensitiveStr::Ascii("ialsits"),
        dictgen::InsensitiveStr::Ascii("ialy"),
        dictgen::InsensitiveStr::Ascii("iapathic"),
        dictgen::InsensitiveStr::Ascii("iapaths"),
        dictgen::InsensitiveStr::Ascii("ieites"),
        dictgen::InsensitiveStr::Ascii("ilaism"),
        dictgen::InsensitiveStr::Ascii("ilaist"),
        dictgen::InsensitiveStr::Ascii("ilaists"),
        dictgen::InsensitiveStr::Ascii("ilaized"),
        dictgen::InsensitiveStr::Ascii("ioecenomic"),
        dictgen::InsensitiveStr::Ascii("ioecomonic"),
        dictgen::InsensitiveStr::Ascii("ioeconimc"),
        dictgen::InsensitiveStr::Ascii("ioeconimic"),
        dictgen::InsensitiveStr::Ascii("ioeconmic"),
        dictgen::InsensitiveStr::Ascii("ioligical"),
        dictgen::InsensitiveStr::Ascii("iologia"),
        dictgen::InsensitiveStr::Ascii("iologial"),
        dictgen::InsensitiveStr::Ascii("iopatas"),
        dictgen::InsensitiveStr::Ascii("iopatch"),
        dictgen::InsensitiveStr::Ascii("iopathes"),
        dictgen::InsensitiveStr::Ascii("iopathis"),
        dictgen::InsensitiveStr::Ascii("iopati"),
        dictgen::InsensitiveStr::Ascii("iopatic"),
        dictgen::InsensitiveStr::Ascii("iopats"),
        dictgen::InsensitiveStr::Ascii("iophatic"),
        dictgen::InsensitiveStr::Ascii("iopolical"),
        dictgen::InsensitiveStr::Ascii("ities"),
        dictgen::InsensitiveStr::Ascii("ratease"),
        dictgen::InsensitiveStr::Ascii("ratees"),
        dictgen::InsensitiveStr::Ascii("rateks"),
        dictgen::InsensitiveStr::Ascii("reboard"),
        dictgen::InsensitiveStr::Ascii("ript"),
        dictgen::InsensitiveStr::Ascii("ripted"),
        dictgen::InsensitiveStr::Ascii("ripting"),
        dictgen::InsensitiveStr::Ascii("ripts"),
        dictgen::InsensitiveStr::Ascii("ttish"),
    ],
    values: &[
        &["social"],
        &["socialism"],
        &["socialist"],
        &["socialists"],
        &["socialize"],
        &["socialized"],
        &["socializing"],
        &["socially"],
        &["socialism"],
        &["socialist"],
        &["socialists"],
        &["socrates"],
        &["societies"],
        &["sockets"],
        &["socializing"],
        &["socialism"],
        &["socializing"],
        &["socialism"],
        &["socialists"],
        &["socialists"],
        &["socialists"],
        &["socialists"],
        &["socialize"],
        &["socializing"],
        &["sociological"],
        &["socialism"],
        &["socialists"],
        &["socially"],
        &["sociopathic"],
        &["sociopaths"],
        &["societies"],
        &["socialism"],
        &["socialist"],
        &["socialists"],
        &["socialized"],
        &["socioeconomic"],
        &["socioeconomic"],
        &["socioeconomic"],
        &["socioeconomic"],
        &["socioeconomic"],
        &["sociological"],
        &["sociological"],
        &["sociological"],
        &["sociopaths"],
        &["sociopaths"],
        &["sociopaths"],
        &["sociopaths"],
        &["sociopathic"],
        &["sociopathic"],
        &["sociopaths"],
        &["sociopathic"],
        &["sociological"],
        &["societies"],
        &["socrates"],
        &["socrates"],
        &["socrates"],
        &["scoreboard"],
        &["script"],
        &["scripted"],
        &["scripting"],
        &["scripts"],
        &["scottish"],
    ],
    range: 3..=10,
};

static WORD_SOB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SOB_CHILDREN),
    value: None,
};

pub static WORD_SOB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("erity"),
        dictgen::InsensitiveStr::Ascii("reity"),
    ],
    values: &[&["sobriety"], &["sobriety"]],
    range: 5..=5,
};

static WORD_SOA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SOA_CHILDREN),
    value: None,
};

pub static WORD_SOA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("lris")],
    values: &[&["solaris"]],
    range: 4..=4,
};

static WORD_SN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SN_CHILDREN),
    value: None,
};

pub static WORD_SN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("adler"),
        dictgen::InsensitiveStr::Ascii("adstorm"),
        dictgen::InsensitiveStr::Ascii("adwiches"),
        dictgen::InsensitiveStr::Ascii("aped"),
        dictgen::InsensitiveStr::Ascii("aphot"),
        dictgen::InsensitiveStr::Ascii("aphsot"),
        dictgen::InsensitiveStr::Ascii("aping"),
        dictgen::InsensitiveStr::Ascii("appng"),
        dictgen::InsensitiveStr::Ascii("apsnot"),
        dictgen::InsensitiveStr::Ascii("apsnots"),
        dictgen::InsensitiveStr::Ascii("eeks"),
        dictgen::InsensitiveStr::Ascii("ese"),
        dictgen::InsensitiveStr::Ascii("etries"),
        dictgen::InsensitiveStr::Ascii("igles"),
        dictgen::InsensitiveStr::Ascii("ipet"),
        dictgen::InsensitiveStr::Ascii("ipets"),
        dictgen::InsensitiveStr::Ascii("ippent"),
        dictgen::InsensitiveStr::Ascii("ippert"),
        dictgen::InsensitiveStr::Ascii("ippes"),
        dictgen::InsensitiveStr::Ascii("ippests"),
        dictgen::InsensitiveStr::Ascii("ippetts"),
        dictgen::InsensitiveStr::Ascii("odwen"),
        dictgen::InsensitiveStr::Ascii("owbaling"),
        dictgen::InsensitiveStr::Ascii("owballes"),
        dictgen::InsensitiveStr::Ascii("owballling"),
        dictgen::InsensitiveStr::Ascii("owballls"),
        dictgen::InsensitiveStr::Ascii("owbals"),
        dictgen::InsensitiveStr::Ascii("owbaording"),
        dictgen::InsensitiveStr::Ascii("owboaring"),
        dictgen::InsensitiveStr::Ascii("owbolling"),
        dictgen::InsensitiveStr::Ascii("owfalke"),
        dictgen::InsensitiveStr::Ascii("owfalling"),
        dictgen::InsensitiveStr::Ascii("owflaek"),
        dictgen::InsensitiveStr::Ascii("owlfake"),
        dictgen::InsensitiveStr::Ascii("pashot"),
        dictgen::InsensitiveStr::Ascii("pashots"),
        dictgen::InsensitiveStr::Ascii("ugglie"),
        dictgen::InsensitiveStr::Ascii("woballs"),
        dictgen::InsensitiveStr::Ascii("woden"),
        dictgen::InsensitiveStr::Ascii("yc"),
        dictgen::InsensitiveStr::Ascii("ycing"),
        dictgen::InsensitiveStr::Ascii("ydrome"),
        dictgen::InsensitiveStr::Ascii("yergy"),
        dictgen::InsensitiveStr::Ascii("yopsis"),
        dictgen::InsensitiveStr::Ascii("ytax"),
        dictgen::InsensitiveStr::Ascii("ythesis"),
        dictgen::InsensitiveStr::Ascii("ythetic"),
    ],
    values: &[
        &["sandler"],
        &["sandstorm"],
        &["sandwiches"],
        &["snapped"],
        &["snapshot"],
        &["snapshot"],
        &["snapping"],
        &["snapping"],
        &["snapshot"],
        &["snapshots"],
        &["sneaks"],
        &["sneeze"],
        &["sentries"],
        &["singles"],
        &["snippet"],
        &["snippets"],
        &["snippet"],
        &["snippet"],
        &["snippets"],
        &["snippets"],
        &["snippets"],
        &["snowden"],
        &["snowballing"],
        &["snowballs"],
        &["snowballing"],
        &["snowballs"],
        &["snowballs"],
        &["snowboarding"],
        &["snowboarding"],
        &["snowballing"],
        &["snowflake"],
        &["snowballing"],
        &["snowflake"],
        &["snowflake"],
        &["snapshot"],
        &["snapshots"],
        &["snuggle"],
        &["snowballs"],
        &["snowden"],
        &["sync"],
        &["syncing"],
        &["syndrome"],
        &["synergy"],
        &["synopsis"],
        &["syntax"],
        &["synthesis"],
        &["synthetic"],
    ],
    range: 2..=10,
};

static WORD_SM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SM_CHILDREN),
    value: None,
};

pub static WORD_SM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ackdwon"),
        dictgen::InsensitiveStr::Ascii("ae"),
        dictgen::InsensitiveStr::Ascii("al"),
        dictgen::InsensitiveStr::Ascii("aler"),
        dictgen::InsensitiveStr::Ascii("allar"),
        dictgen::InsensitiveStr::Ascii("alles"),
        dictgen::InsensitiveStr::Ascii("aple"),
        dictgen::InsensitiveStr::Ascii("apled"),
        dictgen::InsensitiveStr::Ascii("aples"),
        dictgen::InsensitiveStr::Ascii("apling"),
        dictgen::InsensitiveStr::Ascii("arpthone"),
        dictgen::InsensitiveStr::Ascii("artare"),
        dictgen::InsensitiveStr::Ascii("arthpone"),
        dictgen::InsensitiveStr::Ascii("arthpones"),
        dictgen::InsensitiveStr::Ascii("artre"),
        dictgen::InsensitiveStr::Ascii("aurai"),
        dictgen::InsensitiveStr::Ascii("ealting"),
        dictgen::InsensitiveStr::Ascii("eesters"),
        dictgen::InsensitiveStr::Ascii("ehow"),
        dictgen::InsensitiveStr::Ascii("ething"),
        dictgen::InsensitiveStr::Ascii("ll"),
        dictgen::InsensitiveStr::Ascii("ller"),
        dictgen::InsensitiveStr::Ascii("oe"),
        dictgen::InsensitiveStr::Ascii("oot"),
        dictgen::InsensitiveStr::Ascii("ooter"),
        dictgen::InsensitiveStr::Ascii("oothign"),
        dictgen::InsensitiveStr::Ascii("ooting"),
        dictgen::InsensitiveStr::Ascii("outh"),
        dictgen::InsensitiveStr::Ascii("outhness"),
        dictgen::InsensitiveStr::Ascii("ove"),
        dictgen::InsensitiveStr::Ascii("pt"),
    ],
    values: &[
        &["smackdown"],
        &["same"],
        &["small"],
        &["smaller"],
        &["smaller"],
        &["smallest"],
        &["sample"],
        &["sampled"],
        &["samples"],
        &["sampling"],
        &["smartphones"],
        &["smarter"],
        &["smartphone"],
        &["smartphones"],
        &["smarter"],
        &["samurai"],
        &["smelting"],
        &["semesters"],
        &["somehow"],
        &["something"],
        &["small", "smell"],
        &["smaller"],
        &["some"],
        &["smooth"],
        &["smoother"],
        &["smoothing"],
        &["smoothing"],
        &["smooth"],
        &["smoothness"],
        &["move"],
        &["smtp", "smtpe"],
    ],
    range: 2..=9,
};

static WORD_SL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_SL_CHILDREN),
    value: None,
};

static WORD_SL_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_SLA_NODE),
    None,
    Some(&WORD_SLC_NODE),
    Some(&WORD_SLD_NODE),
    Some(&WORD_SLE_NODE),
    None,
    None,
    None,
    Some(&WORD_SLI_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_SLO_NODE),
    None,
    Some(&WORD_SLQ_NODE),
    None,
    None,
    None,
    Some(&WORD_SLU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_SLU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SLU_CHILDREN),
    value: None,
};

pub static WORD_SLU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aghter"),
        dictgen::InsensitiveStr::Ascii("aghtered"),
        dictgen::InsensitiveStr::Ascii("aghtering"),
        dictgen::InsensitiveStr::Ascii("ggify"),
    ],
    values: &[
        &["slaughter"],
        &["slaughtered"],
        &["slaughtering"],
        &["slugify"],
    ],
    range: 5..=9,
};

static WORD_SLQ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SLQ_CHILDREN),
    value: Some(&["sql"]),
};

pub static WORD_SLQ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[],
    values: &[],
    range: 0..=0,
};

static WORD_SLO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SLO_CHILDREN),
    value: None,
};

pub static WORD_SLO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("oth"),
        dictgen::InsensitiveStr::Ascii("othed"),
        dictgen::InsensitiveStr::Ascii("othing"),
        dictgen::InsensitiveStr::Ascii("oths"),
        dictgen::InsensitiveStr::Ascii("table"),
        dictgen::InsensitiveStr::Ascii("ughtering"),
        dictgen::InsensitiveStr::Ascii("wy"),
    ],
    values: &[
        &["sleuth", "sloth", "sooth"],
        &["sleuthing"],
        &["sleuthing"],
        &["sleuths"],
        &["slottable"],
        &["slaughtering"],
        &["slowly"],
    ],
    range: 2..=9,
};

static WORD_SLI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SLI_CHILDREN),
    value: None,
};

pub static WORD_SLI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cable"),
        dictgen::InsensitiveStr::Ascii("enced"),
        dictgen::InsensitiveStr::Ascii("ent"),
        dictgen::InsensitiveStr::Ascii("ently"),
        dictgen::InsensitiveStr::Ascii("ghlty"),
        dictgen::InsensitiveStr::Ascii("ghly"),
        dictgen::InsensitiveStr::Ascii("ghtl"),
        dictgen::InsensitiveStr::Ascii("ghty"),
        dictgen::InsensitiveStr::Ascii("gnt"),
        dictgen::InsensitiveStr::Ascii("gntly"),
        dictgen::InsensitiveStr::Ascii("gth"),
        dictgen::InsensitiveStr::Ascii("gthly"),
        dictgen::InsensitiveStr::Ascii("gtly"),
        dictgen::InsensitiveStr::Ascii("ped"),
        dictgen::InsensitiveStr::Ascii("pperies"),
        dictgen::InsensitiveStr::Ascii("pperly"),
        dictgen::InsensitiveStr::Ascii("ppes"),
        dictgen::InsensitiveStr::Ascii("ppey"),
        dictgen::InsensitiveStr::Ascii("seshow"),
        dictgen::InsensitiveStr::Ascii("te"),
    ],
    values: &[
        &["sliceable"],
        &["silenced"],
        &["silent"],
        &["silently"],
        &["slightly"],
        &["slightly"],
        &["slightly"],
        &["slightly"],
        &["slight"],
        &["slightly"],
        &["slight"],
        &["slightly"],
        &["slightly"],
        &["slipped"],
        &["slippers"],
        &["slippery"],
        &["slippers"],
        &["slippery"],
        &["slideshow"],
        &["elite", "site", "sleight", "slide"],
    ],
    range: 2..=7,
};

static WORD_SLE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SLE_CHILDREN),
    value: None,
};

pub static WORD_SLE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ct"),
        dictgen::InsensitiveStr::Ascii("cted"),
        dictgen::InsensitiveStr::Ascii("cting"),
        dictgen::InsensitiveStr::Ascii("ction"),
        dictgen::InsensitiveStr::Ascii("ect"),
        dictgen::InsensitiveStr::Ascii("eped"),
        dictgen::InsensitiveStr::Ascii("epp"),
        dictgen::InsensitiveStr::Ascii("fies"),
        dictgen::InsensitiveStr::Ascii("fishness"),
        dictgen::InsensitiveStr::Ascii("wth"),
        dictgen::InsensitiveStr::Ascii("wthed"),
        dictgen::InsensitiveStr::Ascii("wthing"),
        dictgen::InsensitiveStr::Ascii("wths"),
    ],
    values: &[
        &["select"],
        &["selected"],
        &["selecting"],
        &["selection"],
        &["select"],
        &["slept"],
        &["sleep"],
        &["selfies"],
        &["selfishness"],
        &["sleuth"],
        &["sleuthed"],
        &["sleuthing"],
        &["sleuths"],
    ],
    range: 2..=8,
};

static WORD_SLD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SLD_CHILDREN),
    value: None,
};

pub static WORD_SLD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("iers")],
    values: &[&["sliders"]],
    range: 4..=4,
};

static WORD_SLC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SLC_CHILDREN),
    value: None,
};

pub static WORD_SLC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ies")],
    values: &[&["slices"]],
    range: 3..=3,
};

static WORD_SLA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SLA_CHILDREN),
    value: None,
};

pub static WORD_SLA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("c"),
        dictgen::InsensitiveStr::Ascii("ch"),
        dictgen::InsensitiveStr::Ascii("ches"),
        dictgen::InsensitiveStr::Ascii("nguage"),
        dictgen::InsensitiveStr::Ascii("nguages"),
        dictgen::InsensitiveStr::Ascii("ptoon"),
        dictgen::InsensitiveStr::Ascii("se"),
        dictgen::InsensitiveStr::Ascii("ses"),
        dictgen::InsensitiveStr::Ascii("shs"),
        dictgen::InsensitiveStr::Ascii("ughted"),
        dictgen::InsensitiveStr::Ascii("ughterd"),
        dictgen::InsensitiveStr::Ascii("ugterhouses"),
        dictgen::InsensitiveStr::Ascii("ugther"),
        dictgen::InsensitiveStr::Ascii("ugthered"),
        dictgen::InsensitiveStr::Ascii("ugthering"),
        dictgen::InsensitiveStr::Ascii("vage"),
        dictgen::InsensitiveStr::Ascii("verly"),
        dictgen::InsensitiveStr::Ascii("yign"),
    ],
    values: &[
        &["slack"],
        &["slash"],
        &["slashes"],
        &["language"],
        &["languages"],
        &["splatoon"],
        &["slash"],
        &["slashes"],
        &["slashes"],
        &["slaughtered"],
        &["slaughtered"],
        &["slaughterhouses"],
        &["slaughter"],
        &["slaughtered"],
        &["slaughtering"],
        &["salvage"],
        &["slavery"],
        &["slaying"],
    ],
    range: 1..=11,
};

static WORD_SK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_SK_CHILDREN),
    value: None,
};

static WORD_SK_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_SKA_NODE),
    None,
    None,
    None,
    Some(&WORD_SKE_NODE),
    None,
    None,
    None,
    Some(&WORD_SKI_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_SKO_NODE),
    Some(&WORD_SKP_NODE),
    None,
    Some(&WORD_SKR_NODE),
    None,
    Some(&WORD_SKT_NODE),
    Some(&WORD_SKU_NODE),
    None,
    Some(&WORD_SKW_NODE),
    None,
    Some(&WORD_SKY_NODE),
    None,
];

static WORD_SKY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SKY_CHILDREN),
    value: None,
};

pub static WORD_SKY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("p"),
        dictgen::InsensitiveStr::Ascii("walkr"),
    ],
    values: &[&["skip", "skype"], &["skywalker"]],
    range: 1..=5,
};

static WORD_SKW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SKW_CHILDREN),
    value: None,
};

pub static WORD_SKW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("alk"),
        dictgen::InsensitiveStr::Ascii("alked"),
        dictgen::InsensitiveStr::Ascii("alking"),
        dictgen::InsensitiveStr::Ascii("alks"),
        dictgen::InsensitiveStr::Ascii("yard"),
    ],
    values: &[
        &["squawk"],
        &["squawked"],
        &["squawking"],
        &["squawks"],
        &["skyward"],
    ],
    range: 3..=6,
};

static WORD_SKU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SKU_CHILDREN),
    value: None,
};

pub static WORD_SKU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("rge"),
        dictgen::InsensitiveStr::Ascii("rged"),
        dictgen::InsensitiveStr::Ascii("rges"),
        dictgen::InsensitiveStr::Ascii("rging"),
    ],
    values: &[&["scourge"], &["scourged"], &["scourges"], &["scourging"]],
    range: 3..=5,
};

static WORD_SKT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SKT_CHILDREN),
    value: None,
};

pub static WORD_SKT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eches"),
        dictgen::InsensitiveStr::Ascii("echy"),
    ],
    values: &[&["sketches"], &["sketchy"]],
    range: 4..=5,
};

static WORD_SKR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SKR_CHILDREN),
    value: None,
};

pub static WORD_SKR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("awberries"),
        dictgen::InsensitiveStr::Ascii("imish"),
    ],
    values: &[&["strawberries"], &["skirmish"]],
    range: 5..=9,
};

static WORD_SKP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SKP_CHILDREN),
    value: None,
};

pub static WORD_SKP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("etic"),
        dictgen::InsensitiveStr::Ascii("eticism"),
        dictgen::InsensitiveStr::Ascii("etics"),
    ],
    values: &[&["skeptic"], &["skepticism"], &["skeptics"]],
    range: 4..=7,
};

static WORD_SKO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SKO_CHILDREN),
    value: None,
};

pub static WORD_SKO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ol"),
        dictgen::InsensitiveStr::Ascii("oled"),
        dictgen::InsensitiveStr::Ascii("oling"),
        dictgen::InsensitiveStr::Ascii("ols"),
        dictgen::InsensitiveStr::Ascii("pped"),
    ],
    values: &[
        &["school"],
        &["schooled"],
        &["schooling"],
        &["schools"],
        &["shopped", "skipped", "slopped", "stopped"],
    ],
    range: 2..=5,
};

static WORD_SKI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SKI_CHILDREN),
    value: None,
};

pub static WORD_SKI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("lfull"),
        dictgen::InsensitiveStr::Ascii("llfull"),
        dictgen::InsensitiveStr::Ascii("llfullness"),
        dictgen::InsensitiveStr::Ascii("llhosts"),
        dictgen::InsensitiveStr::Ascii("llshits"),
        dictgen::InsensitiveStr::Ascii("llshoot"),
        dictgen::InsensitiveStr::Ascii("llshoots"),
        dictgen::InsensitiveStr::Ascii("llshosts"),
        dictgen::InsensitiveStr::Ascii("llslots"),
        dictgen::InsensitiveStr::Ascii("llsofts"),
        dictgen::InsensitiveStr::Ascii("llsshot"),
        dictgen::InsensitiveStr::Ascii("llsto"),
        dictgen::InsensitiveStr::Ascii("mrish"),
        dictgen::InsensitiveStr::Ascii("pd"),
        dictgen::InsensitiveStr::Ascii("pe"),
        dictgen::InsensitiveStr::Ascii("ped"),
        dictgen::InsensitiveStr::Ascii("ping"),
        dictgen::InsensitiveStr::Ascii("pp"),
        dictgen::InsensitiveStr::Ascii("ppd"),
        dictgen::InsensitiveStr::Ascii("ppped"),
        dictgen::InsensitiveStr::Ascii("ppps"),
        dictgen::InsensitiveStr::Ascii("pt"),
        dictgen::InsensitiveStr::Ascii("rmiches"),
        dictgen::InsensitiveStr::Ascii("tsofrinic"),
        dictgen::InsensitiveStr::Ascii("tsofrinics"),
    ],
    values: &[
        &["skilful"],
        &["skillful", "skillfully"],
        &["skillfulness"],
        &["skillshots"],
        &["skillshots"],
        &["skillshots"],
        &["skillshots"],
        &["skillshots"],
        &["skillshots"],
        &["skillshots"],
        &["skillshots"],
        &["skillshots"],
        &["skirmish"],
        &["skipped"],
        &["skip"],
        &["skipped", "skyped"],
        &["skipping"],
        &["skip", "skipped"],
        &["skipped"],
        &["skipped"],
        &["skips"],
        &["skip", "skype", "skipped"],
        &["skirmish"],
        &["schizophrenic"],
        &["schizophrenics"],
    ],
    range: 2..=10,
};

static WORD_SKE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SKE_CHILDREN),
    value: None,
};

pub static WORD_SKE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cth"),
        dictgen::InsensitiveStr::Ascii("cthes"),
        dictgen::InsensitiveStr::Ascii("cthy"),
        dictgen::InsensitiveStr::Ascii("ep"),
        dictgen::InsensitiveStr::Ascii("latel"),
        dictgen::InsensitiveStr::Ascii("letaal"),
        dictgen::InsensitiveStr::Ascii("letl"),
        dictgen::InsensitiveStr::Ascii("letones"),
        dictgen::InsensitiveStr::Ascii("letos"),
        dictgen::InsensitiveStr::Ascii("lton"),
        dictgen::InsensitiveStr::Ascii("pitcal"),
        dictgen::InsensitiveStr::Ascii("pt"),
        dictgen::InsensitiveStr::Ascii("ptecism"),
        dictgen::InsensitiveStr::Ascii("pticals"),
        dictgen::InsensitiveStr::Ascii("pticim"),
        dictgen::InsensitiveStr::Ascii("pticisim"),
        dictgen::InsensitiveStr::Ascii("pticles"),
        dictgen::InsensitiveStr::Ascii("pticons"),
        dictgen::InsensitiveStr::Ascii("ptis"),
        dictgen::InsensitiveStr::Ascii("ptisicm"),
        dictgen::InsensitiveStr::Ascii("ptisism"),
        dictgen::InsensitiveStr::Ascii("tchey"),
        dictgen::InsensitiveStr::Ascii("tchs"),
        dictgen::InsensitiveStr::Ascii("tchysex"),
        dictgen::InsensitiveStr::Ascii("tck"),
        dictgen::InsensitiveStr::Ascii("tcked"),
        dictgen::InsensitiveStr::Ascii("tckes"),
        dictgen::InsensitiveStr::Ascii("tcking"),
        dictgen::InsensitiveStr::Ascii("tpic"),
        dictgen::InsensitiveStr::Ascii("tpical"),
        dictgen::InsensitiveStr::Ascii("tpicism"),
        dictgen::InsensitiveStr::Ascii("tpics"),
    ],
    values: &[
        &["sketch"],
        &["sketches"],
        &["sketchy"],
        &["skip"],
        &["skeletal"],
        &["skeletal"],
        &["skeletal"],
        &["skeletons"],
        &["skeletons"],
        &["skeleton"],
        &["skeptical"],
        &["skipped"],
        &["skepticism"],
        &["skeptics"],
        &["skepticism"],
        &["skepticism"],
        &["skeptics"],
        &["skeptics"],
        &["skeptics"],
        &["skepticism"],
        &["skepticism"],
        &["sketchy"],
        &["sketches"],
        &["sketches"],
        &["skate", "sketch"],
        &["skated", "sketched"],
        &["skates", "sketches"],
        &["skating", "sketching"],
        &["skeptic"],
        &["skeptical"],
        &["skepticism"],
        &["skeptics"],
    ],
    range: 2..=8,
};

static WORD_SKA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SKA_CHILDREN),
    value: None,
};

pub static WORD_SKA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("gerak"),
        dictgen::InsensitiveStr::Ascii("lar"),
        dictgen::InsensitiveStr::Ascii("ndinavian"),
        dictgen::InsensitiveStr::Ascii("tebaord"),
        dictgen::InsensitiveStr::Ascii("tebaording"),
        dictgen::InsensitiveStr::Ascii("tebaords"),
        dictgen::InsensitiveStr::Ascii("teboad"),
        dictgen::InsensitiveStr::Ascii("teboader"),
        dictgen::InsensitiveStr::Ascii("teboaring"),
        dictgen::InsensitiveStr::Ascii("teborad"),
        dictgen::InsensitiveStr::Ascii("teborading"),
        dictgen::InsensitiveStr::Ascii("tebored"),
        dictgen::InsensitiveStr::Ascii("tebrand"),
        dictgen::InsensitiveStr::Ascii("teing"),
    ],
    values: &[
        &["skagerrak"],
        &["scalar"],
        &["scandinavian"],
        &["skateboard"],
        &["skateboarding"],
        &["skateboard"],
        &["skateboard"],
        &["skateboard"],
        &["skateboarding"],
        &["skateboard"],
        &["skateboarding"],
        &["skateboard"],
        &["skateboard"],
        &["skating"],
    ],
    range: 3..=10,
};

static WORD_SI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_SI_CHILDREN),
    value: None,
};

static WORD_SI_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    Some(&WORD_SIB_NODE),
    Some(&WORD_SIC_NODE),
    Some(&WORD_SID_NODE),
    Some(&WORD_SIE_NODE),
    Some(&WORD_SIF_NODE),
    Some(&WORD_SIG_NODE),
    Some(&WORD_SIH_NODE),
    None,
    None,
    None,
    Some(&WORD_SIL_NODE),
    Some(&WORD_SIM_NODE),
    Some(&WORD_SIN_NODE),
    Some(&WORD_SIO_NODE),
    Some(&WORD_SIP_NODE),
    None,
    Some(&WORD_SIR_NODE),
    Some(&WORD_SIS_NODE),
    Some(&WORD_SIT_NODE),
    Some(&WORD_SIU_NODE),
    Some(&WORD_SIV_NODE),
    Some(&WORD_SIW_NODE),
    Some(&WORD_SIX_NODE),
    None,
    Some(&WORD_SIZ_NODE),
];

static WORD_SIZ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SIZ_CHILDREN),
    value: Some(&["six", "size"]),
};

pub static WORD_SIZ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ebale"),
        dictgen::InsensitiveStr::Ascii("eble"),
        dictgen::InsensitiveStr::Ascii("emologist"),
        dictgen::InsensitiveStr::Ascii("emologists"),
        dictgen::InsensitiveStr::Ascii("emologogical"),
        dictgen::InsensitiveStr::Ascii("emologogically"),
        dictgen::InsensitiveStr::Ascii("emology"),
        dictgen::InsensitiveStr::Ascii("or"),
        dictgen::InsensitiveStr::Ascii("ors"),
        dictgen::InsensitiveStr::Ascii("re"),
    ],
    values: &[
        &["sizeable"],
        &["sizable", "sizeable"],
        &["seismologist"],
        &["seismologists"],
        &["seismological"],
        &["seismologically"],
        &["seismology"],
        &["scissor", "sizer"],
        &["scissors", "sizers"],
        &["size"],
    ],
    range: 2..=14,
};

static WORD_SIX_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SIX_CHILDREN),
    value: None,
};

pub static WORD_SIX_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("tin")],
    values: &[&["sistine", "sixteen"]],
    range: 3..=3,
};

static WORD_SIW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SIW_CHILDREN),
    value: None,
};

pub static WORD_SIW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("tch"),
        dictgen::InsensitiveStr::Ascii("tched"),
        dictgen::InsensitiveStr::Ascii("tching"),
    ],
    values: &[&["switch"], &["switched"], &["switching"]],
    range: 3..=6,
};

static WORD_SIV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SIV_CHILDREN),
    value: None,
};

pub static WORD_SIV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("er"),
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("ible"),
        dictgen::InsensitiveStr::Ascii("ing"),
    ],
    values: &[
        &["save", "sieve"],
        &["saved", "sieved"],
        &["diver", "silver", "sliver"],
        &["saves", "sieves"],
        &["visible"],
        &["saving", "sieving"],
    ],
    range: 1..=4,
};

static WORD_SIU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SIU_CHILDREN),
    value: None,
};

pub static WORD_SIU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("table"),
        dictgen::InsensitiveStr::Ascii("tational"),
        dictgen::InsensitiveStr::Ascii("te"),
    ],
    values: &[&["suitable"], &["situational"], &["suite"]],
    range: 2..=8,
};

static WORD_SIT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SIT_CHILDREN),
    value: None,
};

pub static WORD_SIT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ation"),
        dictgen::InsensitiveStr::Ascii("ations"),
        dictgen::InsensitiveStr::Ascii("aution"),
        dictgen::InsensitiveStr::Ascii("autional"),
        dictgen::InsensitiveStr::Ascii("autions"),
        dictgen::InsensitiveStr::Ascii("ck"),
        dictgen::InsensitiveStr::Ascii("ckers"),
        dictgen::InsensitiveStr::Ascii("eu"),
        dictgen::InsensitiveStr::Ascii("ill"),
        dictgen::InsensitiveStr::Ascii("irring"),
        dictgen::InsensitiveStr::Ascii("irs"),
        dictgen::InsensitiveStr::Ascii("l"),
        dictgen::InsensitiveStr::Ascii("ll"),
        dictgen::InsensitiveStr::Ascii("muli"),
        dictgen::InsensitiveStr::Ascii("rring"),
        dictgen::InsensitiveStr::Ascii("uacional"),
        dictgen::InsensitiveStr::Ascii("uaion"),
        dictgen::InsensitiveStr::Ascii("uaions"),
        dictgen::InsensitiveStr::Ascii("uatinal"),
        dictgen::InsensitiveStr::Ascii("uationals"),
        dictgen::InsensitiveStr::Ascii("uationly"),
        dictgen::InsensitiveStr::Ascii("uationnal"),
        dictgen::InsensitiveStr::Ascii("uatuion"),
        dictgen::InsensitiveStr::Ascii("uatuions"),
        dictgen::InsensitiveStr::Ascii("uatution"),
        dictgen::InsensitiveStr::Ascii("uatutions"),
        dictgen::InsensitiveStr::Ascii("ubbornness"),
        dictgen::InsensitiveStr::Ascii("udio"),
        dictgen::InsensitiveStr::Ascii("udios"),
        dictgen::InsensitiveStr::Ascii("uration"),
        dictgen::InsensitiveStr::Ascii("urations"),
        dictgen::InsensitiveStr::Ascii("utaion"),
        dictgen::InsensitiveStr::Ascii("utaions"),
        dictgen::InsensitiveStr::Ascii("utation"),
        dictgen::InsensitiveStr::Ascii("utations"),
    ],
    values: &[
        &["situation"],
        &["situations"],
        &["situation"],
        &["situational"],
        &["situations"],
        &["stick"],
        &["stickers"],
        &["site"],
        &["still"],
        &["stirring"],
        &["stirs"],
        &["still"],
        &["still"],
        &["stimuli"],
        &["stirring"],
        &["situational"],
        &["situation"],
        &["situations"],
        &["situational"],
        &["situations", "situational"],
        &["situational", "situationally"],
        &["situational"],
        &["situation"],
        &["situations"],
        &["situation"],
        &["situations"],
        &["stubbornness"],
        &["studio"],
        &["studios"],
        &["situation"],
        &["situations"],
        &["situation"],
        &["situations"],
        &["situation"],
        &["situations"],
    ],
    range: 1..=10,
};

static WORD_SIS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SIS_CHILDREN),
    value: None,
};

pub static WORD_SIS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("nce"),
        dictgen::InsensitiveStr::Ascii("ser"),
        dictgen::InsensitiveStr::Ascii("sered"),
        dictgen::InsensitiveStr::Ascii("sering"),
        dictgen::InsensitiveStr::Ascii("sers"),
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("tem"),
        dictgen::InsensitiveStr::Ascii("tematically"),
        dictgen::InsensitiveStr::Ascii("tematics"),
        dictgen::InsensitiveStr::Ascii("tematies"),
        dictgen::InsensitiveStr::Ascii("tematising"),
        dictgen::InsensitiveStr::Ascii("tematizing"),
        dictgen::InsensitiveStr::Ascii("tematy"),
        dictgen::InsensitiveStr::Ascii("temed"),
        dictgen::InsensitiveStr::Ascii("temic"),
        dictgen::InsensitiveStr::Ascii("temically"),
        dictgen::InsensitiveStr::Ascii("temics"),
        dictgen::InsensitiveStr::Ascii("teming"),
        dictgen::InsensitiveStr::Ascii("temist"),
        dictgen::InsensitiveStr::Ascii("temists"),
        dictgen::InsensitiveStr::Ascii("temize"),
        dictgen::InsensitiveStr::Ascii("temized"),
        dictgen::InsensitiveStr::Ascii("temizes"),
        dictgen::InsensitiveStr::Ascii("temizing"),
        dictgen::InsensitiveStr::Ascii("tems"),
        dictgen::InsensitiveStr::Ascii("ts"),
    ],
    values: &[
        &["size", "sisal"],
        &["since"],
        &["scissor", "sissier", "sister"],
        &["scissored"],
        &["scissoring"],
        &["scissors", "sisters"],
        &["cyst", "sift", "sits"],
        &["system"],
        &["systematically"],
        &["systematics"],
        &["systematies"],
        &["systematising"],
        &["systematizing"],
        &["systematy"],
        &["systemed"],
        &["systemic"],
        &["systemically"],
        &["systemics"],
        &["systemic", "stemming"],
        &["systemist"],
        &["systemists"],
        &["systemize"],
        &["systemized"],
        &["systemizes"],
        &["systemizing"],
        &["systems"],
        &["cysts", "sifts", "sits"],
    ],
    range: 1..=11,
};

static WORD_SIR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SIR_CHILDREN),
    value: None,
};

pub static WORD_SIR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cle"),
        dictgen::InsensitiveStr::Ascii("cles"),
        dictgen::InsensitiveStr::Ascii("cular"),
        dictgen::InsensitiveStr::Ascii("ect"),
        dictgen::InsensitiveStr::Ascii("ected"),
        dictgen::InsensitiveStr::Ascii("ecting"),
        dictgen::InsensitiveStr::Ascii("ection"),
        dictgen::InsensitiveStr::Ascii("ectional"),
        dictgen::InsensitiveStr::Ascii("ectionalities"),
        dictgen::InsensitiveStr::Ascii("ectionality"),
        dictgen::InsensitiveStr::Ascii("ectionals"),
        dictgen::InsensitiveStr::Ascii("ectionless"),
        dictgen::InsensitiveStr::Ascii("ections"),
        dictgen::InsensitiveStr::Ascii("ective"),
        dictgen::InsensitiveStr::Ascii("ectives"),
        dictgen::InsensitiveStr::Ascii("ectly"),
        dictgen::InsensitiveStr::Ascii("ectness"),
        dictgen::InsensitiveStr::Ascii("ector"),
        dictgen::InsensitiveStr::Ascii("ectories"),
        dictgen::InsensitiveStr::Ascii("ectors"),
        dictgen::InsensitiveStr::Ascii("ectory"),
        dictgen::InsensitiveStr::Ascii("ects"),
        dictgen::InsensitiveStr::Ascii("inge"),
        dictgen::InsensitiveStr::Ascii("inges"),
        dictgen::InsensitiveStr::Ascii("vayl"),
        dictgen::InsensitiveStr::Ascii("vayled"),
        dictgen::InsensitiveStr::Ascii("vaylence"),
        dictgen::InsensitiveStr::Ascii("vayles"),
        dictgen::InsensitiveStr::Ascii("vayling"),
        dictgen::InsensitiveStr::Ascii("vayls"),
        dictgen::InsensitiveStr::Ascii("ynge"),
        dictgen::InsensitiveStr::Ascii("ynges"),
    ],
    values: &[
        &["circle"],
        &["circles"],
        &["circular"],
        &["direct"],
        &["directed"],
        &["directing"],
        &["direction"],
        &["directional"],
        &["directionalities"],
        &["directionality"],
        &["directionals"],
        &["directionless"],
        &["directions"],
        &["directive"],
        &["directives"],
        &["directly"],
        &["directness"],
        &["director"],
        &["directories"],
        &["directors"],
        &["directory"],
        &["directs"],
        &["syringe"],
        &["syringes"],
        &["surveil"],
        &["surveiled"],
        &["surveillance"],
        &["surveils"],
        &["surveiling"],
        &["surveils"],
        &["syringe"],
        &["syringes"],
    ],
    range: 3..=13,
};

static WORD_SIP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SIP_CHILDREN),
    value: None,
};

pub static WORD_SIP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ly")],
    values: &[&["simply"]],
    range: 2..=2,
};

static WORD_SIO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SIO_CHILDREN),
    value: None,
};

pub static WORD_SIO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("nist"),
        dictgen::InsensitiveStr::Ascii("nists"),
    ],
    values: &[&["zionist"], &["zionists"]],
    range: 4..=5,
};

static WORD_SIN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_SIN_CHILDREN),
    value: None,
};

static WORD_SIN_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_SINA_NODE),
    None,
    Some(&WORD_SINC_NODE),
    None,
    None,
    None,
    Some(&WORD_SING_NODE),
    None,
    Some(&WORD_SINI_NODE),
    None,
    None,
    Some(&WORD_SINL_NODE),
    None,
    Some(&WORD_SINN_NODE),
    Some(&WORD_SINO_NODE),
    Some(&WORD_SINP_NODE),
    None,
    None,
    Some(&WORD_SINS_NODE),
    Some(&WORD_SINT_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_SINT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SINT_CHILDREN),
    value: None,
};

pub static WORD_SINT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ac"),
        dictgen::InsensitiveStr::Ascii("acks"),
        dictgen::InsensitiveStr::Ascii("acs"),
        dictgen::InsensitiveStr::Ascii("act"),
        dictgen::InsensitiveStr::Ascii("acts"),
        dictgen::InsensitiveStr::Ascii("ak"),
        dictgen::InsensitiveStr::Ascii("aks"),
        dictgen::InsensitiveStr::Ascii("akt"),
        dictgen::InsensitiveStr::Ascii("akts"),
        dictgen::InsensitiveStr::Ascii("ax"),
    ],
    values: &[
        &["syntax"],
        &["syntax"],
        &["syntax"],
        &["syntax"],
        &["syntax"],
        &["syntax"],
        &["syntax"],
        &["syntax"],
        &["syntax"],
        &["syntax"],
    ],
    range: 2..=4,
};

static WORD_SINS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SINS_CHILDREN),
    value: None,
};

pub static WORD_SINS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("iter"),
    ],
    values: &[&["sines", "since"], &["sinister"]],
    range: 1..=4,
};

static WORD_SINP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SINP_CHILDREN),
    value: None,
};

pub static WORD_SINP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ly")],
    values: &[&["simply"]],
    range: 2..=2,
};

static WORD_SINO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SINO_CHILDREN),
    value: None,
};

pub static WORD_SINO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("id"),
        dictgen::InsensitiveStr::Ascii("idal"),
        dictgen::InsensitiveStr::Ascii("ids"),
    ],
    values: &[&["sinusoid"], &["sinusoidal"], &["sinusoids"]],
    range: 2..=4,
};

static WORD_SINN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SINN_CHILDREN),
    value: None,
};

pub static WORD_SINN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("agog"),
        dictgen::InsensitiveStr::Ascii("agogs"),
        dictgen::InsensitiveStr::Ascii("ic"),
        dictgen::InsensitiveStr::Ascii("ical"),
        dictgen::InsensitiveStr::Ascii("ically"),
        dictgen::InsensitiveStr::Ascii("icaly"),
        dictgen::InsensitiveStr::Ascii("ics"),
    ],
    values: &[
        &["synagog"],
        &["synagogs"],
        &["cynic"],
        &["cynical"],
        &["cynically"],
        &["cynically"],
        &["cynics"],
    ],
    range: 2..=6,
};

static WORD_SINL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SINL_CHILDREN),
    value: None,
};

pub static WORD_SINL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ge"),
        dictgen::InsensitiveStr::Ascii("geplayer"),
        dictgen::InsensitiveStr::Ascii("ges"),
    ],
    values: &[&["single"], &["singleplayer"], &["singles"]],
    range: 2..=8,
};

static WORD_SINI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SINI_CHILDREN),
    value: None,
};

pub static WORD_SINI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("c"),
        dictgen::InsensitiveStr::Ascii("cal"),
        dictgen::InsensitiveStr::Ascii("cally"),
        dictgen::InsensitiveStr::Ascii("caly"),
        dictgen::InsensitiveStr::Ascii("cs"),
        dictgen::InsensitiveStr::Ascii("stre"),
    ],
    values: &[
        &["cynic", "sonic"],
        &["cynical"],
        &["cynically"],
        &["cynically"],
        &["cynics"],
        &["sinister"],
    ],
    range: 1..=5,
};

static WORD_SING_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SING_CHILDREN),
    value: None,
};

pub static WORD_SING_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("al"),
        dictgen::InsensitiveStr::Ascii("aled"),
        dictgen::InsensitiveStr::Ascii("als"),
        dictgen::InsensitiveStr::Ascii("ature"),
        dictgen::InsensitiveStr::Ascii("atures"),
        dictgen::InsensitiveStr::Ascii("el"),
        dictgen::InsensitiveStr::Ascii("elar"),
        dictgen::InsensitiveStr::Ascii("elarity"),
        dictgen::InsensitiveStr::Ascii("elarly"),
        dictgen::InsensitiveStr::Ascii("eled"),
        dictgen::InsensitiveStr::Ascii("eles"),
        dictgen::InsensitiveStr::Ascii("elplayer"),
        dictgen::InsensitiveStr::Ascii("els"),
        dictgen::InsensitiveStr::Ascii("elton"),
        dictgen::InsensitiveStr::Ascii("ificand"),
        dictgen::InsensitiveStr::Ascii("ificantly"),
        dictgen::InsensitiveStr::Ascii("ify"),
        dictgen::InsensitiveStr::Ascii("l"),
        dictgen::InsensitiveStr::Ascii("lar"),
        dictgen::InsensitiveStr::Ascii("lely"),
        dictgen::InsensitiveStr::Ascii("lepalyer"),
        dictgen::InsensitiveStr::Ascii("lers"),
        dictgen::InsensitiveStr::Ascii("ls"),
        dictgen::InsensitiveStr::Ascii("lton"),
        dictgen::InsensitiveStr::Ascii("ltons"),
        dictgen::InsensitiveStr::Ascii("luar"),
        dictgen::InsensitiveStr::Ascii("luarity"),
        dictgen::InsensitiveStr::Ascii("lular"),
        dictgen::InsensitiveStr::Ascii("lularly"),
        dictgen::InsensitiveStr::Ascii("nal"),
        dictgen::InsensitiveStr::Ascii("nalled"),
        dictgen::InsensitiveStr::Ascii("nals"),
        dictgen::InsensitiveStr::Ascii("ol"),
        dictgen::InsensitiveStr::Ascii("olar"),
        dictgen::InsensitiveStr::Ascii("oled"),
        dictgen::InsensitiveStr::Ascii("ols"),
        dictgen::InsensitiveStr::Ascii("ool"),
        dictgen::InsensitiveStr::Ascii("oolar"),
        dictgen::InsensitiveStr::Ascii("oolarity"),
        dictgen::InsensitiveStr::Ascii("oolarly"),
        dictgen::InsensitiveStr::Ascii("ooled"),
        dictgen::InsensitiveStr::Ascii("ools"),
        dictgen::InsensitiveStr::Ascii("paore"),
        dictgen::InsensitiveStr::Ascii("sog"),
        dictgen::InsensitiveStr::Ascii("ualrity"),
        dictgen::InsensitiveStr::Ascii("uarity"),
        dictgen::InsensitiveStr::Ascii("uarl"),
        dictgen::InsensitiveStr::Ascii("ulair"),
        dictgen::InsensitiveStr::Ascii("ulaire"),
        dictgen::InsensitiveStr::Ascii("ulairty"),
        dictgen::InsensitiveStr::Ascii("ularily"),
        dictgen::InsensitiveStr::Ascii("ulariy"),
        dictgen::InsensitiveStr::Ascii("ularty"),
        dictgen::InsensitiveStr::Ascii("ulary"),
        dictgen::InsensitiveStr::Ascii("ulat"),
        dictgen::InsensitiveStr::Ascii("ulaties"),
        dictgen::InsensitiveStr::Ascii("ulator"),
    ],
    values: &[
        &["signal", "single"],
        &["signaled"],
        &["signals"],
        &["signature"],
        &["signatures"],
        &["single", "signal"],
        &["singular"],
        &["singularity"],
        &["singularly"],
        &["singled", "signaled"],
        &["singles", "signals"],
        &["singleplayer"],
        &["singles"],
        &["singleton"],
        &["significand", "significant"],
        &["significantly"],
        &["signify"],
        &["single"],
        &["singular"],
        &["singly"],
        &["singleplayer"],
        &["singles"],
        &["singles", "single"],
        &["singleton"],
        &["singletons"],
        &["singular"],
        &["singularity"],
        &["singular"],
        &["singularly"],
        &["signal"],
        &["signalled"],
        &["signals"],
        &["signal", "single"],
        &["singular"],
        &["signaled", "singled"],
        &["signals", "singles"],
        &["single", "signal"],
        &["singular"],
        &["singularity"],
        &["singularly"],
        &["singled", "signaled"],
        &["singles", "signals"],
        &["singapore"],
        &["singsong"],
        &["singularity"],
        &["singularity"],
        &["singular"],
        &["singular"],
        &["singular"],
        &["singularity"],
        &["singularity"],
        &["singularity"],
        &["singularity"],
        &["singularity"],
        &["singular"],
        &["singularities"],
        &["singular"],
    ],
    range: 1..=9,
};

static WORD_SINC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SINC_CHILDREN),
    value: None,
};

pub static WORD_SINC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ereley"),
        dictgen::InsensitiveStr::Ascii("erelly"),
        dictgen::InsensitiveStr::Ascii("erley"),
        dictgen::InsensitiveStr::Ascii("erly"),
    ],
    values: &[
        &["sincerely"],
        &["sincerely"],
        &["sincerely"],
        &["sincerely"],
    ],
    range: 4..=6,
};

static WORD_SINA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SINA_CHILDREN),
    value: None,
};

pub static WORD_SINA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("gog"),
        dictgen::InsensitiveStr::Ascii("gogs"),
        dictgen::InsensitiveStr::Ascii("gpore"),
        dictgen::InsensitiveStr::Ascii("ture"),
    ],
    values: &[&["synagog"], &["synagogs"], &["singapore"], &["signature"]],
    range: 3..=5,
};

static WORD_SIM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_SIM_CHILDREN),
    value: None,
};

static WORD_SIM_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_SIMA_NODE),
    None,
    None,
    None,
    Some(&WORD_SIME_NODE),
    None,
    Some(&WORD_SIMG_NODE),
    None,
    Some(&WORD_SIMI_NODE),
    None,
    None,
    Some(&WORD_SIML_NODE),
    Some(&WORD_SIMM_NODE),
    None,
    None,
    Some(&WORD_SIMP_NODE),
    None,
    None,
    Some(&WORD_SIMS_NODE),
    None,
    Some(&WORD_SIMU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_SIMU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SIMU_CHILDREN),
    value: None,
};

pub static WORD_SIMU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("alte"),
        dictgen::InsensitiveStr::Ascii("alted"),
        dictgen::InsensitiveStr::Ascii("altes"),
        dictgen::InsensitiveStr::Ascii("alting"),
        dictgen::InsensitiveStr::Ascii("altion"),
        dictgen::InsensitiveStr::Ascii("altions"),
        dictgen::InsensitiveStr::Ascii("altor"),
        dictgen::InsensitiveStr::Ascii("altors"),
        dictgen::InsensitiveStr::Ascii("lacion"),
        dictgen::InsensitiveStr::Ascii("laiton"),
        dictgen::InsensitiveStr::Ascii("laitons"),
        dictgen::InsensitiveStr::Ascii("lantaneous"),
        dictgen::InsensitiveStr::Ascii("lantaneously"),
        dictgen::InsensitiveStr::Ascii("lataeous"),
        dictgen::InsensitiveStr::Ascii("lataeously"),
        dictgen::InsensitiveStr::Ascii("lataneity"),
        dictgen::InsensitiveStr::Ascii("lataneous"),
        dictgen::InsensitiveStr::Ascii("lataneously"),
        dictgen::InsensitiveStr::Ascii("latanious"),
        dictgen::InsensitiveStr::Ascii("lataniously"),
        dictgen::InsensitiveStr::Ascii("latanous"),
        dictgen::InsensitiveStr::Ascii("latanously"),
        dictgen::InsensitiveStr::Ascii("latation"),
        dictgen::InsensitiveStr::Ascii("latenous"),
        dictgen::InsensitiveStr::Ascii("latenously"),
        dictgen::InsensitiveStr::Ascii("latie"),
        dictgen::InsensitiveStr::Ascii("laties"),
        dictgen::InsensitiveStr::Ascii("latin"),
        dictgen::InsensitiveStr::Ascii("latious"),
        dictgen::InsensitiveStr::Ascii("latneous"),
        dictgen::InsensitiveStr::Ascii("latneously"),
        dictgen::InsensitiveStr::Ascii("lato"),
        dictgen::InsensitiveStr::Ascii("latons"),
        dictgen::InsensitiveStr::Ascii("latore"),
        dictgen::InsensitiveStr::Ascii("ltaenous"),
        dictgen::InsensitiveStr::Ascii("ltaenously"),
        dictgen::InsensitiveStr::Ascii("ltainously"),
        dictgen::InsensitiveStr::Ascii("ltanaeous"),
        dictgen::InsensitiveStr::Ascii("ltaneos"),
        dictgen::InsensitiveStr::Ascii("ltaneosly"),
        dictgen::InsensitiveStr::Ascii("ltaneoulsy"),
        dictgen::InsensitiveStr::Ascii("ltaneuos"),
        dictgen::InsensitiveStr::Ascii("ltaneuous"),
        dictgen::InsensitiveStr::Ascii("ltaneus"),
        dictgen::InsensitiveStr::Ascii("ltaneusly"),
        dictgen::InsensitiveStr::Ascii("ltanious"),
        dictgen::InsensitiveStr::Ascii("ltaniously"),
        dictgen::InsensitiveStr::Ascii("ltanous"),
        dictgen::InsensitiveStr::Ascii("ltanously"),
        dictgen::InsensitiveStr::Ascii("lteanously"),
        dictgen::InsensitiveStr::Ascii("lteneous"),
        dictgen::InsensitiveStr::Ascii("ltenious"),
        dictgen::InsensitiveStr::Ascii("lteniously"),
        dictgen::InsensitiveStr::Ascii("taneously"),
    ],
    values: &[
        &["simulate"],
        &["simulated"],
        &["simulates"],
        &["simulating"],
        &["simulation"],
        &["simulations"],
        &["simulator"],
        &["simulators"],
        &["simulation"],
        &["simulations", "simulation"],
        &["simulations"],
        &["simultaneous"],
        &["simultaneously"],
        &["simultaneous"],
        &["simultaneously"],
        &["simultaneity"],
        &["simultaneous"],
        &["simultaneously"],
        &["simultaneous"],
        &["simultaneously"],
        &["simultaneous"],
        &["simultaneously"],
        &["simulation"],
        &["simultaneous"],
        &["simultaneously"],
        &["simulate"],
        &["simulate"],
        &["simulation"],
        &["simulations"],
        &["simultaneous"],
        &["simultaneously"],
        &["simulation"],
        &["simulations"],
        &["simulate"],
        &["simultaneous"],
        &["simultaneously"],
        &["simultaneously"],
        &["simultaneous"],
        &["simultaneous"],
        &["simultaneously"],
        &["simultaneously"],
        &["simultaneous"],
        &["simultaneous"],
        &["simultaneous"],
        &["simultaneously"],
        &["simultaneous"],
        &["simultaneously"],
        &["simultaneous"],
        &["simultaneously"],
        &["simultaneously"],
        &["simultaneous"],
        &["simultaneous"],
        &["simultaneously"],
        &["simultaneously"],
    ],
    range: 4..=12,
};

static WORD_SIMS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SIMS_CHILDREN),
    value: None,
};

pub static WORD_SIMS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("pon")],
    values: &[&["simpson"]],
    range: 3..=3,
};

static WORD_SIMP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SIMP_CHILDREN),
    value: None,
};

pub static WORD_SIMP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("athizers"),
        dictgen::InsensitiveStr::Ascii("elst"),
        dictgen::InsensitiveStr::Ascii("ification"),
        dictgen::InsensitiveStr::Ascii("ifications"),
        dictgen::InsensitiveStr::Ascii("ified"),
        dictgen::InsensitiveStr::Ascii("lefying"),
        dictgen::InsensitiveStr::Ascii("lei"),
        dictgen::InsensitiveStr::Ascii("let"),
        dictgen::InsensitiveStr::Ascii("lets"),
        dictgen::InsensitiveStr::Ascii("ley"),
        dictgen::InsensitiveStr::Ascii("lfy"),
        dictgen::InsensitiveStr::Ascii("lication"),
        dictgen::InsensitiveStr::Ascii("licitly"),
        dictgen::InsensitiveStr::Ascii("lictic"),
        dictgen::InsensitiveStr::Ascii("licty"),
        dictgen::InsensitiveStr::Ascii("licy"),
        dictgen::InsensitiveStr::Ascii("lier"),
        dictgen::InsensitiveStr::Ascii("lies"),
        dictgen::InsensitiveStr::Ascii("liest"),
        dictgen::InsensitiveStr::Ascii("lifed"),
        dictgen::InsensitiveStr::Ascii("lificacion"),
        dictgen::InsensitiveStr::Ascii("lificaiton"),
        dictgen::InsensitiveStr::Ascii("lificaitons"),
        dictgen::InsensitiveStr::Ascii("lificating"),
        dictgen::InsensitiveStr::Ascii("lifiing"),
        dictgen::InsensitiveStr::Ascii("lifing"),
        dictgen::InsensitiveStr::Ascii("lifiy"),
        dictgen::InsensitiveStr::Ascii("lifyed"),
        dictgen::InsensitiveStr::Ascii("lifyng"),
        dictgen::InsensitiveStr::Ascii("lifys"),
        dictgen::InsensitiveStr::Ascii("liifcation"),
        dictgen::InsensitiveStr::Ascii("liifcations"),
        dictgen::InsensitiveStr::Ascii("lisitc"),
        dictgen::InsensitiveStr::Ascii("lisitic"),
        dictgen::InsensitiveStr::Ascii("lisity"),
        dictgen::InsensitiveStr::Ascii("list"),
        dictgen::InsensitiveStr::Ascii("listes"),
        dictgen::InsensitiveStr::Ascii("listisch"),
        dictgen::InsensitiveStr::Ascii("livity"),
        dictgen::InsensitiveStr::Ascii("liy"),
        dictgen::InsensitiveStr::Ascii("lyfied"),
        dictgen::InsensitiveStr::Ascii("lyifing"),
        dictgen::InsensitiveStr::Ascii("osn"),
        dictgen::InsensitiveStr::Ascii("tom"),
        dictgen::InsensitiveStr::Ascii("tomatic"),
        dictgen::InsensitiveStr::Ascii("tomatically"),
        dictgen::InsensitiveStr::Ascii("tomaticaly"),
        dictgen::InsensitiveStr::Ascii("tomaticlly"),
        dictgen::InsensitiveStr::Ascii("tomaticly"),
        dictgen::InsensitiveStr::Ascii("toms"),
        dictgen::InsensitiveStr::Ascii("tum"),
        dictgen::InsensitiveStr::Ascii("tumatic"),
        dictgen::InsensitiveStr::Ascii("tumatically"),
        dictgen::InsensitiveStr::Ascii("tumaticaly"),
        dictgen::InsensitiveStr::Ascii("tumaticlly"),
        dictgen::InsensitiveStr::Ascii("tumaticly"),
        dictgen::InsensitiveStr::Ascii("tums"),
        dictgen::InsensitiveStr::Ascii("y"),
    ],
    values: &[
        &["sympathizers"],
        &["simplest"],
        &["simplification"],
        &["simplifications"],
        &["simplified"],
        &["simplifying"],
        &["simply"],
        &["simplest"],
        &["simplest"],
        &["simply"],
        &["simplify"],
        &["simplification"],
        &["simplicity"],
        &["simplistic"],
        &["simplicity"],
        &["simplicity"],
        &["simpler"],
        &["implies", "simplifies"],
        &["simplest"],
        &["simplified"],
        &["simplification"],
        &["simplification"],
        &["simplifications"],
        &["simplification"],
        &["simplifying"],
        &["simplifying"],
        &["simplify"],
        &["simplified"],
        &["simplifying"],
        &["simplifies"],
        &["simplification"],
        &["simplifications"],
        &["simplistic"],
        &["simplistic"],
        &["simplicity"],
        &["simplest"],
        &["simplest"],
        &["simplistic"],
        &["simplicity"],
        &["simplify", "simply"],
        &["simplified"],
        &["simplifying"],
        &["simpson"],
        &["symptom"],
        &["symptomatic"],
        &["symptomatically"],
        &["symptomatically"],
        &["symptomatically"],
        &["symptomatically"],
        &["symptoms"],
        &["symptom"],
        &["symptomatic"],
        &["symptomatically"],
        &["symptomatically"],
        &["symptomatically"],
        &["symptomatically"],
        &["symptoms"],
        &["simply"],
    ],
    range: 1..=11,
};

static WORD_SIMM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SIMM_CHILDREN),
    value: None,
};

pub static WORD_SIMM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("etric"),
        dictgen::InsensitiveStr::Ascii("etrical"),
        dictgen::InsensitiveStr::Ascii("etricaly"),
        dictgen::InsensitiveStr::Ascii("etriclly"),
        dictgen::InsensitiveStr::Ascii("etricly"),
        dictgen::InsensitiveStr::Ascii("etry"),
        dictgen::InsensitiveStr::Ascii("ilar"),
    ],
    values: &[
        &["symmetric"],
        &["symmetrical"],
        &["symmetrically"],
        &["symmetrically"],
        &["symmetricly"],
        &["symmetry"],
        &["similar"],
    ],
    range: 4..=8,
};

static WORD_SIML_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SIML_CHILDREN),
    value: None,
};

pub static WORD_SIML_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ar"),
        dictgen::InsensitiveStr::Ascii("arlity"),
        dictgen::InsensitiveStr::Ascii("arly"),
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("iar"),
        dictgen::InsensitiveStr::Ascii("iarities"),
        dictgen::InsensitiveStr::Ascii("iarity"),
        dictgen::InsensitiveStr::Ascii("iarly"),
        dictgen::InsensitiveStr::Ascii("icity"),
        dictgen::InsensitiveStr::Ascii("ified"),
        dictgen::InsensitiveStr::Ascii("ifies"),
        dictgen::InsensitiveStr::Ascii("ify"),
        dictgen::InsensitiveStr::Ascii("ifying"),
        dictgen::InsensitiveStr::Ascii("iiar"),
        dictgen::InsensitiveStr::Ascii("pe"),
        dictgen::InsensitiveStr::Ascii("uate"),
        dictgen::InsensitiveStr::Ascii("uated"),
        dictgen::InsensitiveStr::Ascii("uation"),
        dictgen::InsensitiveStr::Ascii("uations"),
        dictgen::InsensitiveStr::Ascii("uator"),
        dictgen::InsensitiveStr::Ascii("utaneous"),
        dictgen::InsensitiveStr::Ascii("utaneously"),
        dictgen::InsensitiveStr::Ascii("y"),
    ],
    values: &[
        &["similar"],
        &["similarity"],
        &["similarly"],
        &["simple", "smile", "simile"],
        &["similar"],
        &["similarities"],
        &["similarity"],
        &["similarly"],
        &["simplicity"],
        &["simplified"],
        &["simplifies"],
        &["simplify"],
        &["simplifying"],
        &["similar"],
        &["simple"],
        &["simulate"],
        &["simulated"],
        &["simulation"],
        &["simulations"],
        &["simulator"],
        &["simultaneous"],
        &["simultaneously"],
        &["simply", "simile", "smiley"],
    ],
    range: 1..=10,
};

static WORD_SIMI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SIMI_CHILDREN),
    value: None,
};

pub static WORD_SIMI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("alir"),
        dictgen::InsensitiveStr::Ascii("alr"),
        dictgen::InsensitiveStr::Ascii("alrity"),
        dictgen::InsensitiveStr::Ascii("alrly"),
        dictgen::InsensitiveStr::Ascii("ar"),
        dictgen::InsensitiveStr::Ascii("ilar"),
        dictgen::InsensitiveStr::Ascii("lair"),
        dictgen::InsensitiveStr::Ascii("lairty"),
        dictgen::InsensitiveStr::Ascii("laraties"),
        dictgen::InsensitiveStr::Ascii("lari"),
        dictgen::InsensitiveStr::Ascii("larily"),
        dictgen::InsensitiveStr::Ascii("larites"),
        dictgen::InsensitiveStr::Ascii("larlity"),
        dictgen::InsensitiveStr::Ascii("larlly"),
        dictgen::InsensitiveStr::Ascii("lart"),
        dictgen::InsensitiveStr::Ascii("lary"),
        dictgen::InsensitiveStr::Ascii("lat"),
        dictgen::InsensitiveStr::Ascii("lia"),
        dictgen::InsensitiveStr::Ascii("liair"),
        dictgen::InsensitiveStr::Ascii("liar"),
        dictgen::InsensitiveStr::Ascii("liarites"),
        dictgen::InsensitiveStr::Ascii("liarity"),
        dictgen::InsensitiveStr::Ascii("liarly"),
        dictgen::InsensitiveStr::Ascii("liarties"),
        dictgen::InsensitiveStr::Ascii("liarty"),
        dictgen::InsensitiveStr::Ascii("liary"),
        dictgen::InsensitiveStr::Ascii("lir"),
        dictgen::InsensitiveStr::Ascii("liraties"),
        dictgen::InsensitiveStr::Ascii("llar"),
        dictgen::InsensitiveStr::Ascii("ltaneous"),
        dictgen::InsensitiveStr::Ascii("ltaneously"),
        dictgen::InsensitiveStr::Ascii("ly"),
    ],
    values: &[
        &["similar"],
        &["similar"],
        &["similarity"],
        &["similarly"],
        &["similar"],
        &["similar"],
        &["similar"],
        &["similarity"],
        &["similarities"],
        &["similar"],
        &["similarly"],
        &["similarities"],
        &["similarity"],
        &["similarly"],
        &["similarity"],
        &["similarly"],
        &["similar"],
        &["similar"],
        &["similar"],
        &["similar"],
        &["similarities"],
        &["similarity"],
        &["similarly"],
        &["similarities"],
        &["similarity"],
        &["similarity"],
        &["similar"],
        &["similarities"],
        &["similar"],
        &["simultaneous"],
        &["simultaneously"],
        &["simile", "smiley", "simply", "similarly"],
    ],
    range: 2..=10,
};

static WORD_SIMG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SIMG_CHILDREN),
    value: None,
};

pub static WORD_SIMG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("le")],
    values: &[&["single"]],
    range: 2..=2,
};

static WORD_SIME_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SIME_CHILDREN),
    value: None,
};

pub static WORD_SIME_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ltaneous"),
        dictgen::InsensitiveStr::Ascii("ltaneously"),
        dictgen::InsensitiveStr::Ascii("ple"),
        dictgen::InsensitiveStr::Ascii("tric"),
        dictgen::InsensitiveStr::Ascii("trical"),
        dictgen::InsensitiveStr::Ascii("tricaly"),
        dictgen::InsensitiveStr::Ascii("triclly"),
        dictgen::InsensitiveStr::Ascii("tricly"),
        dictgen::InsensitiveStr::Ascii("trie"),
        dictgen::InsensitiveStr::Ascii("tries"),
    ],
    values: &[
        &["simultaneous"],
        &["simultaneously"],
        &["simple"],
        &["symmetric"],
        &["symmetrical"],
        &["symmetrically"],
        &["symmetrically"],
        &["symmetricly"],
        &["symmetry"],
        &["symmetries"],
    ],
    range: 3..=10,
};

static WORD_SIMA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SIMA_CHILDREN),
    value: None,
};

pub static WORD_SIMA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ltaneous"),
        dictgen::InsensitiveStr::Ascii("ltaneously"),
    ],
    values: &[&["simultaneous"], &["simultaneously"]],
    range: 8..=10,
};

static WORD_SIL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SIL_CHILDREN),
    value: None,
};

pub static WORD_SIL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("abus"),
        dictgen::InsensitiveStr::Ascii("abuses"),
        dictgen::InsensitiveStr::Ascii("bings"),
        dictgen::InsensitiveStr::Ascii("ders"),
        dictgen::InsensitiveStr::Ascii("entely"),
        dictgen::InsensitiveStr::Ascii("enty"),
        dictgen::InsensitiveStr::Ascii("houete"),
        dictgen::InsensitiveStr::Ascii("houeted"),
        dictgen::InsensitiveStr::Ascii("houetes"),
        dictgen::InsensitiveStr::Ascii("houeting"),
        dictgen::InsensitiveStr::Ascii("houetist"),
        dictgen::InsensitiveStr::Ascii("houwet"),
        dictgen::InsensitiveStr::Ascii("houweted"),
        dictgen::InsensitiveStr::Ascii("houwetes"),
        dictgen::InsensitiveStr::Ascii("houweting"),
        dictgen::InsensitiveStr::Ascii("houwetist"),
        dictgen::InsensitiveStr::Ascii("ibus"),
        dictgen::InsensitiveStr::Ascii("ibuses"),
        dictgen::InsensitiveStr::Ascii("icoln"),
        dictgen::InsensitiveStr::Ascii("icoon"),
        dictgen::InsensitiveStr::Ascii("iently"),
        dictgen::InsensitiveStr::Ascii("imiar"),
        dictgen::InsensitiveStr::Ascii("labus"),
        dictgen::InsensitiveStr::Ascii("labuses"),
        dictgen::InsensitiveStr::Ascii("libus"),
        dictgen::InsensitiveStr::Ascii("libuses"),
        dictgen::InsensitiveStr::Ascii("lybus"),
        dictgen::InsensitiveStr::Ascii("lybuses"),
        dictgen::InsensitiveStr::Ascii("ohuette"),
        dictgen::InsensitiveStr::Ascii("ouet"),
        dictgen::InsensitiveStr::Ascii("ouete"),
        dictgen::InsensitiveStr::Ascii("oueted"),
        dictgen::InsensitiveStr::Ascii("ouetes"),
        dictgen::InsensitiveStr::Ascii("oueting"),
        dictgen::InsensitiveStr::Ascii("ouetist"),
        dictgen::InsensitiveStr::Ascii("ouhette"),
        dictgen::InsensitiveStr::Ascii("ouhetted"),
        dictgen::InsensitiveStr::Ascii("ouhettes"),
        dictgen::InsensitiveStr::Ascii("ouhetting"),
        dictgen::InsensitiveStr::Ascii("ouwet"),
        dictgen::InsensitiveStr::Ascii("ouweted"),
        dictgen::InsensitiveStr::Ascii("ouwetes"),
        dictgen::InsensitiveStr::Ascii("ouweting"),
        dictgen::InsensitiveStr::Ascii("ouwetist"),
        dictgen::InsensitiveStr::Ascii("owet"),
        dictgen::InsensitiveStr::Ascii("oweted"),
        dictgen::InsensitiveStr::Ascii("owetes"),
        dictgen::InsensitiveStr::Ascii("oweting"),
        dictgen::InsensitiveStr::Ascii("owetist"),
        dictgen::InsensitiveStr::Ascii("ybus"),
        dictgen::InsensitiveStr::Ascii("ybuses"),
    ],
    values: &[
        &["syllabus"],
        &["syllabuses"],
        &["siblings"],
        &["sliders"],
        &["silently"],
        &["silently"],
        &["silhouette"],
        &["silhouetted"],
        &["silhouettes"],
        &["silhouetting"],
        &["silhouettist"],
        &["silhouette"],
        &["silhouetted"],
        &["silhouettes"],
        &["silhouetting"],
        &["silhouettist"],
        &["syllabus"],
        &["syllabuses"],
        &["silicon"],
        &["silicon"],
        &["silently", "saliently"],
        &["similar"],
        &["syllabus"],
        &["syllabuses"],
        &["syllabus"],
        &["syllabuses"],
        &["syllabus"],
        &["syllabuses"],
        &["silhouette"],
        &["silhouette"],
        &["silhouette"],
        &["silhouetted"],
        &["silhouettes"],
        &["silhouetting"],
        &["silhouettist"],
        &["silhouette"],
        &["silhouetted"],
        &["silhouettes"],
        &["silhouetting"],
        &["silhouette"],
        &["silhouetted"],
        &["silhouettes"],
        &["silhouetting"],
        &["silhouettist"],
        &["silhouette"],
        &["silhouetted"],
        &["silhouettes"],
        &["silhouetting"],
        &["silhouettist"],
        &["syllabus"],
        &["syllabuses"],
    ],
    range: 4..=9,
};

static WORD_SIH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SIH_CHILDREN),
    value: None,
};

pub static WORD_SIH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("louette")],
    values: &[&["silhouette"]],
    range: 7..=7,
};

static WORD_SIG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_SIG_CHILDREN),
    value: None,
};

static WORD_SIG_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_SIGA_NODE),
    None,
    None,
    None,
    Some(&WORD_SIGE_NODE),
    None,
    None,
    Some(&WORD_SIGH_NODE),
    Some(&WORD_SIGI_NODE),
    None,
    None,
    Some(&WORD_SIGL_NODE),
    None,
    Some(&WORD_SIGN_NODE),
    None,
    None,
    None,
    Some(&WORD_SIGR_NODE),
    None,
    Some(&WORD_SIGT_NODE),
    Some(&WORD_SIGU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_SIGU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SIGU_CHILDREN),
    value: None,
};

pub static WORD_SIGU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ret"),
        dictgen::InsensitiveStr::Ascii("rete"),
        dictgen::InsensitiveStr::Ascii("retes"),
        dictgen::InsensitiveStr::Ascii("rets"),
        dictgen::InsensitiveStr::Ascii("rette"),
    ],
    values: &[
        &["cigaret"],
        &["cigarette"],
        &["cigarettes"],
        &["cigarets"],
        &["cigarette"],
    ],
    range: 3..=5,
};

static WORD_SIGT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SIGT_CHILDREN),
    value: None,
};

pub static WORD_SIGT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("hstone")],
    values: &[&["sightstone"]],
    range: 6..=6,
};

static WORD_SIGR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SIGR_CHILDREN),
    value: None,
};

pub static WORD_SIGR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ynge"),
        dictgen::InsensitiveStr::Ascii("ynges"),
    ],
    values: &[&["syringe"], &["syringes"]],
    range: 4..=5,
};

static WORD_SIGN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SIGN_CHILDREN),
    value: None,
};

pub static WORD_SIGN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("abl"),
        dictgen::InsensitiveStr::Ascii("ales"),
        dictgen::InsensitiveStr::Ascii("all"),
        dictgen::InsensitiveStr::Ascii("apore"),
        dictgen::InsensitiveStr::Ascii("atue"),
        dictgen::InsensitiveStr::Ascii("atur"),
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("ficant"),
        dictgen::InsensitiveStr::Ascii("ficantly"),
        dictgen::InsensitiveStr::Ascii("ficiant"),
        dictgen::InsensitiveStr::Ascii("ficiantly"),
        dictgen::InsensitiveStr::Ascii("fies"),
        dictgen::InsensitiveStr::Ascii("fiy"),
        dictgen::InsensitiveStr::Ascii("guature"),
        dictgen::InsensitiveStr::Ascii("ifanct"),
        dictgen::InsensitiveStr::Ascii("ifant"),
        dictgen::InsensitiveStr::Ascii("ifantly"),
        dictgen::InsensitiveStr::Ascii("ifcant"),
        dictgen::InsensitiveStr::Ascii("ifcantly"),
        dictgen::InsensitiveStr::Ascii("ifficant"),
        dictgen::InsensitiveStr::Ascii("ifiant"),
        dictgen::InsensitiveStr::Ascii("ificane"),
        dictgen::InsensitiveStr::Ascii("ificanlty"),
        dictgen::InsensitiveStr::Ascii("ificanly"),
        dictgen::InsensitiveStr::Ascii("ificante"),
        dictgen::InsensitiveStr::Ascii("ificanty"),
        dictgen::InsensitiveStr::Ascii("ificat"),
        dictgen::InsensitiveStr::Ascii("ificatly"),
        dictgen::InsensitiveStr::Ascii("ificato"),
        dictgen::InsensitiveStr::Ascii("ificently"),
        dictgen::InsensitiveStr::Ascii("ifigant"),
        dictgen::InsensitiveStr::Ascii("ifigantly"),
        dictgen::InsensitiveStr::Ascii("ifikant"),
        dictgen::InsensitiveStr::Ascii("ifiy"),
        dictgen::InsensitiveStr::Ascii("ign"),
        dictgen::InsensitiveStr::Ascii("igns"),
        dictgen::InsensitiveStr::Ascii("inged"),
        dictgen::InsensitiveStr::Ascii("ins"),
        dictgen::InsensitiveStr::Ascii("itories"),
        dictgen::InsensitiveStr::Ascii("itory"),
        dictgen::InsensitiveStr::Ascii("itures"),
        dictgen::InsensitiveStr::Ascii("le"),
        dictgen::InsensitiveStr::Ascii("leplayer"),
        dictgen::InsensitiveStr::Ascii("les"),
        dictgen::InsensitiveStr::Ascii("ol"),
        dictgen::InsensitiveStr::Ascii("ture"),
        dictgen::InsensitiveStr::Ascii("ul"),
        dictgen::InsensitiveStr::Ascii("ular"),
        dictgen::InsensitiveStr::Ascii("ularity"),
    ],
    values: &[
        &["signable", "signal"],
        &["signals"],
        &["signal"],
        &["singapore"],
        &["signatures", "signature"],
        &["signature"],
        &["signs"],
        &["significant"],
        &["significantly"],
        &["significant"],
        &["significantly"],
        &["signifies"],
        &["signify"],
        &["signature"],
        &["significant"],
        &["significant"],
        &["significantly"],
        &["significant"],
        &["significantly"],
        &["significant"],
        &["significant"],
        &["significance"],
        &["significantly"],
        &["significantly"],
        &["significance"],
        &["significantly"],
        &["significant"],
        &["significantly"],
        &["significant"],
        &["significantly"],
        &["significant"],
        &["significantly"],
        &["significant"],
        &["signify"],
        &["signing"],
        &["signings"],
        &["signing"],
        &["signings"],
        &["signatories"],
        &["signatory"],
        &["signatures"],
        &["single", "signal"],
        &["singleplayer"],
        &["singles", "signals"],
        &["signal"],
        &["signature"],
        &["signal"],
        &["singular"],
        &["singularity"],
    ],
    range: 2..=9,
};

static WORD_SIGL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SIGL_CHILDREN),
    value: None,
};

pub static WORD_SIGL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("eton"),
    ],
    values: &[&["single", "sigil"], &["singles", "sigils"], &["singleton"]],
    range: 1..=4,
};

static WORD_SIGI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SIGI_CHILDREN),
    value: None,
};

pub static WORD_SIGI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ficance"),
        dictgen::InsensitiveStr::Ascii("ficant"),
        dictgen::InsensitiveStr::Ascii("nificant"),
        dictgen::InsensitiveStr::Ascii("nificantly"),
        dictgen::InsensitiveStr::Ascii("nifies"),
        dictgen::InsensitiveStr::Ascii("nify"),
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("ts"),
    ],
    values: &[
        &["significance"],
        &["significant"],
        &["significant"],
        &["significantly"],
        &["signifies"],
        &["signify"],
        &["digit"],
        &["digits"],
    ],
    range: 1..=10,
};

static WORD_SIGH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SIGH_CHILDREN),
    value: None,
};

pub static WORD_SIGH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("rynge"),
        dictgen::InsensitiveStr::Ascii("rynges"),
        dictgen::InsensitiveStr::Ascii("th"),
        dictgen::InsensitiveStr::Ascii("ths"),
        dictgen::InsensitiveStr::Ascii("tstine"),
    ],
    values: &[
        &["syringe"],
        &["syringes"],
        &["scythe", "sight"],
        &["scythes", "sights"],
        &["sightstone"],
    ],
    range: 2..=6,
};

static WORD_SIGE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SIGE_CHILDREN),
    value: None,
};

pub static WORD_SIGE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("n")],
    values: &[&["sign"]],
    range: 1..=1,
};

static WORD_SIGA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SIGA_CHILDREN),
    value: None,
};

pub static WORD_SIGA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("l"),
        dictgen::InsensitiveStr::Ascii("led"),
        dictgen::InsensitiveStr::Ascii("ls"),
        dictgen::InsensitiveStr::Ascii("nture"),
        dictgen::InsensitiveStr::Ascii("ntures"),
        dictgen::InsensitiveStr::Ascii("ture"),
        dictgen::InsensitiveStr::Ascii("tures"),
    ],
    values: &[
        &["signal", "sigil"],
        &["signaled"],
        &["signals", "sigils"],
        &["signature"],
        &["signatures"],
        &["signature"],
        &["signatures"],
    ],
    range: 1..=6,
};

static WORD_SIF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SIF_CHILDREN),
    value: None,
};

pub static WORD_SIF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("fix"),
        dictgen::InsensitiveStr::Ascii("fixation"),
        dictgen::InsensitiveStr::Ascii("fixed"),
        dictgen::InsensitiveStr::Ascii("fixes"),
        dictgen::InsensitiveStr::Ascii("fixing"),
    ],
    values: &[
        &["suffix"],
        &["suffixation", "suffocation"],
        &["suffixed"],
        &["suffixes"],
        &["suffixing"],
    ],
    range: 3..=8,
};

static WORD_SIE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SIE_CHILDREN),
    value: Some(&["size", "sigh", "side"]),
};

pub static WORD_SIE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("nce"),
        dictgen::InsensitiveStr::Ascii("s"),
        dictgen::InsensitiveStr::Ascii("z"),
        dictgen::InsensitiveStr::Ascii("zable"),
        dictgen::InsensitiveStr::Ascii("ze"),
        dictgen::InsensitiveStr::Ascii("zed"),
        dictgen::InsensitiveStr::Ascii("zing"),
        dictgen::InsensitiveStr::Ascii("zure"),
        dictgen::InsensitiveStr::Ascii("zures"),
    ],
    values: &[
        &["science", "silence"],
        &["size", "sighs", "sides"],
        &["size", "seize"],
        &["sizable"],
        &["seize", "size"],
        &["seized", "sized"],
        &["seizing", "sizing"],
        &["seizure"],
        &["seizures"],
    ],
    range: 1..=5,
};

static WORD_SID_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SID_CHILDREN),
    value: None,
};

pub static WORD_SID_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("de"),
        dictgen::InsensitiveStr::Ascii("ebaord"),
        dictgen::InsensitiveStr::Ascii("eboad"),
        dictgen::InsensitiveStr::Ascii("elen"),
        dictgen::InsensitiveStr::Ascii("elinien"),
        dictgen::InsensitiveStr::Ascii("elinjen"),
        dictgen::InsensitiveStr::Ascii("elinked"),
        dictgen::InsensitiveStr::Ascii("eral"),
        dictgen::InsensitiveStr::Ascii("leine"),
        dictgen::InsensitiveStr::Ascii("uction"),
    ],
    values: &[
        &["side"],
        &["sideboard"],
        &["sideboard"],
        &["sideline"],
        &["sideline"],
        &["sideline"],
        &["sideline"],
        &["sidereal"],
        &["sideline"],
        &["seduction"],
    ],
    range: 2..=7,
};

static WORD_SIC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SIC_CHILDREN),
    value: None,
};

pub static WORD_SIC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("inct"),
        dictgen::InsensitiveStr::Ascii("inctly"),
        dictgen::InsensitiveStr::Ascii("kamore"),
        dictgen::InsensitiveStr::Ascii("kamores"),
        dictgen::InsensitiveStr::Ascii("ne"),
    ],
    values: &[
        &["succinct"],
        &["succinctly"],
        &["sycamore"],
        &["sycamores"],
        &["since"],
    ],
    range: 2..=7,
};

static WORD_SIB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SIB_CHILDREN),
    value: None,
};

pub static WORD_SIB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("iling"),
        dictgen::InsensitiveStr::Ascii("ilings"),
        dictgen::InsensitiveStr::Ascii("lins"),
        dictgen::InsensitiveStr::Ascii("title"),
        dictgen::InsensitiveStr::Ascii("titles"),
    ],
    values: &[
        &["sibling"],
        &["siblings"],
        &["siblings"],
        &["subtitle"],
        &["subtitles"],
    ],
    range: 4..=6,
};

static WORD_SH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_SH_CHILDREN),
    value: None,
};

static WORD_SH_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_SHA_NODE),
    Some(&WORD_SHB_NODE),
    Some(&WORD_SHC_NODE),
    None,
    Some(&WORD_SHE_NODE),
    Some(&WORD_SHF_NODE),
    None,
    None,
    Some(&WORD_SHI_NODE),
    None,
    None,
    Some(&WORD_SHL_NODE),
    None,
    Some(&WORD_SHN_NODE),
    Some(&WORD_SHO_NODE),
    Some(&WORD_SHP_NODE),
    None,
    Some(&WORD_SHR_NODE),
    Some(&WORD_SHS_NODE),
    Some(&WORD_SHT_NODE),
    Some(&WORD_SHU_NODE),
    None,
    Some(&WORD_SHW_NODE),
    None,
    Some(&WORD_SHY_NODE),
    None,
];

static WORD_SHY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SHY_CHILDREN),
    value: None,
};

pub static WORD_SHY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("stem"),
        dictgen::InsensitiveStr::Ascii("stemerror"),
        dictgen::InsensitiveStr::Ascii("stemmemory"),
        dictgen::InsensitiveStr::Ascii("stems"),
        dictgen::InsensitiveStr::Ascii("stemwindow"),
    ],
    values: &[
        &["system"],
        &["systemerror"],
        &["systemmemory"],
        &["systems"],
        &["systemwindow"],
    ],
    range: 4..=10,
};

static WORD_SHW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SHW_CHILDREN),
    value: None,
};

pub static WORD_SHW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ashank"),
        dictgen::InsensitiveStr::Ascii("o"),
        dictgen::InsensitiveStr::Ascii("on"),
    ],
    values: &[&["shawshank"], &["show"], &["shown"]],
    range: 1..=6,
};

static WORD_SHU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SHU_CHILDREN),
    value: None,
};

pub static WORD_SHU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("down"),
        dictgen::InsensitiveStr::Ascii("fle"),
        dictgen::InsensitiveStr::Ascii("ld"),
        dictgen::InsensitiveStr::Ascii("old"),
        dictgen::InsensitiveStr::Ascii("oldnt"),
        dictgen::InsensitiveStr::Ascii("re"),
        dictgen::InsensitiveStr::Ascii("rely"),
        dictgen::InsensitiveStr::Ascii("tdownm"),
        dictgen::InsensitiveStr::Ascii("ting"),
        dictgen::InsensitiveStr::Ascii("todwn"),
    ],
    values: &[
        &["shutdown"],
        &["shuffle"],
        &["should"],
        &["should"],
        &["shouldnt"],
        &["sure"],
        &["surely"],
        &["shutdown"],
        &["shutting"],
        &["shutdown"],
    ],
    range: 2..=6,
};

static WORD_SHT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SHT_CHILDREN),
    value: None,
};

pub static WORD_SHT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("iless"),
        dictgen::InsensitiveStr::Ascii("op"),
        dictgen::InsensitiveStr::Ascii("oped"),
        dictgen::InsensitiveStr::Ascii("opes"),
        dictgen::InsensitiveStr::Ascii("oping"),
        dictgen::InsensitiveStr::Ascii("opp"),
        dictgen::InsensitiveStr::Ascii("opped"),
        dictgen::InsensitiveStr::Ascii("oppes"),
        dictgen::InsensitiveStr::Ascii("opping"),
        dictgen::InsensitiveStr::Ascii("ops"),
    ],
    values: &[
        &["shitless"],
        &["stop", "shop"],
        &["stopped", "shopped"],
        &["stops", "shops"],
        &["stopping", "shopping"],
        &["stop", "shop"],
        &["stopped", "shopped"],
        &["stops", "shops"],
        &["stopping", "shopping"],
        &["stops", "shops"],
    ],
    range: 2..=6,
};

static WORD_SHS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SHS_CHILDREN),
    value: Some(&["nhs", "ssh"]),
};

pub static WORD_SHS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[],
    values: &[],
    range: 0..=0,
};

static WORD_SHR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SHR_CHILDREN),
    value: None,
};

pub static WORD_SHR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("apenl"),
        dictgen::InsensitiveStr::Ascii("eak"),
        dictgen::InsensitiveStr::Ascii("elock"),
        dictgen::InsensitiveStr::Ascii("eshold"),
        dictgen::InsensitiveStr::Ascii("iks"),
        dictgen::InsensitiveStr::Ascii("iley"),
        dictgen::InsensitiveStr::Ascii("inked"),
        dictgen::InsensitiveStr::Ascii("panel"),
    ],
    values: &[
        &["shrapnel"],
        &["shriek"],
        &["sherlock"],
        &["threshold"],
        &["shrinks"],
        &["shirley"],
        &["shrunk", "shrank"],
        &["shrapnel"],
    ],
    range: 3..=6,
};

static WORD_SHP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SHP_CHILDREN),
    value: None,
};

pub static WORD_SHP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ae"),
        dictgen::InsensitiveStr::Ascii("aes"),
        dictgen::InsensitiveStr::Ascii("apes"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("ere"),
        dictgen::InsensitiveStr::Ascii("eres"),
        dictgen::InsensitiveStr::Ascii("erical"),
        dictgen::InsensitiveStr::Ascii("ped"),
    ],
    values: &[
        &["shape"],
        &["shapes"],
        &["shapes"],
        &["shaped", "shipped"],
        &["sphere"],
        &["spheres"],
        &["spherical"],
        &["shipped"],
    ],
    range: 2..=6,
};

static WORD_SHO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SHO_CHILDREN),
    value: None,
};

pub static WORD_SHO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ft"),
        dictgen::InsensitiveStr::Ascii("ftware"),
        dictgen::InsensitiveStr::Ascii("ild"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("ld"),
        dictgen::InsensitiveStr::Ascii("lder"),
        dictgen::InsensitiveStr::Ascii("luld"),
        dictgen::InsensitiveStr::Ascii("ould"),
        dictgen::InsensitiveStr::Ascii("pkeeepers"),
        dictgen::InsensitiveStr::Ascii("puld"),
        dictgen::InsensitiveStr::Ascii("rcut"),
        dictgen::InsensitiveStr::Ascii("rcuts"),
        dictgen::InsensitiveStr::Ascii("rly"),
        dictgen::InsensitiveStr::Ascii("rtcat"),
        dictgen::InsensitiveStr::Ascii("rtcats"),
        dictgen::InsensitiveStr::Ascii("rtcomming"),
        dictgen::InsensitiveStr::Ascii("rtcommings"),
        dictgen::InsensitiveStr::Ascii("rtcutt"),
        dictgen::InsensitiveStr::Ascii("rtend"),
        dictgen::InsensitiveStr::Ascii("rtenend"),
        dictgen::InsensitiveStr::Ascii("rtenning"),
        dictgen::InsensitiveStr::Ascii("rtenting"),
        dictgen::InsensitiveStr::Ascii("rtern"),
        dictgen::InsensitiveStr::Ascii("rthly"),
        dictgen::InsensitiveStr::Ascii("rtining"),
        dictgen::InsensitiveStr::Ascii("rtkut"),
        dictgen::InsensitiveStr::Ascii("rtkuts"),
        dictgen::InsensitiveStr::Ascii("tcut"),
        dictgen::InsensitiveStr::Ascii("tcuts"),
        dictgen::InsensitiveStr::Ascii("tdown"),
        dictgen::InsensitiveStr::Ascii("tuout"),
        dictgen::InsensitiveStr::Ascii("ucl"),
        dictgen::InsensitiveStr::Ascii("ud"),
        dictgen::InsensitiveStr::Ascii("uder"),
        dictgen::InsensitiveStr::Ascii("udered"),
        dictgen::InsensitiveStr::Ascii("uders"),
        dictgen::InsensitiveStr::Ascii("udl"),
        dictgen::InsensitiveStr::Ascii("udld"),
        dictgen::InsensitiveStr::Ascii("udle"),
        dictgen::InsensitiveStr::Ascii("udlers"),
        dictgen::InsensitiveStr::Ascii("udln"),
        dictgen::InsensitiveStr::Ascii("udlnt"),
        dictgen::InsensitiveStr::Ascii("udn"),
        dictgen::InsensitiveStr::Ascii("udt"),
        dictgen::InsensitiveStr::Ascii("ul"),
        dictgen::InsensitiveStr::Ascii("uldbe"),
        dictgen::InsensitiveStr::Ascii("uldes"),
        dictgen::InsensitiveStr::Ascii("uldnot"),
        dictgen::InsensitiveStr::Ascii("uldt"),
        dictgen::InsensitiveStr::Ascii("ule"),
        dictgen::InsensitiveStr::Ascii("ulld"),
        dictgen::InsensitiveStr::Ascii("ulndt"),
        dictgen::InsensitiveStr::Ascii("uls"),
        dictgen::InsensitiveStr::Ascii("ult"),
        dictgen::InsensitiveStr::Ascii("uod"),
        dictgen::InsensitiveStr::Ascii("utot"),
        dictgen::InsensitiveStr::Ascii("uw"),
        dictgen::InsensitiveStr::Ascii("uws"),
        dictgen::InsensitiveStr::Ascii("wboarding"),
        dictgen::InsensitiveStr::Ascii("wede"),
        dictgen::InsensitiveStr::Ascii("werd"),
        dictgen::InsensitiveStr::Ascii("wfer"),
        dictgen::InsensitiveStr::Ascii("wvinism"),
    ],
    values: &[
        &["shift", "short"],
        &["software"],
        &["should"],
        &["showing"],
        &["should", "hold", "sold"],
        &["shoulder"],
        &["should"],
        &["should"],
        &["shopkeepers"],
        &["should"],
        &["shortcut"],
        &["shortcuts"],
        &["shortly"],
        &["shortcut"],
        &["shortcuts"],
        &["shortcoming"],
        &["shortcomings"],
        &["shortcut"],
        &["shortened"],
        &["shortened"],
        &["shortening"],
        &["shortening"],
        &["shorten"],
        &["shortly"],
        &["shortening"],
        &["shortcut"],
        &["shortcuts"],
        &["shortcut"],
        &["shortcuts"],
        &["shutdown"],
        &["shoutout"],
        &["should"],
        &["should"],
        &["shoulder", "shudder"],
        &["shouldered", "shuddered"],
        &["shoulders", "shudders"],
        &["should"],
        &["should"],
        &["should"],
        &["shoulders"],
        &["should"],
        &["shouldnt"],
        &["shouldn"],
        &["should"],
        &["should", "shawl", "shoal"],
        &["should"],
        &["shoulders"],
        &["shouldnt"],
        &["shouldnt"],
        &["should"],
        &["should"],
        &["shouldnt"],
        &["should"],
        &["should"],
        &["should"],
        &["shoutout"],
        &["show"],
        &["shows"],
        &["snowboarding"],
        &["showered"],
        &["showered"],
        &["chauffeur", "shower"],
        &["chauvinism"],
    ],
    range: 2..=10,
};

static WORD_SHN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SHN_CHILDREN),
    value: None,
};

pub static WORD_SHN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("aghai")],
    values: &[&["shanghai"]],
    range: 5..=5,
};

static WORD_SHL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SHL_CHILDREN),
    value: None,
};

pub static WORD_SHL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("edon"),
        dictgen::InsensitiveStr::Ascii("eter"),
        dictgen::InsensitiveStr::Ascii("etered"),
        dictgen::InsensitiveStr::Ascii("eters"),
    ],
    values: &[&["sheldon"], &["shelter"], &["sheltered"], &["shelters"]],
    range: 4..=6,
};

static WORD_SHI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SHI_CHILDREN),
    value: None,
};

pub static WORD_SHI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cane"),
        dictgen::InsensitiveStr::Ascii("eldd"),
        dictgen::InsensitiveStr::Ascii("f"),
        dictgen::InsensitiveStr::Ascii("fitng"),
        dictgen::InsensitiveStr::Ascii("fteer"),
        dictgen::InsensitiveStr::Ascii("leded"),
        dictgen::InsensitiveStr::Ascii("leding"),
        dictgen::InsensitiveStr::Ascii("louette"),
        dictgen::InsensitiveStr::Ascii("neing"),
        dictgen::InsensitiveStr::Ascii("ped"),
        dictgen::InsensitiveStr::Ascii("ping"),
        dictgen::InsensitiveStr::Ascii("rely"),
        dictgen::InsensitiveStr::Ascii("tfer"),
        dictgen::InsensitiveStr::Ascii("tlasses"),
        dictgen::InsensitiveStr::Ascii("tstom"),
        dictgen::InsensitiveStr::Ascii("tstrom"),
        dictgen::InsensitiveStr::Ascii("ttoon"),
        dictgen::InsensitiveStr::Ascii("ttown"),
    ],
    values: &[
        &["chicane"],
        &["shielded"],
        &["shift"],
        &["shifting"],
        &["shifter"],
        &["shielded"],
        &["shielding"],
        &["silhouette"],
        &["shining"],
        &["shipped"],
        &["shipping"],
        &["shirley"],
        &["shifter"],
        &["shitless"],
        &["shitstorm"],
        &["shitstorm"],
        &["shitton"],
        &["shitton"],
    ],
    range: 1..=7,
};

static WORD_SHF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SHF_CHILDREN),
    value: None,
};

pub static WORD_SHF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("it"),
        dictgen::InsensitiveStr::Ascii("ited"),
        dictgen::InsensitiveStr::Ascii("iter"),
        dictgen::InsensitiveStr::Ascii("iting"),
        dictgen::InsensitiveStr::Ascii("its"),
        dictgen::InsensitiveStr::Ascii("ted"),
    ],
    values: &[
        &["shift"],
        &["shifted"],
        &["shifter"],
        &["shifting"],
        &["shifts"],
        &["shifted"],
    ],
    range: 2..=5,
};

static WORD_SHE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_SHE_CHILDREN),
    value: None,
};

static WORD_SHE_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_SHEA_NODE),
    None,
    Some(&WORD_SHEC_NODE),
    Some(&WORD_SHED_NODE),
    Some(&WORD_SHEE_NODE),
    None,
    None,
    None,
    Some(&WORD_SHEI_NODE),
    None,
    None,
    Some(&WORD_SHEL_NODE),
    Some(&WORD_SHEM_NODE),
    Some(&WORD_SHEN_NODE),
    None,
    Some(&WORD_SHEP_NODE),
    None,
    Some(&WORD_SHER_NODE),
    None,
    Some(&WORD_SHET_NODE),
    None,
    Some(&WORD_SHEV_NODE),
    None,
    None,
    None,
    None,
];

static WORD_SHEV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SHEV_CHILDREN),
    value: None,
};

pub static WORD_SHEV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("les")],
    values: &[&["shelves"]],
    range: 3..=3,
};

static WORD_SHET_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SHET_CHILDREN),
    value: None,
};

pub static WORD_SHET_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ler"),
        dictgen::InsensitiveStr::Ascii("lers"),
    ],
    values: &[&["shelter"], &["shelters"]],
    range: 3..=4,
};

static WORD_SHER_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SHER_CHILDREN),
    value: None,
};

pub static WORD_SHER_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("if"),
        dictgen::InsensitiveStr::Ascii("ifs"),
        dictgen::InsensitiveStr::Ascii("lcok"),
        dictgen::InsensitiveStr::Ascii("lok"),
    ],
    values: &[&["sheriff"], &["sheriffs"], &["sherlock"], &["sherlock"]],
    range: 2..=4,
};

static WORD_SHEP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SHEP_CHILDREN),
    value: None,
};

pub static WORD_SHEP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ard"),
        dictgen::InsensitiveStr::Ascii("arded"),
        dictgen::InsensitiveStr::Ascii("arding"),
        dictgen::InsensitiveStr::Ascii("ards"),
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("ered"),
        dictgen::InsensitiveStr::Ascii("eredly"),
        dictgen::InsensitiveStr::Ascii("ereds"),
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("harded"),
        dictgen::InsensitiveStr::Ascii("hed"),
        dictgen::InsensitiveStr::Ascii("hered"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("perd"),
        dictgen::InsensitiveStr::Ascii("perded"),
        dictgen::InsensitiveStr::Ascii("perding"),
        dictgen::InsensitiveStr::Ascii("perds"),
        dictgen::InsensitiveStr::Ascii("re"),
        dictgen::InsensitiveStr::Ascii("res"),
    ],
    values: &[
        &["shepherd"],
        &["shepherded"],
        &["shepherding"],
        &["shepherds"],
        &["shape"],
        &["shaped", "shepherd"],
        &["shepherd"],
        &["shepherdly"],
        &["shepherds"],
        &["shapes"],
        &["shepherd"],
        &["shepherd"],
        &["shepherd"],
        &["shaping"],
        &["shepherd"],
        &["shepherded"],
        &["shepherding"],
        &["shepherds"],
        &["sphere"],
        &["spheres"],
    ],
    range: 1..=7,
};

static WORD_SHEN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SHEN_CHILDREN),
    value: None,
};

pub static WORD_SHEN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("adigans"),
        dictgen::InsensitiveStr::Ascii("anagans"),
        dictgen::InsensitiveStr::Ascii("anagins"),
        dictgen::InsensitiveStr::Ascii("anegans"),
        dictgen::InsensitiveStr::Ascii("anegins"),
        dictgen::InsensitiveStr::Ascii("angians"),
        dictgen::InsensitiveStr::Ascii("anigains"),
        dictgen::InsensitiveStr::Ascii("anigangs"),
        dictgen::InsensitiveStr::Ascii("aniganns"),
        dictgen::InsensitiveStr::Ascii("anigens"),
        dictgen::InsensitiveStr::Ascii("anighans"),
        dictgen::InsensitiveStr::Ascii("anigins"),
        dictgen::InsensitiveStr::Ascii("enigans"),
        dictgen::InsensitiveStr::Ascii("inigans"),
        dictgen::InsensitiveStr::Ascii("naigans"),
    ],
    values: &[
        &["shenanigans"],
        &["shenanigans"],
        &["shenanigans"],
        &["shenanigans"],
        &["shenanigans"],
        &["shenanigans"],
        &["shenanigans"],
        &["shenanigans"],
        &["shenanigans"],
        &["shenanigans"],
        &["shenanigans"],
        &["shenanigans"],
        &["shenanigans"],
        &["shenanigans"],
        &["shenanigans"],
    ],
    range: 7..=8,
};

static WORD_SHEM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SHEM_CHILDREN),
    value: None,
};

pub static WORD_SHEM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("e")],
    values: &[&["scheme", "shame"]],
    range: 1..=1,
};

static WORD_SHEL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SHEL_CHILDREN),
    value: None,
};

pub static WORD_SHEL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("terd"),
        dictgen::InsensitiveStr::Ascii("vers"),
        dictgen::InsensitiveStr::Ascii("veys"),
    ],
    values: &[&["sheltered"], &["shelves"], &["shelves"]],
    range: 4..=4,
};

static WORD_SHEI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SHEI_CHILDREN),
    value: None,
};

pub static WORD_SHEI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ld"),
        dictgen::InsensitiveStr::Ascii("lded"),
        dictgen::InsensitiveStr::Ascii("lding"),
        dictgen::InsensitiveStr::Ascii("lds"),
    ],
    values: &[&["shield"], &["shielded"], &["shielding"], &["shields"]],
    range: 2..=5,
};

static WORD_SHEE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SHEE_CHILDREN),
    value: None,
};

pub static WORD_SHEE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("lpe"),
        dictgen::InsensitiveStr::Ascii("pel"),
        dictgen::InsensitiveStr::Ascii("pherd"),
        dictgen::InsensitiveStr::Ascii("pherds"),
        dictgen::InsensitiveStr::Ascii("ps"),
    ],
    values: &[
        &["sheeple"],
        &["sheeple"],
        &["shepherd"],
        &["shepherds"],
        &["sheep"],
    ],
    range: 2..=6,
};

static WORD_SHED_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SHED_CHILDREN),
    value: None,
};

pub static WORD_SHED_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ule"),
        dictgen::InsensitiveStr::Ascii("uled"),
        dictgen::InsensitiveStr::Ascii("ules"),
        dictgen::InsensitiveStr::Ascii("uling"),
    ],
    values: &[
        &["schedule"],
        &["scheduled"],
        &["schedules"],
        &["scheduling"],
    ],
    range: 3..=5,
};

static WORD_SHEC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SHEC_CHILDREN),
    value: None,
};

pub static WORD_SHEC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("k"),
        dictgen::InsensitiveStr::Ascii("ked"),
        dictgen::InsensitiveStr::Ascii("ker"),
        dictgen::InsensitiveStr::Ascii("king"),
        dictgen::InsensitiveStr::Ascii("ks"),
    ],
    values: &[
        &["check", "shuck"],
        &["checked", "shucked"],
        &["checker", "shucker"],
        &["checking", "shucking"],
        &["checks", "shucks"],
    ],
    range: 1..=4,
};

static WORD_SHEA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SHEA_CHILDREN),
    value: None,
};

pub static WORD_SHEA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("kspeare"),
        dictgen::InsensitiveStr::Ascii("t"),
    ],
    values: &[&["shakespeare"], &["sheath", "sheet", "cheat"]],
    range: 1..=7,
};

static WORD_SHC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SHC_CHILDREN),
    value: None,
};

pub static WORD_SHC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("emes"),
        dictgen::InsensitiveStr::Ascii("izophrenic"),
        dictgen::InsensitiveStr::Ascii("olars"),
        dictgen::InsensitiveStr::Ascii("ooled"),
    ],
    values: &[
        &["schemes"],
        &["schizophrenic"],
        &["scholars"],
        &["schooled"],
    ],
    range: 4..=10,
};

static WORD_SHB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SHB_CHILDREN),
    value: None,
};

pub static WORD_SHB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ang")],
    values: &[&["shebang"]],
    range: 3..=3,
};

static WORD_SHA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_SHA_CHILDREN),
    value: None,
};

static WORD_SHA_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    None,
    Some(&WORD_SHAD_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_SHAK_NODE),
    Some(&WORD_SHAL_NODE),
    Some(&WORD_SHAM_NODE),
    Some(&WORD_SHAN_NODE),
    None,
    Some(&WORD_SHAP_NODE),
    None,
    Some(&WORD_SHAR_NODE),
    Some(&WORD_SHAS_NODE),
    Some(&WORD_SHAT_NODE),
    None,
    None,
    Some(&WORD_SHAW_NODE),
    None,
    None,
    None,
];

static WORD_SHAW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SHAW_CHILDREN),
    value: None,
};

pub static WORD_SHAW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("hsank"),
        dictgen::InsensitiveStr::Ascii("shak"),
    ],
    values: &[&["shawshank"], &["shawshank"]],
    range: 4..=5,
};

static WORD_SHAT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SHAT_CHILDREN),
    value: None,
};

pub static WORD_SHAT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("nering"),
        dictgen::InsensitiveStr::Ascii("ow"),
        dictgen::InsensitiveStr::Ascii("ows"),
        dictgen::InsensitiveStr::Ascii("tening"),
        dictgen::InsensitiveStr::Ascii("terling"),
        dictgen::InsensitiveStr::Ascii("terring"),
    ],
    values: &[
        &["shattering"],
        &["château", "châteaux", "shadow"],
        &["châteaus", "châteaux", "shadows"],
        &["shattering"],
        &["shattering"],
        &["shattering"],
    ],
    range: 2..=7,
};

static WORD_SHAS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SHAS_CHILDREN),
    value: None,
};

pub static WORD_SHAS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("hes")],
    values: &[&["slashes"]],
    range: 3..=3,
};

static WORD_SHAR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SHAR_CHILDREN),
    value: None,
};

pub static WORD_SHAR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("dholders"),
        dictgen::InsensitiveStr::Ascii("eed"),
        dictgen::InsensitiveStr::Ascii("eholdes"),
        dictgen::InsensitiveStr::Ascii("eholds"),
        dictgen::InsensitiveStr::Ascii("eing"),
        dictgen::InsensitiveStr::Ascii("ipe"),
        dictgen::InsensitiveStr::Ascii("kening"),
        dictgen::InsensitiveStr::Ascii("loton"),
        dictgen::InsensitiveStr::Ascii("peneing"),
        dictgen::InsensitiveStr::Ascii("penning"),
        dictgen::InsensitiveStr::Ascii("penss"),
        dictgen::InsensitiveStr::Ascii("pining"),
        dictgen::InsensitiveStr::Ascii("play"),
        dictgen::InsensitiveStr::Ascii("pley"),
        dictgen::InsensitiveStr::Ascii("raid"),
        dictgen::InsensitiveStr::Ascii("raids"),
        dictgen::InsensitiveStr::Ascii("tening"),
    ],
    values: &[
        &["shareholders"],
        &["shared"],
        &["shareholders"],
        &["shareholders"],
        &["sharing"],
        &["sharpie"],
        &["sharpening"],
        &["charlatan"],
        &["sharpening"],
        &["sharpening"],
        &["sharpness"],
        &["sharpening"],
        &["sharply"],
        &["sharply"],
        &["charade"],
        &["charades"],
        &["sharpening"],
    ],
    range: 3..=8,
};

static WORD_SHAP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SHAP_CHILDREN),
    value: None,
};

pub static WORD_SHAP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("rening"),
        dictgen::InsensitiveStr::Ascii("rie"),
        dictgen::InsensitiveStr::Ascii("rly"),
        dictgen::InsensitiveStr::Ascii("rness"),
        dictgen::InsensitiveStr::Ascii("shot"),
        dictgen::InsensitiveStr::Ascii("shots"),
        dictgen::InsensitiveStr::Ascii("snot"),
        dictgen::InsensitiveStr::Ascii("snots"),
        dictgen::InsensitiveStr::Ascii("t"),
    ],
    values: &[
        &["sharpening"],
        &["sharpie"],
        &["sharply"],
        &["sharpness"],
        &["snapshot"],
        &["snapshots"],
        &["snapshot"],
        &["snapshots"],
        &["shape", "shaped"],
    ],
    range: 1..=6,
};

static WORD_SHAN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SHAN_CHILDREN),
    value: None,
};

pub static WORD_SHAN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("deleer"),
        dictgen::InsensitiveStr::Ascii("deleers"),
        dictgen::InsensitiveStr::Ascii("dow"),
        dictgen::InsensitiveStr::Ascii("eal"),
        dictgen::InsensitiveStr::Ascii("enigans"),
        dictgen::InsensitiveStr::Ascii("gahi"),
        dictgen::InsensitiveStr::Ascii("ge"),
        dictgen::InsensitiveStr::Ascii("ged"),
        dictgen::InsensitiveStr::Ascii("ger"),
        dictgen::InsensitiveStr::Ascii("ges"),
        dictgen::InsensitiveStr::Ascii("ghi"),
        dictgen::InsensitiveStr::Ascii("ghia"),
        dictgen::InsensitiveStr::Ascii("ging"),
    ],
    values: &[
        &["chandelier"],
        &["chandeliers"],
        &["shadow"],
        &["chenille"],
        &["shenanigans"],
        &["shanghai"],
        &["change"],
        &["changed", "shanked"],
        &["changer"],
        &["changes"],
        &["shanghai"],
        &["shanghai"],
        &["changing", "shanking"],
    ],
    range: 2..=7,
};

static WORD_SHAM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SHAM_CHILDREN),
    value: None,
};

pub static WORD_SHAM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("elesly"),
        dictgen::InsensitiveStr::Ascii("elessely"),
        dictgen::InsensitiveStr::Ascii("elessley"),
        dictgen::InsensitiveStr::Ascii("elessy"),
        dictgen::InsensitiveStr::Ascii("en"),
        dictgen::InsensitiveStr::Ascii("pionship"),
    ],
    values: &[
        &["shamelessly"],
        &["shamelessly"],
        &["shamelessly"],
        &["shamelessly"],
        &["shaman", "shamans"],
        &["championship"],
    ],
    range: 2..=8,
};

static WORD_SHAL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SHAL_CHILDREN),
    value: Some(&["shall"]),
};

pub static WORD_SHAL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[],
    values: &[],
    range: 0..=0,
};

static WORD_SHAK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SHAK_CHILDREN),
    value: None,
};

pub static WORD_SHAK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eapeare"),
        dictgen::InsensitiveStr::Ascii("epseare"),
        dictgen::InsensitiveStr::Ascii("espare"),
        dictgen::InsensitiveStr::Ascii("espeer"),
        dictgen::InsensitiveStr::Ascii("espere"),
        dictgen::InsensitiveStr::Ascii("esperean"),
        dictgen::InsensitiveStr::Ascii("esphere"),
    ],
    values: &[
        &["shakespeare"],
        &["shakespeare"],
        &["shakespeare"],
        &["shakespeare"],
        &["shakespeare"],
        &["shakespeare"],
        &["shakespeare"],
    ],
    range: 6..=8,
};

static WORD_SHAD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SHAD_CHILDREN),
    value: None,
};

pub static WORD_SHAD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("asloo"),
        dictgen::InsensitiveStr::Ascii("der"),
        dictgen::InsensitiveStr::Ascii("dow"),
        dictgen::InsensitiveStr::Ascii("how"),
        dictgen::InsensitiveStr::Ascii("oloo"),
    ],
    values: &[
        &["shadaloo"],
        &["shader"],
        &["shadow"],
        &["shadow"],
        &["shadaloo"],
    ],
    range: 3..=5,
};

static WORD_SG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SG_CHILDREN),
    value: None,
};

pub static WORD_SG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("adow")],
    values: &[&["shadow"]],
    range: 4..=4,
};

static WORD_SF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SF_CHILDREN),
    value: None,
};

pub static WORD_SF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ety")],
    values: &[&["safety"]],
    range: 3..=3,
};

static WORD_SE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_SE_CHILDREN),
    value: None,
};

static WORD_SE_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_SEA_NODE),
    Some(&WORD_SEB_NODE),
    Some(&WORD_SEC_NODE),
    Some(&WORD_SED_NODE),
    Some(&WORD_SEE_NODE),
    Some(&WORD_SEF_NODE),
    Some(&WORD_SEG_NODE),
    Some(&WORD_SEH_NODE),
    Some(&WORD_SEI_NODE),
    None,
    Some(&WORD_SEK_NODE),
    Some(&WORD_SEL_NODE),
    Some(&WORD_SEM_NODE),
    Some(&WORD_SEN_NODE),
    Some(&WORD_SEO_NODE),
    Some(&WORD_SEP_NODE),
    Some(&WORD_SEQ_NODE),
    Some(&WORD_SER_NODE),
    Some(&WORD_SES_NODE),
    Some(&WORD_SET_NODE),
    Some(&WORD_SEU_NODE),
    Some(&WORD_SEV_NODE),
    Some(&WORD_SEW_NODE),
    Some(&WORD_SEX_NODE),
    None,
    Some(&WORD_SEZ_NODE),
];

static WORD_SEZ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SEZ_CHILDREN),
    value: None,
};

pub static WORD_SEZ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("iure"),
        dictgen::InsensitiveStr::Ascii("iures"),
        dictgen::InsensitiveStr::Ascii("uires"),
    ],
    values: &[&["seizure"], &["seizures"], &["seizures"]],
    range: 4..=5,
};

static WORD_SEX_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SEX_CHILDREN),
    value: None,
};

pub static WORD_SEX_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aulized"),
        dictgen::InsensitiveStr::Ascii("aully"),
        dictgen::InsensitiveStr::Ascii("ualixed"),
        dictgen::InsensitiveStr::Ascii("ualizd"),
        dictgen::InsensitiveStr::Ascii("ualizied"),
        dictgen::InsensitiveStr::Ascii("uallity"),
        dictgen::InsensitiveStr::Ascii("uallly"),
        dictgen::InsensitiveStr::Ascii("ualy"),
        dictgen::InsensitiveStr::Ascii("ualzied"),
        dictgen::InsensitiveStr::Ascii("ulaized"),
    ],
    values: &[
        &["sexualized"],
        &["sexually"],
        &["sexualized"],
        &["sexualized"],
        &["sexualized"],
        &["sexually"],
        &["sexually"],
        &["sexually"],
        &["sexualized"],
        &["sexualized"],
    ],
    range: 4..=8,
};

static WORD_SEW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SEW_CHILDREN),
    value: None,
};

pub static WORD_SEW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("donim"),
        dictgen::InsensitiveStr::Ascii("donims"),
        dictgen::InsensitiveStr::Ascii("rvice"),
    ],
    values: &[&["pseudonym"], &["pseudonyms"], &["service"]],
    range: 5..=6,
};

static WORD_SEV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SEV_CHILDREN),
    value: None,
};

pub static WORD_SEV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aral"),
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("enteeen"),
        dictgen::InsensitiveStr::Ascii("enten"),
        dictgen::InsensitiveStr::Ascii("erat"),
        dictgen::InsensitiveStr::Ascii("ereal"),
        dictgen::InsensitiveStr::Ascii("ereid"),
        dictgen::InsensitiveStr::Ascii("eride"),
        dictgen::InsensitiveStr::Ascii("eririrty"),
        dictgen::InsensitiveStr::Ascii("eririties"),
        dictgen::InsensitiveStr::Ascii("erite"),
        dictgen::InsensitiveStr::Ascii("erites"),
        dictgen::InsensitiveStr::Ascii("eritie"),
        dictgen::InsensitiveStr::Ascii("eriy"),
        dictgen::InsensitiveStr::Ascii("erl"),
        dictgen::InsensitiveStr::Ascii("erley"),
        dictgen::InsensitiveStr::Ascii("erly"),
        dictgen::InsensitiveStr::Ascii("ice"),
        dictgen::InsensitiveStr::Ascii("iced"),
        dictgen::InsensitiveStr::Ascii("ices"),
        dictgen::InsensitiveStr::Ascii("icing"),
        dictgen::InsensitiveStr::Ascii("irity"),
        dictgen::InsensitiveStr::Ascii("ral"),
        dictgen::InsensitiveStr::Ascii("rally"),
        dictgen::InsensitiveStr::Ascii("rity"),
    ],
    values: &[
        &["several"],
        &["save", "sieve"],
        &["seventeen"],
        &["seventeen"],
        &["several"],
        &["several"],
        &["severed"],
        &["severed"],
        &["severity"],
        &["severities"],
        &["severity"],
        &["severities"],
        &["severity", "severities"],
        &["severity"],
        &["several"],
        &["severely"],
        &["severely"],
        &["service"],
        &["serviced"],
        &["services"],
        &["servicing"],
        &["severity"],
        &["several"],
        &["severally"],
        &["severity"],
    ],
    range: 1..=9,
};

static WORD_SEU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SEU_CHILDREN),
    value: None,
};

pub static WORD_SEU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ence"),
        dictgen::InsensitiveStr::Ascii("ences"),
        dictgen::InsensitiveStr::Ascii("xalized"),
    ],
    values: &[&["sequence"], &["sequences"], &["sexualized"]],
    range: 4..=7,
};

static WORD_SET_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SET_CHILDREN),
    value: None,
};

pub static WORD_SET_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("evn"),
        dictgen::InsensitiveStr::Ascii("git"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("ings"),
        dictgen::InsensitiveStr::Ascii("ion"),
        dictgen::InsensitiveStr::Ascii("ions"),
        dictgen::InsensitiveStr::Ascii("is"),
        dictgen::InsensitiveStr::Ascii("itng"),
        dictgen::InsensitiveStr::Ascii("itngs"),
        dictgen::InsensitiveStr::Ascii("quential"),
        dictgen::InsensitiveStr::Ascii("ted"),
        dictgen::InsensitiveStr::Ascii("telement"),
        dictgen::InsensitiveStr::Ascii("telment"),
        dictgen::InsensitiveStr::Ascii("telments"),
        dictgen::InsensitiveStr::Ascii("tign"),
        dictgen::InsensitiveStr::Ascii("tigns"),
        dictgen::InsensitiveStr::Ascii("tigs"),
        dictgen::InsensitiveStr::Ascii("tiing"),
        dictgen::InsensitiveStr::Ascii("tiings"),
        dictgen::InsensitiveStr::Ascii("tinga"),
        dictgen::InsensitiveStr::Ascii("tingss"),
        dictgen::InsensitiveStr::Ascii("tins"),
        dictgen::InsensitiveStr::Ascii("tlemens"),
        dictgen::InsensitiveStr::Ascii("tlemetns"),
        dictgen::InsensitiveStr::Ascii("tlemets"),
        dictgen::InsensitiveStr::Ascii("tlemnts"),
        dictgen::InsensitiveStr::Ascii("tlment"),
        dictgen::InsensitiveStr::Ascii("tng"),
        dictgen::InsensitiveStr::Ascii("tter"),
        dictgen::InsensitiveStr::Ascii("tters"),
        dictgen::InsensitiveStr::Ascii("tting"),
        dictgen::InsensitiveStr::Ascii("ttings"),
        dictgen::InsensitiveStr::Ascii("tubg"),
        dictgen::InsensitiveStr::Ascii("tubgs"),
        dictgen::InsensitiveStr::Ascii("tup"),
        dictgen::InsensitiveStr::Ascii("yp"),
        dictgen::InsensitiveStr::Ascii("yps"),
    ],
    values: &[
        &["setenv"],
        &["setgid"],
        &["setting"],
        &["settings"],
        &["section"],
        &["sections"],
        &["settees"],
        &["setting"],
        &["settings"],
        &["sequential"],
        &["set"],
        &["settlement"],
        &["settlement"],
        &["settlements"],
        &["setting"],
        &["settings"],
        &["settings"],
        &["setting"],
        &["settings"],
        &["settings"],
        &["settings"],
        &["settings"],
        &["settlements"],
        &["settlements"],
        &["settlements"],
        &["settlements"],
        &["settlement"],
        &["setting"],
        &["setter"],
        &["setters"],
        &["setting"],
        &["settings"],
        &["setting", "setup"],
        &["settings", "setups"],
        &["setup"],
        &["setup"],
        &["setups"],
    ],
    range: 2..=8,
};

static WORD_SES_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SES_CHILDREN),
    value: None,
};

pub static WORD_SES_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cede"),
        dictgen::InsensitiveStr::Ascii("ceded"),
        dictgen::InsensitiveStr::Ascii("ceder"),
        dictgen::InsensitiveStr::Ascii("cedes"),
        dictgen::InsensitiveStr::Ascii("ceding"),
        dictgen::InsensitiveStr::Ascii("eed"),
        dictgen::InsensitiveStr::Ascii("eeded"),
        dictgen::InsensitiveStr::Ascii("eeder"),
        dictgen::InsensitiveStr::Ascii("eedes"),
        dictgen::InsensitiveStr::Ascii("eeding"),
        dictgen::InsensitiveStr::Ascii("eeds"),
        dictgen::InsensitiveStr::Ascii("ion"),
        dictgen::InsensitiveStr::Ascii("ions"),
        dictgen::InsensitiveStr::Ascii("itive"),
        dictgen::InsensitiveStr::Ascii("itively"),
        dictgen::InsensitiveStr::Ascii("itiveness"),
        dictgen::InsensitiveStr::Ascii("itivity"),
        dictgen::InsensitiveStr::Ascii("katchewan"),
        dictgen::InsensitiveStr::Ascii("nors"),
        dictgen::InsensitiveStr::Ascii("sio"),
        dictgen::InsensitiveStr::Ascii("sison"),
        dictgen::InsensitiveStr::Ascii("ssion"),
        dictgen::InsensitiveStr::Ascii("ssions"),
        dictgen::InsensitiveStr::Ascii("tatusbar"),
        dictgen::InsensitiveStr::Ascii("tatusmsg"),
    ],
    values: &[
        &["secede"],
        &["seceded"],
        &["seceder"],
        &["secedes"],
        &["seceding"],
        &["secede"],
        &["seceded"],
        &["seceder"],
        &["secedes"],
        &["seceding"],
        &["secedes"],
        &["session"],
        &["sessions"],
        &["sensitive"],
        &["sensitively"],
        &["sensitiveness"],
        &["sensitivity"],
        &["saskatchewan"],
        &["sensors"],
        &["session"],
        &["session"],
        &["session"],
        &["sessions"],
        &["setstatusbar"],
        &["setstatusmsg"],
    ],
    range: 3..=9,
};

static WORD_SER_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_SER_CHILDREN),
    value: Some(&["set"]),
};

static WORD_SER_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_SERA_NODE),
    Some(&WORD_SERB_NODE),
    Some(&WORD_SERC_NODE),
    None,
    Some(&WORD_SERE_NODE),
    None,
    Some(&WORD_SERG_NODE),
    None,
    Some(&WORD_SERI_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_SERO_NODE),
    None,
    None,
    Some(&WORD_SERR_NODE),
    Some(&WORD_SERS_NODE),
    Some(&WORD_SERT_NODE),
    None,
    Some(&WORD_SERV_NODE),
    Some(&WORD_SERW_NODE),
    None,
    None,
    None,
];

static WORD_SERW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SERW_CHILDREN),
    value: None,
};

pub static WORD_SERW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("er")],
    values: &[&["server", "sewer"]],
    range: 2..=2,
};

static WORD_SERV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SERV_CHILDREN),
    value: None,
};

pub static WORD_SERV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ans"),
        dictgen::InsensitiveStr::Ascii("antes"),
        dictgen::InsensitiveStr::Ascii("ce"),
        dictgen::InsensitiveStr::Ascii("ced"),
        dictgen::InsensitiveStr::Ascii("ces"),
        dictgen::InsensitiveStr::Ascii("cie"),
        dictgen::InsensitiveStr::Ascii("cies"),
        dictgen::InsensitiveStr::Ascii("cing"),
        dictgen::InsensitiveStr::Ascii("ece"),
        dictgen::InsensitiveStr::Ascii("eced"),
        dictgen::InsensitiveStr::Ascii("eces"),
        dictgen::InsensitiveStr::Ascii("ecing"),
        dictgen::InsensitiveStr::Ascii("eice"),
        dictgen::InsensitiveStr::Ascii("eiced"),
        dictgen::InsensitiveStr::Ascii("eices"),
        dictgen::InsensitiveStr::Ascii("eicing"),
        dictgen::InsensitiveStr::Ascii("eillance"),
        dictgen::InsensitiveStr::Ascii("eless"),
        dictgen::InsensitiveStr::Ascii("eral"),
        dictgen::InsensitiveStr::Ascii("erite"),
        dictgen::InsensitiveStr::Ascii("erites"),
        dictgen::InsensitiveStr::Ascii("eritie"),
        dictgen::InsensitiveStr::Ascii("erities"),
        dictgen::InsensitiveStr::Ascii("erity"),
        dictgen::InsensitiveStr::Ascii("erles"),
        dictgen::InsensitiveStr::Ascii("erlesss"),
        dictgen::InsensitiveStr::Ascii("erlsss"),
        dictgen::InsensitiveStr::Ascii("iceble"),
        dictgen::InsensitiveStr::Ascii("iciable"),
        dictgen::InsensitiveStr::Ascii("icies"),
        dictgen::InsensitiveStr::Ascii("ie"),
        dictgen::InsensitiveStr::Ascii("ier"),
        dictgen::InsensitiveStr::Ascii("ies"),
        dictgen::InsensitiveStr::Ascii("ise"),
        dictgen::InsensitiveStr::Ascii("ised"),
        dictgen::InsensitiveStr::Ascii("ises"),
        dictgen::InsensitiveStr::Ascii("ising"),
        dictgen::InsensitiveStr::Ascii("ive"),
        dictgen::InsensitiveStr::Ascii("oce"),
        dictgen::InsensitiveStr::Ascii("oced"),
        dictgen::InsensitiveStr::Ascii("oces"),
        dictgen::InsensitiveStr::Ascii("ocing"),
    ],
    values: &[
        &["servants"],
        &["servants"],
        &["service", "serve"],
        &["serviced", "served"],
        &["services", "serves"],
        &["service"],
        &["services"],
        &["servicing", "serving"],
        &["service"],
        &["serviced"],
        &["services"],
        &["servicing"],
        &["service"],
        &["serviced"],
        &["services"],
        &["servicing"],
        &["surveillance"],
        &["serverless"],
        &["several"],
        &["severity"],
        &["severities"],
        &["severity", "severities"],
        &["severities"],
        &["severity"],
        &["serverless"],
        &["serverless"],
        &["serverless"],
        &["serviceable"],
        &["serviceable"],
        &["services"],
        &["service"],
        &["server"],
        &["services"],
        &["service"],
        &["serviced"],
        &["services"],
        &["servicing"],
        &["service"],
        &["service"],
        &["serviced"],
        &["services"],
        &["servicing"],
    ],
    range: 2..=8,
};

static WORD_SERT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SERT_CHILDREN),
    value: None,
};

pub static WORD_SERT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ificate"),
        dictgen::InsensitiveStr::Ascii("ificated"),
        dictgen::InsensitiveStr::Ascii("ificates"),
        dictgen::InsensitiveStr::Ascii("ification"),
    ],
    values: &[
        &["certificate"],
        &["certificated"],
        &["certificates"],
        &["certification"],
    ],
    range: 7..=9,
};

static WORD_SERS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SERS_CHILDREN),
    value: None,
};

pub static WORD_SERS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ies")],
    values: &[&["series"]],
    range: 3..=3,
};

static WORD_SERR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SERR_CHILDREN),
    value: None,
};

pub static WORD_SERR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ebral"),
        dictgen::InsensitiveStr::Ascii("ebrally"),
    ],
    values: &[&["cerebral"], &["cerebrally"]],
    range: 5..=7,
};

static WORD_SERO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SERO_CHILDREN),
    value: None,
};

pub static WORD_SERO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("und"),
        dictgen::InsensitiveStr::Ascii("unded"),
        dictgen::InsensitiveStr::Ascii("unding"),
        dictgen::InsensitiveStr::Ascii("unds"),
    ],
    values: &[
        &["surround"],
        &["surrounded"],
        &["surrounding"],
        &["surrounds"],
    ],
    range: 3..=6,
};

static WORD_SERI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SERI_CHILDREN),
    value: None,
};

pub static WORD_SERI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("alialisation"),
        dictgen::InsensitiveStr::Ascii("alialise"),
        dictgen::InsensitiveStr::Ascii("alialised"),
        dictgen::InsensitiveStr::Ascii("alialises"),
        dictgen::InsensitiveStr::Ascii("alialising"),
        dictgen::InsensitiveStr::Ascii("alialization"),
        dictgen::InsensitiveStr::Ascii("alialize"),
        dictgen::InsensitiveStr::Ascii("alialized"),
        dictgen::InsensitiveStr::Ascii("alializes"),
        dictgen::InsensitiveStr::Ascii("alializing"),
        dictgen::InsensitiveStr::Ascii("aliasation"),
        dictgen::InsensitiveStr::Ascii("aliazation"),
        dictgen::InsensitiveStr::Ascii("alsiation"),
        dictgen::InsensitiveStr::Ascii("alsie"),
        dictgen::InsensitiveStr::Ascii("alsied"),
        dictgen::InsensitiveStr::Ascii("alsies"),
        dictgen::InsensitiveStr::Ascii("alsing"),
        dictgen::InsensitiveStr::Ascii("alziation"),
        dictgen::InsensitiveStr::Ascii("alzie"),
        dictgen::InsensitiveStr::Ascii("alzied"),
        dictgen::InsensitiveStr::Ascii("alzies"),
        dictgen::InsensitiveStr::Ascii("alzing"),
        dictgen::InsensitiveStr::Ascii("ban"),
        dictgen::InsensitiveStr::Ascii("ce"),
        dictgen::InsensitiveStr::Ascii("ces"),
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("el"),
        dictgen::InsensitiveStr::Ascii("eses"),
        dictgen::InsensitiveStr::Ascii("monial"),
        dictgen::InsensitiveStr::Ascii("monies"),
        dictgen::InsensitiveStr::Ascii("mony"),
        dictgen::InsensitiveStr::Ascii("monys"),
        dictgen::InsensitiveStr::Ascii("nomial"),
        dictgen::InsensitiveStr::Ascii("nomies"),
        dictgen::InsensitiveStr::Ascii("nomy"),
        dictgen::InsensitiveStr::Ascii("nomys"),
        dictgen::InsensitiveStr::Ascii("os"),
        dictgen::InsensitiveStr::Ascii("osuly"),
        dictgen::InsensitiveStr::Ascii("oulsy"),
        dictgen::InsensitiveStr::Ascii("ouly"),
        dictgen::InsensitiveStr::Ascii("ousally"),
        dictgen::InsensitiveStr::Ascii("ouslly"),
        dictgen::InsensitiveStr::Ascii("uos"),
        dictgen::InsensitiveStr::Ascii("uosly"),
        dictgen::InsensitiveStr::Ascii("vce"),
        dictgen::InsensitiveStr::Ascii("vceable"),
        dictgen::InsensitiveStr::Ascii("vces"),
    ],
    values: &[
        &["serialisation"],
        &["serialise"],
        &["serialised"],
        &["serialises"],
        &["serialising"],
        &["serialization"],
        &["serialize"],
        &["serialized"],
        &["serializes"],
        &["serializing"],
        &["serialisation"],
        &["serialization"],
        &["serialisation"],
        &["serialise"],
        &["serialised"],
        &["serialises"],
        &["serialising"],
        &["serialization"],
        &["serialize"],
        &["serialized"],
        &["serializes"],
        &["serializing"],
        &["serbian"],
        &["service"],
        &["services", "series"],
        &["series"],
        &["serial"],
        &["series"],
        &["ceremonial"],
        &["ceremonies"],
        &["ceremony"],
        &["ceremonies"],
        &["ceremonial"],
        &["ceremonies"],
        &["ceremony"],
        &["ceremonies"],
        &["serious"],
        &["seriously"],
        &["seriously"],
        &["seriously"],
        &["seriously"],
        &["seriously"],
        &["serious"],
        &["seriously"],
        &["service"],
        &["serviceable"],
        &["services"],
    ],
    range: 1..=12,
};

static WORD_SERG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SERG_CHILDREN),
    value: None,
};

pub static WORD_SERG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aent"),
        dictgen::InsensitiveStr::Ascii("eat"),
        dictgen::InsensitiveStr::Ascii("ent"),
        dictgen::InsensitiveStr::Ascii("un"),
        dictgen::InsensitiveStr::Ascii("uns"),
    ],
    values: &[
        &["sergeant"],
        &["sergeant"],
        &["sergeant"],
        &["surgeon"],
        &["surgeons"],
    ],
    range: 2..=4,
};

static WORD_SERE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SERE_CHILDREN),
    value: None,
};

pub static WORD_SERE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("bral"),
        dictgen::InsensitiveStr::Ascii("brally"),
        dictgen::InsensitiveStr::Ascii("nitary"),
        dictgen::InsensitiveStr::Ascii("ntiy"),
        dictgen::InsensitiveStr::Ascii("ous"),
        dictgen::InsensitiveStr::Ascii("ousally"),
        dictgen::InsensitiveStr::Ascii("ouslly"),
        dictgen::InsensitiveStr::Ascii("ously"),
        dictgen::InsensitiveStr::Ascii("verless"),
        dictgen::InsensitiveStr::Ascii("vrless"),
    ],
    values: &[
        &["cerebral"],
        &["cerebrally"],
        &["serenity"],
        &["serenity"],
        &["serious", "serous"],
        &["seriously"],
        &["seriously"],
        &["seriously"],
        &["serverless"],
        &["serverless"],
    ],
    range: 3..=7,
};

static WORD_SERC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SERC_CHILDREN),
    value: None,
};

pub static WORD_SERC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("h"),
        dictgen::InsensitiveStr::Ascii("hed"),
        dictgen::InsensitiveStr::Ascii("hes"),
        dictgen::InsensitiveStr::Ascii("hing"),
        dictgen::InsensitiveStr::Ascii("ive"),
        dictgen::InsensitiveStr::Ascii("ived"),
        dictgen::InsensitiveStr::Ascii("ives"),
        dictgen::InsensitiveStr::Ascii("iving"),
        dictgen::InsensitiveStr::Ascii("urity"),
    ],
    values: &[
        &["search"],
        &["searched"],
        &["searches"],
        &["searching"],
        &["service"],
        &["serviced"],
        &["services"],
        &["servicing"],
        &["security"],
    ],
    range: 1..=5,
};

static WORD_SERB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SERB_CHILDREN),
    value: None,
};

pub static WORD_SERB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ain")],
    values: &[&["serbian"]],
    range: 3..=3,
};

static WORD_SERA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SERA_CHILDREN),
    value: None,
};

pub static WORD_SERA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ch"),
        dictgen::InsensitiveStr::Ascii("ched"),
        dictgen::InsensitiveStr::Ascii("cher"),
        dictgen::InsensitiveStr::Ascii("ches"),
        dictgen::InsensitiveStr::Ascii("ching"),
        dictgen::InsensitiveStr::Ascii("chs"),
        dictgen::InsensitiveStr::Ascii("ilisation"),
        dictgen::InsensitiveStr::Ascii("ilise"),
        dictgen::InsensitiveStr::Ascii("ilised"),
        dictgen::InsensitiveStr::Ascii("ilization"),
        dictgen::InsensitiveStr::Ascii("ilize"),
        dictgen::InsensitiveStr::Ascii("ilized"),
        dictgen::InsensitiveStr::Ascii("ilse"),
        dictgen::InsensitiveStr::Ascii("ilsed"),
        dictgen::InsensitiveStr::Ascii("ilze"),
        dictgen::InsensitiveStr::Ascii("ilzed"),
        dictgen::InsensitiveStr::Ascii("ilzied"),
        dictgen::InsensitiveStr::Ascii("lize"),
        dictgen::InsensitiveStr::Ascii("lized"),
        dictgen::InsensitiveStr::Ascii("lizes"),
        dictgen::InsensitiveStr::Ascii("lizing"),
        dictgen::InsensitiveStr::Ascii("monial"),
        dictgen::InsensitiveStr::Ascii("monies"),
        dictgen::InsensitiveStr::Ascii("mony"),
        dictgen::InsensitiveStr::Ascii("monys"),
        dictgen::InsensitiveStr::Ascii("nomial"),
        dictgen::InsensitiveStr::Ascii("nomies"),
        dictgen::InsensitiveStr::Ascii("nomy"),
        dictgen::InsensitiveStr::Ascii("nomys"),
    ],
    values: &[
        &["search"],
        &["searched"],
        &["searcher"],
        &["searches"],
        &["searching"],
        &["searches"],
        &["serialisation"],
        &["serialise"],
        &["serialised"],
        &["serialization"],
        &["serialize"],
        &["serialized"],
        &["serialise"],
        &["serialised"],
        &["serialize"],
        &["serialized"],
        &["serialized"],
        &["serialize"],
        &["serialized"],
        &["serializes"],
        &["serializing"],
        &["ceremonial"],
        &["ceremonies"],
        &["ceremony"],
        &["ceremonies"],
        &["ceremonial"],
        &["ceremonies"],
        &["ceremony"],
        &["ceremonies"],
    ],
    range: 2..=9,
};

static WORD_SEQ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SEQ_CHILDREN),
    value: None,
};

pub static WORD_SEQ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ence"),
        dictgen::InsensitiveStr::Ascii("enced"),
        dictgen::InsensitiveStr::Ascii("ences"),
        dictgen::InsensitiveStr::Ascii("encing"),
        dictgen::InsensitiveStr::Ascii("ense"),
        dictgen::InsensitiveStr::Ascii("ensed"),
        dictgen::InsensitiveStr::Ascii("enses"),
        dictgen::InsensitiveStr::Ascii("ensing"),
        dictgen::InsensitiveStr::Ascii("enstial"),
        dictgen::InsensitiveStr::Ascii("ential"),
        dictgen::InsensitiveStr::Ascii("euence"),
        dictgen::InsensitiveStr::Ascii("euencer"),
        dictgen::InsensitiveStr::Ascii("euental"),
        dictgen::InsensitiveStr::Ascii("eunce"),
        dictgen::InsensitiveStr::Ascii("euncer"),
        dictgen::InsensitiveStr::Ascii("euntials"),
        dictgen::InsensitiveStr::Ascii("uantial"),
        dictgen::InsensitiveStr::Ascii("ucne"),
        dictgen::InsensitiveStr::Ascii("uece"),
        dictgen::InsensitiveStr::Ascii("uecence"),
        dictgen::InsensitiveStr::Ascii("uecences"),
        dictgen::InsensitiveStr::Ascii("ueces"),
        dictgen::InsensitiveStr::Ascii("ueence"),
        dictgen::InsensitiveStr::Ascii("uelce"),
        dictgen::InsensitiveStr::Ascii("uemce"),
        dictgen::InsensitiveStr::Ascii("uemces"),
        dictgen::InsensitiveStr::Ascii("uencial"),
        dictgen::InsensitiveStr::Ascii("uencially"),
        dictgen::InsensitiveStr::Ascii("uencies"),
        dictgen::InsensitiveStr::Ascii("uenes"),
        dictgen::InsensitiveStr::Ascii("uense"),
        dictgen::InsensitiveStr::Ascii("uensed"),
        dictgen::InsensitiveStr::Ascii("uenses"),
        dictgen::InsensitiveStr::Ascii("uensing"),
        dictgen::InsensitiveStr::Ascii("uenstial"),
        dictgen::InsensitiveStr::Ascii("uentialy"),
        dictgen::InsensitiveStr::Ascii("uenzes"),
        dictgen::InsensitiveStr::Ascii("uetial"),
        dictgen::InsensitiveStr::Ascii("ueze"),
        dictgen::InsensitiveStr::Ascii("unce"),
        dictgen::InsensitiveStr::Ascii("unced"),
        dictgen::InsensitiveStr::Ascii("uncer"),
        dictgen::InsensitiveStr::Ascii("uncers"),
        dictgen::InsensitiveStr::Ascii("unces"),
        dictgen::InsensitiveStr::Ascii("unece"),
        dictgen::InsensitiveStr::Ascii("uneces"),
    ],
    values: &[
        &["sequence"],
        &["sequenced"],
        &["sequences"],
        &["sequencing"],
        &["sequence"],
        &["sequenced"],
        &["sequences"],
        &["sequencing"],
        &["sequential"],
        &["sequential"],
        &["sequence"],
        &["sequencer"],
        &["sequential"],
        &["sequence"],
        &["sequencer"],
        &["sequentials"],
        &["sequential"],
        &["sequence"],
        &["sequence"],
        &["sequence"],
        &["sequences"],
        &["sequences"],
        &["sequence"],
        &["sequence"],
        &["sequence"],
        &["sequences"],
        &["sequential"],
        &["sequentially"],
        &["sequences"],
        &["sequences"],
        &["sequence"],
        &["sequenced"],
        &["sequences"],
        &["sequencing"],
        &["sequential"],
        &["sequentially"],
        &["sequences"],
        &["sequential"],
        &["squeeze", "sequence"],
        &["sequence"],
        &["sequenced"],
        &["sequencer"],
        &["sequencers"],
        &["sequences"],
        &["sequence"],
        &["sequences"],
    ],
    range: 4..=9,
};

static WORD_SEP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_SEP_CHILDREN),
    value: None,
};

static WORD_SEP_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_SEPA_NODE),
    None,
    Some(&WORD_SEPC_NODE),
    None,
    Some(&WORD_SEPE_NODE),
    None,
    None,
    None,
    Some(&WORD_SEPI_NODE),
    None,
    None,
    Some(&WORD_SEPL_NODE),
    None,
    None,
    Some(&WORD_SEPO_NODE),
    Some(&WORD_SEPP_NODE),
    None,
    Some(&WORD_SEPR_NODE),
    None,
    Some(&WORD_SEPT_NODE),
    Some(&WORD_SEPU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_SEPU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SEPU_CHILDREN),
    value: None,
};

pub static WORD_SEPU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("lchraly"),
        dictgen::InsensitiveStr::Ascii("lchrlly"),
        dictgen::InsensitiveStr::Ascii("lchrly"),
        dictgen::InsensitiveStr::Ascii("lchure"),
        dictgen::InsensitiveStr::Ascii("lcre"),
    ],
    values: &[
        &["sepulchrally"],
        &["sepulchrally"],
        &["sepulchrally"],
        &["sepulchre"],
        &["sepulchre"],
    ],
    range: 4..=7,
};

static WORD_SEPT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SEPT_CHILDREN),
    value: None,
};

pub static WORD_SEPT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("emer"),
        dictgen::InsensitiveStr::Ascii("meber"),
    ],
    values: &[&["september"], &["september"]],
    range: 4..=5,
};

static WORD_SEPR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SEPR_CHILDREN),
    value: None,
};

pub static WORD_SEPR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aate"),
        dictgen::InsensitiveStr::Ascii("arate"),
        dictgen::InsensitiveStr::Ascii("ate"),
        dictgen::InsensitiveStr::Ascii("ated"),
        dictgen::InsensitiveStr::Ascii("ator"),
        dictgen::InsensitiveStr::Ascii("ators"),
        dictgen::InsensitiveStr::Ascii("eate"),
    ],
    values: &[
        &["separate"],
        &["separate"],
        &["separate"],
        &["separated"],
        &["separator"],
        &["separators"],
        &["separate"],
    ],
    range: 3..=5,
};

static WORD_SEPP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SEPP_CHILDREN),
    value: None,
};

pub static WORD_SEPP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aration"),
        dictgen::InsensitiveStr::Ascii("arations"),
        dictgen::InsensitiveStr::Ascii("erate"),
    ],
    values: &[&["separation"], &["separations"], &["separate"]],
    range: 5..=8,
};

static WORD_SEPO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SEPO_CHILDREN),
    value: None,
};

pub static WORD_SEPO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("rate")],
    values: &[&["separate"]],
    range: 4..=4,
};

static WORD_SEPL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SEPL_CHILDREN),
    value: None,
};

pub static WORD_SEPL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("icural"),
        dictgen::InsensitiveStr::Ascii("icurally"),
        dictgen::InsensitiveStr::Ascii("icuraly"),
        dictgen::InsensitiveStr::Ascii("icurlly"),
        dictgen::InsensitiveStr::Ascii("ling"),
    ],
    values: &[
        &["sepulchral"],
        &["sepulchrally"],
        &["sepulchrally"],
        &["sepulchrally"],
        &["spelling"],
    ],
    range: 4..=8,
};

static WORD_SEPI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SEPI_CHILDREN),
    value: None,
};

pub static WORD_SEPI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("na")],
    values: &[&["subpena"]],
    range: 2..=2,
};

static WORD_SEPE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_SEPE_CHILDREN),
    value: None,
};

static WORD_SEPE_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_SEPEA_NODE),
    None,
    Some(&WORD_SEPEC_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_SEPEI_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_SEPEN_NODE),
    None,
    None,
    None,
    Some(&WORD_SEPER_NODE),
    None,
    Some(&WORD_SEPET_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_SEPET_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SEPET_CHILDREN),
    value: None,
};

pub static WORD_SEPET_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aror"),
        dictgen::InsensitiveStr::Ascii("arors"),
        dictgen::InsensitiveStr::Ascii("ate"),
        dictgen::InsensitiveStr::Ascii("ated"),
        dictgen::InsensitiveStr::Ascii("ately"),
        dictgen::InsensitiveStr::Ascii("ates"),
    ],
    values: &[
        &["separator"],
        &["separators"],
        &["separate"],
        &["separated"],
        &["separately"],
        &["separates"],
    ],
    range: 3..=5,
};

static WORD_SEPER_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SEPER_CHILDREN),
    value: None,
};

pub static WORD_SEPER_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("able"),
        dictgen::InsensitiveStr::Ascii("ad"),
        dictgen::InsensitiveStr::Ascii("adly"),
        dictgen::InsensitiveStr::Ascii("aly"),
        dictgen::InsensitiveStr::Ascii("aor"),
        dictgen::InsensitiveStr::Ascii("aors"),
        dictgen::InsensitiveStr::Ascii("are"),
        dictgen::InsensitiveStr::Ascii("ared"),
        dictgen::InsensitiveStr::Ascii("ares"),
        dictgen::InsensitiveStr::Ascii("at"),
        dictgen::InsensitiveStr::Ascii("ataed"),
        dictgen::InsensitiveStr::Ascii("atally"),
        dictgen::InsensitiveStr::Ascii("ataly"),
        dictgen::InsensitiveStr::Ascii("atated"),
        dictgen::InsensitiveStr::Ascii("atd"),
        dictgen::InsensitiveStr::Ascii("ate"),
        dictgen::InsensitiveStr::Ascii("ated"),
        dictgen::InsensitiveStr::Ascii("atedly"),
        dictgen::InsensitiveStr::Ascii("atedy"),
        dictgen::InsensitiveStr::Ascii("ateely"),
        dictgen::InsensitiveStr::Ascii("ateing"),
        dictgen::InsensitiveStr::Ascii("atelly"),
        dictgen::InsensitiveStr::Ascii("ately"),
        dictgen::InsensitiveStr::Ascii("ater"),
        dictgen::InsensitiveStr::Ascii("aters"),
        dictgen::InsensitiveStr::Ascii("ates"),
        dictgen::InsensitiveStr::Ascii("ating"),
        dictgen::InsensitiveStr::Ascii("ation"),
        dictgen::InsensitiveStr::Ascii("ations"),
        dictgen::InsensitiveStr::Ascii("atism"),
        dictgen::InsensitiveStr::Ascii("atist"),
        dictgen::InsensitiveStr::Ascii("atley"),
        dictgen::InsensitiveStr::Ascii("atly"),
        dictgen::InsensitiveStr::Ascii("ato"),
        dictgen::InsensitiveStr::Ascii("ator"),
        dictgen::InsensitiveStr::Ascii("ators"),
        dictgen::InsensitiveStr::Ascii("atos"),
        dictgen::InsensitiveStr::Ascii("eate"),
        dictgen::InsensitiveStr::Ascii("eated"),
        dictgen::InsensitiveStr::Ascii("eates"),
        dictgen::InsensitiveStr::Ascii("erate"),
        dictgen::InsensitiveStr::Ascii("erated"),
        dictgen::InsensitiveStr::Ascii("erates"),
        dictgen::InsensitiveStr::Ascii("ete"),
        dictgen::InsensitiveStr::Ascii("eted"),
        dictgen::InsensitiveStr::Ascii("etes"),
        dictgen::InsensitiveStr::Ascii("ratly"),
        dictgen::InsensitiveStr::Ascii("tator"),
        dictgen::InsensitiveStr::Ascii("tators"),
        dictgen::InsensitiveStr::Ascii("tor"),
        dictgen::InsensitiveStr::Ascii("tors"),
    ],
    values: &[
        &["separable"],
        &["separate"],
        &["separately"],
        &["separately"],
        &["separator"],
        &["separators"],
        &["separate"],
        &["separated"],
        &["separates"],
        &["separate"],
        &["separated"],
        &["separately"],
        &["separately"],
        &["separated"],
        &["separated"],
        &["separate"],
        &["separated"],
        &["separately"],
        &["separated"],
        &["separately"],
        &["separating"],
        &["separately"],
        &["separately"],
        &["separator"],
        &["separators"],
        &["separates"],
        &["separating"],
        &["separation"],
        &["separations"],
        &["separatism"],
        &["separatist"],
        &["separately"],
        &["separately"],
        &["separator"],
        &["separator"],
        &["separators"],
        &["separators"],
        &["separate"],
        &["separated"],
        &["separates"],
        &["separate"],
        &["separated"],
        &["separates"],
        &["separate"],
        &["separated"],
        &["separates"],
        &["separately"],
        &["separator"],
        &["separators"],
        &["separator"],
        &["separators"],
    ],
    range: 2..=6,
};

static WORD_SEPEN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SEPEN_CHILDREN),
    value: None,
};

pub static WORD_SEPEN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("d"),
        dictgen::InsensitiveStr::Ascii("dent"),
        dictgen::InsensitiveStr::Ascii("ding"),
    ],
    values: &[&["depend", "suspend"], &["dependent"], &["depending"]],
    range: 1..=4,
};

static WORD_SEPEI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SEPEI_CHILDREN),
    value: None,
};

pub static WORD_SEPEI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("cfy")],
    values: &[&["specify"]],
    range: 3..=3,
};

static WORD_SEPEC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SEPEC_CHILDREN),
    value: None,
};

pub static WORD_SEPEC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ial"),
        dictgen::InsensitiveStr::Ascii("ially"),
        dictgen::InsensitiveStr::Ascii("ifed"),
        dictgen::InsensitiveStr::Ascii("ific"),
        dictgen::InsensitiveStr::Ascii("ification"),
        dictgen::InsensitiveStr::Ascii("ified"),
        dictgen::InsensitiveStr::Ascii("ifier"),
        dictgen::InsensitiveStr::Ascii("ifiers"),
        dictgen::InsensitiveStr::Ascii("ifies"),
        dictgen::InsensitiveStr::Ascii("ify"),
        dictgen::InsensitiveStr::Ascii("tral"),
    ],
    values: &[
        &["special"],
        &["especially", "specially"],
        &["specified"],
        &["specific"],
        &["specification"],
        &["specified"],
        &["specifier"],
        &["specifiers"],
        &["specifies"],
        &["specify"],
        &["spectral"],
    ],
    range: 3..=9,
};

static WORD_SEPEA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SEPEA_CHILDREN),
    value: None,
};

pub static WORD_SEPEA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("rable"),
        dictgen::InsensitiveStr::Ascii("rate"),
        dictgen::InsensitiveStr::Ascii("rated"),
        dictgen::InsensitiveStr::Ascii("rately"),
        dictgen::InsensitiveStr::Ascii("rates"),
        dictgen::InsensitiveStr::Ascii("ration"),
        dictgen::InsensitiveStr::Ascii("rator"),
        dictgen::InsensitiveStr::Ascii("rators"),
        dictgen::InsensitiveStr::Ascii("ret"),
        dictgen::InsensitiveStr::Ascii("retly"),
        dictgen::InsensitiveStr::Ascii("rte"),
        dictgen::InsensitiveStr::Ascii("rted"),
        dictgen::InsensitiveStr::Ascii("rtely"),
        dictgen::InsensitiveStr::Ascii("rtes"),
        dictgen::InsensitiveStr::Ascii("rtor"),
        dictgen::InsensitiveStr::Ascii("rtors"),
        dictgen::InsensitiveStr::Ascii("te"),
        dictgen::InsensitiveStr::Ascii("ted"),
        dictgen::InsensitiveStr::Ascii("tes"),
        dictgen::InsensitiveStr::Ascii("tor"),
        dictgen::InsensitiveStr::Ascii("tors"),
    ],
    values: &[
        &["separable"],
        &["separate"],
        &["separated"],
        &["separately"],
        &["separates"],
        &["separation"],
        &["separator"],
        &["separators"],
        &["separate"],
        &["separately"],
        &["separate"],
        &["separated"],
        &["separately"],
        &["separates"],
        &["separator"],
        &["separators"],
        &["separate"],
        &["separated"],
        &["separates"],
        &["separator"],
        &["separators"],
    ],
    range: 2..=6,
};

static WORD_SEPC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SEPC_CHILDREN),
    value: None,
};

pub static WORD_SEPC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ial"),
        dictgen::InsensitiveStr::Ascii("ially"),
        dictgen::InsensitiveStr::Ascii("ific"),
        dictgen::InsensitiveStr::Ascii("ifically"),
        dictgen::InsensitiveStr::Ascii("ification"),
        dictgen::InsensitiveStr::Ascii("ifications"),
        dictgen::InsensitiveStr::Ascii("ified"),
        dictgen::InsensitiveStr::Ascii("ifier"),
        dictgen::InsensitiveStr::Ascii("ifies"),
        dictgen::InsensitiveStr::Ascii("ify"),
        dictgen::InsensitiveStr::Ascii("ifying"),
        dictgen::InsensitiveStr::Ascii("ulating"),
    ],
    values: &[
        &["special"],
        &["specially"],
        &["specific"],
        &["specifically"],
        &["specification"],
        &["specification", "specifications"],
        &["specified"],
        &["specifier"],
        &["specifies"],
        &["specify"],
        &["specifying"],
        &["speculating"],
    ],
    range: 3..=10,
};

static WORD_SEPA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SEPA_CHILDREN),
    value: None,
};

pub static WORD_SEPA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ate"),
        dictgen::InsensitiveStr::Ascii("racion"),
        dictgen::InsensitiveStr::Ascii("rartor"),
        dictgen::InsensitiveStr::Ascii("rat"),
        dictgen::InsensitiveStr::Ascii("ratedly"),
        dictgen::InsensitiveStr::Ascii("ratelly"),
        dictgen::InsensitiveStr::Ascii("rater"),
        dictgen::InsensitiveStr::Ascii("raters"),
        dictgen::InsensitiveStr::Ascii("ratisme"),
        dictgen::InsensitiveStr::Ascii("ratiste"),
        dictgen::InsensitiveStr::Ascii("ratley"),
        dictgen::InsensitiveStr::Ascii("ratly"),
        dictgen::InsensitiveStr::Ascii("rato"),
        dictgen::InsensitiveStr::Ascii("ratos"),
        dictgen::InsensitiveStr::Ascii("ratring"),
        dictgen::InsensitiveStr::Ascii("ratron"),
        dictgen::InsensitiveStr::Ascii("red"),
        dictgen::InsensitiveStr::Ascii("rete"),
        dictgen::InsensitiveStr::Ascii("reted"),
        dictgen::InsensitiveStr::Ascii("retedly"),
        dictgen::InsensitiveStr::Ascii("retely"),
        dictgen::InsensitiveStr::Ascii("reter"),
        dictgen::InsensitiveStr::Ascii("retes"),
        dictgen::InsensitiveStr::Ascii("reting"),
        dictgen::InsensitiveStr::Ascii("retly"),
        dictgen::InsensitiveStr::Ascii("retor"),
        dictgen::InsensitiveStr::Ascii("rtates"),
        dictgen::InsensitiveStr::Ascii("rte"),
        dictgen::InsensitiveStr::Ascii("rted"),
        dictgen::InsensitiveStr::Ascii("rtes"),
        dictgen::InsensitiveStr::Ascii("rting"),
        dictgen::InsensitiveStr::Ascii("rtor"),
        dictgen::InsensitiveStr::Ascii("rtors"),
        dictgen::InsensitiveStr::Ascii("tae"),
        dictgen::InsensitiveStr::Ascii("tate"),
    ],
    values: &[
        &["separate"],
        &["separation"],
        &["separator"],
        &["separate"],
        &["separately"],
        &["separately"],
        &["separator"],
        &["separates"],
        &["separates"],
        &["separates"],
        &["separately"],
        &["separately"],
        &["separation", "separator"],
        &["separators"],
        &["separating"],
        &["separation"],
        &["separated"],
        &["separate"],
        &["separated"],
        &["separately"],
        &["separately"],
        &["separator"],
        &["separates"],
        &["separating"],
        &["separately"],
        &["separator"],
        &["separates"],
        &["separate"],
        &["separated"],
        &["separates"],
        &["separating"],
        &["separator"],
        &["separators"],
        &["separate"],
        &["separate"],
    ],
    range: 3..=7,
};

static WORD_SEO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SEO_CHILDREN),
    value: None,
};

pub static WORD_SEO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("nd"),
        dictgen::InsensitiveStr::Ascii("nds"),
    ],
    values: &[&["second", "send"], &["seconds", "sends"]],
    range: 2..=3,
};

static WORD_SEN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_SEN_CHILDREN),
    value: None,
};

static WORD_SEN_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_SENA_NODE),
    None,
    Some(&WORD_SENC_NODE),
    Some(&WORD_SEND_NODE),
    Some(&WORD_SENE_NODE),
    Some(&WORD_SENF_NODE),
    None,
    None,
    Some(&WORD_SENI_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_SENO_NODE),
    None,
    Some(&WORD_SENQ_NODE),
    None,
    Some(&WORD_SENS_NODE),
    Some(&WORD_SENT_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_SENZ_NODE),
];

static WORD_SENZ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SENZ_CHILDREN),
    value: None,
};

pub static WORD_SENZ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ationalism"),
        dictgen::InsensitiveStr::Ascii("ationalist"),
    ],
    values: &[&["sensationalism"], &["sensationalist"]],
    range: 10..=10,
};

static WORD_SENT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SENT_CHILDREN),
    value: None,
};

pub static WORD_SENT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("amental"),
        dictgen::InsensitiveStr::Ascii("aments"),
        dictgen::InsensitiveStr::Ascii("ance"),
        dictgen::InsensitiveStr::Ascii("ances"),
        dictgen::InsensitiveStr::Ascii("ancing"),
        dictgen::InsensitiveStr::Ascii("aor"),
        dictgen::InsensitiveStr::Ascii("aors"),
        dictgen::InsensitiveStr::Ascii("ationalism"),
        dictgen::InsensitiveStr::Ascii("ationalist"),
        dictgen::InsensitiveStr::Ascii("eces"),
        dictgen::InsensitiveStr::Ascii("emental"),
        dictgen::InsensitiveStr::Ascii("ements"),
        dictgen::InsensitiveStr::Ascii("enal"),
        dictgen::InsensitiveStr::Ascii("enals"),
        dictgen::InsensitiveStr::Ascii("enceing"),
        dictgen::InsensitiveStr::Ascii("encian"),
        dictgen::InsensitiveStr::Ascii("ense"),
        dictgen::InsensitiveStr::Ascii("ensing"),
        dictgen::InsensitiveStr::Ascii("ienl"),
        dictgen::InsensitiveStr::Ascii("iers"),
        dictgen::InsensitiveStr::Ascii("imant"),
        dictgen::InsensitiveStr::Ascii("imenal"),
        dictgen::InsensitiveStr::Ascii("imentals"),
        dictgen::InsensitiveStr::Ascii("imentos"),
        dictgen::InsensitiveStr::Ascii("imentul"),
        dictgen::InsensitiveStr::Ascii("imetal"),
        dictgen::InsensitiveStr::Ascii("inal"),
        dictgen::InsensitiveStr::Ascii("inals"),
        dictgen::InsensitiveStr::Ascii("incing"),
        dictgen::InsensitiveStr::Ascii("inents"),
        dictgen::InsensitiveStr::Ascii("inet"),
        dictgen::InsensitiveStr::Ascii("inte"),
        dictgen::InsensitiveStr::Ascii("ion"),
        dictgen::InsensitiveStr::Ascii("ions"),
        dictgen::InsensitiveStr::Ascii("ires"),
        dictgen::InsensitiveStr::Ascii("ive"),
        dictgen::InsensitiveStr::Ascii("ively"),
        dictgen::InsensitiveStr::Ascii("ivite"),
        dictgen::InsensitiveStr::Ascii("reis"),
        dictgen::InsensitiveStr::Ascii("ris"),
    ],
    values: &[
        &["sentimental"],
        &["sentiments"],
        &["sentence"],
        &["sentences"],
        &["sentencing"],
        &["senator"],
        &["senators"],
        &["sensationalism"],
        &["sensationalist"],
        &["sentences"],
        &["sentimental"],
        &["sentiments"],
        &["sentinel"],
        &["sentinels"],
        &["sentencing"],
        &["sentencing"],
        &["sentence"],
        &["sentencing"],
        &["sentinel"],
        &["sentries"],
        &["sentimental"],
        &["sentimental"],
        &["sentiments"],
        &["sentiments"],
        &["sentimental"],
        &["sentimental"],
        &["sentinel"],
        &["sentinels"],
        &["sentencing"],
        &["sentiments"],
        &["sentient"],
        &["sentient"],
        &["section"],
        &["sections"],
        &["sentries"],
        &["sensitive"],
        &["sensitively", "sensitivity"],
        &["sensitive"],
        &["sentries"],
        &["sentries"],
    ],
    range: 3..=10,
};

static WORD_SENS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SENS_CHILDREN),
    value: None,
};

pub static WORD_SENS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ability"),
        dictgen::InsensitiveStr::Ascii("able"),
        dictgen::InsensitiveStr::Ascii("ably"),
        dictgen::InsensitiveStr::Ascii("acional"),
        dictgen::InsensitiveStr::Ascii("acionalism"),
        dictgen::InsensitiveStr::Ascii("acionalist"),
        dictgen::InsensitiveStr::Ascii("asional"),
        dictgen::InsensitiveStr::Ascii("asionalism"),
        dictgen::InsensitiveStr::Ascii("asionalist"),
        dictgen::InsensitiveStr::Ascii("ationable"),
        dictgen::InsensitiveStr::Ascii("ationail"),
        dictgen::InsensitiveStr::Ascii("ationails"),
        dictgen::InsensitiveStr::Ascii("ationaism"),
        dictgen::InsensitiveStr::Ascii("ationalim"),
        dictgen::InsensitiveStr::Ascii("ationalisim"),
        dictgen::InsensitiveStr::Ascii("ationality"),
        dictgen::InsensitiveStr::Ascii("ationalizm"),
        dictgen::InsensitiveStr::Ascii("ationalsim"),
        dictgen::InsensitiveStr::Ascii("ationel"),
        dictgen::InsensitiveStr::Ascii("ationella"),
        dictgen::InsensitiveStr::Ascii("ationilism"),
        dictgen::InsensitiveStr::Ascii("ationilist"),
        dictgen::InsensitiveStr::Ascii("ationnal"),
        dictgen::InsensitiveStr::Ascii("ationslism"),
        dictgen::InsensitiveStr::Ascii("ative"),
        dictgen::InsensitiveStr::Ascii("ativity"),
        dictgen::InsensitiveStr::Ascii("etional"),
        dictgen::InsensitiveStr::Ascii("etionalism"),
        dictgen::InsensitiveStr::Ascii("etive"),
        dictgen::InsensitiveStr::Ascii("etivity"),
        dictgen::InsensitiveStr::Ascii("ibel"),
        dictgen::InsensitiveStr::Ascii("ibilisiert"),
        dictgen::InsensitiveStr::Ascii("ibilites"),
        dictgen::InsensitiveStr::Ascii("isble"),
        dictgen::InsensitiveStr::Ascii("istive"),
        dictgen::InsensitiveStr::Ascii("istively"),
        dictgen::InsensitiveStr::Ascii("ititive"),
        dictgen::InsensitiveStr::Ascii("ititivies"),
        dictgen::InsensitiveStr::Ascii("ititivity"),
        dictgen::InsensitiveStr::Ascii("ititivy"),
        dictgen::InsensitiveStr::Ascii("itiv"),
        dictgen::InsensitiveStr::Ascii("itiveties"),
        dictgen::InsensitiveStr::Ascii("itivety"),
        dictgen::InsensitiveStr::Ascii("itivites"),
        dictgen::InsensitiveStr::Ascii("itivitiy"),
        dictgen::InsensitiveStr::Ascii("itiviy"),
        dictgen::InsensitiveStr::Ascii("itivties"),
        dictgen::InsensitiveStr::Ascii("itivty"),
        dictgen::InsensitiveStr::Ascii("itivy"),
        dictgen::InsensitiveStr::Ascii("itve"),
        dictgen::InsensitiveStr::Ascii("ivity"),
        dictgen::InsensitiveStr::Ascii("ores"),
        dictgen::InsensitiveStr::Ascii("tive"),
        dictgen::InsensitiveStr::Ascii("ure"),
    ],
    values: &[
        &["sensibility"],
        &["sensible"],
        &["sensibly"],
        &["sensational"],
        &["sensationalism"],
        &["sensationalist"],
        &["sensational"],
        &["sensationalism"],
        &["sensationalist"],
        &["sensational"],
        &["sensational"],
        &["sensationalism"],
        &["sensationalism"],
        &["sensationalism"],
        &["sensationalism"],
        &["sensationalist"],
        &["sensationalism"],
        &["sensationalism"],
        &["sensational"],
        &["sensational"],
        &["sensationalism"],
        &["sensationalist"],
        &["sensational"],
        &["sensationalism"],
        &["sensitive"],
        &["sensitivity"],
        &["sensational"],
        &["sensationalism"],
        &["sensitive"],
        &["sensitivity"],
        &["sensible"],
        &["sensibilities"],
        &["sensibilities"],
        &["sensible"],
        &["sensitive"],
        &["sensitively", "sensitivity"],
        &["sensitive"],
        &["sensitivities"],
        &["sensitivity"],
        &["sensitivity"],
        &["sensitive"],
        &["sensitivities"],
        &["sensitivity"],
        &["sensitivities"],
        &["sensitivity"],
        &["sensitivity"],
        &["sensitivities"],
        &["sensitivity"],
        &["sensitivity", "sensitively"],
        &["sensitive"],
        &["sensitivity", "sensitively"],
        &["sensors"],
        &["sensitive"],
        &["censure"],
    ],
    range: 3..=11,
};

static WORD_SENQ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SENQ_CHILDREN),
    value: None,
};

pub static WORD_SENQ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("uence")],
    values: &[&["sequence"]],
    range: 5..=5,
};

static WORD_SENO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SENO_CHILDREN),
    value: None,
};

pub static WORD_SENO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("irs")],
    values: &[&["seniors"]],
    range: 3..=3,
};

static WORD_SENI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SENI_CHILDREN),
    value: None,
};

pub static WORD_SENI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ntels"),
        dictgen::InsensitiveStr::Ascii("ores"),
        dictgen::InsensitiveStr::Ascii("sble"),
        dictgen::InsensitiveStr::Ascii("tmental"),
        dictgen::InsensitiveStr::Ascii("tments"),
        dictgen::InsensitiveStr::Ascii("tnel"),
        dictgen::InsensitiveStr::Ascii("tnels"),
    ],
    values: &[
        &["sentinels"],
        &["seniors"],
        &["sensible"],
        &["sentimental"],
        &["sentiments"],
        &["sentinel"],
        &["sentinels"],
    ],
    range: 4..=7,
};

static WORD_SENF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SENF_CHILDREN),
    value: None,
};

pub static WORD_SENF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ile")],
    values: &[&["sendfile"]],
    range: 3..=3,
};

static WORD_SENE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SENE_CHILDREN),
    value: None,
};

pub static WORD_SENE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("rity")],
    values: &[&["serenity"]],
    range: 4..=4,
};

static WORD_SEND_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SEND_CHILDREN),
    value: None,
};

pub static WORD_SEND_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("etary"),
        dictgen::InsensitiveStr::Ascii("ign"),
        dictgen::InsensitiveStr::Ascii("inging"),
        dictgen::InsensitiveStr::Ascii("inng"),
    ],
    values: &[&["sedentary"], &["sending"], &["sending"], &["sending"]],
    range: 3..=6,
};

static WORD_SENC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SENC_CHILDREN),
    value: None,
};

pub static WORD_SENC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("ond"),
        dictgen::InsensitiveStr::Ascii("ondary"),
        dictgen::InsensitiveStr::Ascii("onds"),
    ],
    values: &[
        &["sense", "since"],
        &["second"],
        &["secondary"],
        &["seconds"],
    ],
    range: 1..=6,
};

static WORD_SENA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SENA_CHILDREN),
    value: None,
};

pub static WORD_SENA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ireo"),
        dictgen::InsensitiveStr::Ascii("ireos"),
        dictgen::InsensitiveStr::Ascii("phore"),
        dictgen::InsensitiveStr::Ascii("phores"),
        dictgen::InsensitiveStr::Ascii("rio"),
        dictgen::InsensitiveStr::Ascii("rios"),
        dictgen::InsensitiveStr::Ascii("rreo"),
        dictgen::InsensitiveStr::Ascii("rreos"),
        dictgen::InsensitiveStr::Ascii("tores"),
    ],
    values: &[
        &["scenario"],
        &["scenarios"],
        &["semaphore"],
        &["semaphores"],
        &["scenario"],
        &["scenarios"],
        &["scenario"],
        &["scenarios"],
        &["senators"],
    ],
    range: 3..=6,
};

static WORD_SEM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SEM_CHILDREN),
    value: None,
};

pub static WORD_SEM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aintics"),
        dictgen::InsensitiveStr::Ascii("anitcs"),
        dictgen::InsensitiveStr::Ascii("aphone"),
        dictgen::InsensitiveStr::Ascii("aphones"),
        dictgen::InsensitiveStr::Ascii("aphor"),
        dictgen::InsensitiveStr::Ascii("aphors"),
        dictgen::InsensitiveStr::Ascii("apthore"),
        dictgen::InsensitiveStr::Ascii("apthores"),
        dictgen::InsensitiveStr::Ascii("atic"),
        dictgen::InsensitiveStr::Ascii("atical"),
        dictgen::InsensitiveStr::Ascii("atically"),
        dictgen::InsensitiveStr::Ascii("atics"),
        dictgen::InsensitiveStr::Ascii("atnics"),
        dictgen::InsensitiveStr::Ascii("ding"),
        dictgen::InsensitiveStr::Ascii("ent"),
        dictgen::InsensitiveStr::Ascii("entation"),
        dictgen::InsensitiveStr::Ascii("ented"),
        dictgen::InsensitiveStr::Ascii("entic"),
        dictgen::InsensitiveStr::Ascii("entically"),
        dictgen::InsensitiveStr::Ascii("entics"),
        dictgen::InsensitiveStr::Ascii("enting"),
        dictgen::InsensitiveStr::Ascii("ents"),
        dictgen::InsensitiveStr::Ascii("estre"),
        dictgen::InsensitiveStr::Ascii("estres"),
        dictgen::InsensitiveStr::Ascii("gent"),
        dictgen::InsensitiveStr::Ascii("gentation"),
        dictgen::InsensitiveStr::Ascii("icolor"),
        dictgen::InsensitiveStr::Ascii("icolumn"),
        dictgen::InsensitiveStr::Ascii("icondutor"),
        dictgen::InsensitiveStr::Ascii("natics"),
        dictgen::InsensitiveStr::Ascii("pahore"),
        dictgen::InsensitiveStr::Ascii("pahores"),
        dictgen::InsensitiveStr::Ascii("paphore"),
        dictgen::InsensitiveStr::Ascii("paphores"),
        dictgen::InsensitiveStr::Ascii("phore"),
        dictgen::InsensitiveStr::Ascii("phores"),
        dictgen::InsensitiveStr::Ascii("pphore"),
        dictgen::InsensitiveStr::Ascii("seter"),
        dictgen::InsensitiveStr::Ascii("seters"),
    ],
    values: &[
        &["semantics"],
        &["semantics"],
        &["semaphore"],
        &["semaphores"],
        &["semaphore"],
        &["semaphores"],
        &["semaphore"],
        &["semaphores"],
        &["semantic"],
        &["semantical"],
        &["semantically"],
        &["semantics"],
        &["semantics"],
        &["sending"],
        &["cement", "segment"],
        &["segmentation"],
        &["cemented", "segmented"],
        &["semantic"],
        &["semantically"],
        &["semantics"],
        &["cementing", "segmenting"],
        &["cements", "segments"],
        &["semester"],
        &["semesters"],
        &["segment"],
        &["segmentation"],
        &["semicolon"],
        &["semicolon"],
        &["semiconductor"],
        &["semantics"],
        &["semaphore"],
        &["semaphores"],
        &["semaphore"],
        &["semaphores"],
        &["semaphore"],
        &["semaphores"],
        &["semaphore"],
        &["semester"],
        &["semesters"],
    ],
    range: 3..=9,
};

static WORD_SEL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SEL_CHILDREN),
    value: None,
};

pub static WORD_SEL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cetion"),
        dictgen::InsensitiveStr::Ascii("ct"),
        dictgen::InsensitiveStr::Ascii("ctable"),
        dictgen::InsensitiveStr::Ascii("ctables"),
        dictgen::InsensitiveStr::Ascii("cted"),
        dictgen::InsensitiveStr::Ascii("cting"),
        dictgen::InsensitiveStr::Ascii("ction"),
        dictgen::InsensitiveStr::Ascii("ctions"),
        dictgen::InsensitiveStr::Ascii("domly"),
        dictgen::InsensitiveStr::Ascii("ecction"),
        dictgen::InsensitiveStr::Ascii("ecctions"),
        dictgen::InsensitiveStr::Ascii("eced"),
        dictgen::InsensitiveStr::Ascii("ecetd"),
        dictgen::InsensitiveStr::Ascii("eceted"),
        dictgen::InsensitiveStr::Ascii("ecgt"),
        dictgen::InsensitiveStr::Ascii("ecgted"),
        dictgen::InsensitiveStr::Ascii("ecgting"),
        dictgen::InsensitiveStr::Ascii("ecing"),
        dictgen::InsensitiveStr::Ascii("ecrtion"),
        dictgen::InsensitiveStr::Ascii("ectd"),
        dictgen::InsensitiveStr::Ascii("ecte"),
        dictgen::InsensitiveStr::Ascii("ectes"),
        dictgen::InsensitiveStr::Ascii("ectie"),
        dictgen::InsensitiveStr::Ascii("ectin"),
        dictgen::InsensitiveStr::Ascii("ectiose"),
        dictgen::InsensitiveStr::Ascii("ectivley"),
        dictgen::InsensitiveStr::Ascii("ectivly"),
        dictgen::InsensitiveStr::Ascii("ectivos"),
        dictgen::InsensitiveStr::Ascii("ectoin"),
        dictgen::InsensitiveStr::Ascii("ecton"),
        dictgen::InsensitiveStr::Ascii("ectons"),
        dictgen::InsensitiveStr::Ascii("edted"),
        dictgen::InsensitiveStr::Ascii("ektions"),
        dictgen::InsensitiveStr::Ascii("ektor"),
        dictgen::InsensitiveStr::Ascii("et"),
        dictgen::InsensitiveStr::Ascii("eted"),
        dictgen::InsensitiveStr::Ascii("etion"),
        dictgen::InsensitiveStr::Ascii("etions"),
        dictgen::InsensitiveStr::Ascii("ets"),
        dictgen::InsensitiveStr::Ascii("feshness"),
        dictgen::InsensitiveStr::Ascii("fiers"),
        dictgen::InsensitiveStr::Ascii("fishess"),
        dictgen::InsensitiveStr::Ascii("fs"),
        dictgen::InsensitiveStr::Ascii("ifes"),
        dictgen::InsensitiveStr::Ascii("lect"),
        dictgen::InsensitiveStr::Ascii("lected"),
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("v"),
    ],
    values: &[
        &["selection"],
        &["select"],
        &["selectable"],
        &["selectables", "selectable"],
        &["selected"],
        &["selecting"],
        &["selection"],
        &["selections"],
        &["seldom"],
        &["selection"],
        &["selections"],
        &["selected"],
        &["selected"],
        &["selected"],
        &["select"],
        &["selected"],
        &["selecting"],
        &["selecting"],
        &["selection"],
        &["selected"],
        &["selected", "select"],
        &["selects"],
        &["selective"],
        &["selection", "selecting"],
        &["selections"],
        &["selectively"],
        &["selectively"],
        &["selections"],
        &["selection"],
        &["selection"],
        &["selections"],
        &["selected"],
        &["selections"],
        &["selector"],
        &["select"],
        &["selected", "deleted"],
        &["selection", "deletion"],
        &["selections", "deletions"],
        &["selects"],
        &["selfishness"],
        &["selfies"],
        &["selfishness"],
        &["self"],
        &["selfies"],
        &["select"],
        &["selected"],
        &["set", "self", "sold"],
        &["self"],
    ],
    range: 1..=8,
};

static WORD_SEK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SEK_CHILDREN),
    value: None,
};

pub static WORD_SEK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ect"),
        dictgen::InsensitiveStr::Ascii("ected"),
        dictgen::InsensitiveStr::Ascii("ects"),
    ],
    values: &[&["select"], &["selected"], &["selects"]],
    range: 3..=5,
};

static WORD_SEI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SEI_CHILDREN),
    value: None,
};

pub static WORD_SEI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ge"),
        dictgen::InsensitiveStr::Ascii("na"),
        dictgen::InsensitiveStr::Ascii("ng"),
        dictgen::InsensitiveStr::Ascii("nor"),
        dictgen::InsensitiveStr::Ascii("nors"),
        dictgen::InsensitiveStr::Ascii("res"),
    ],
    values: &[
        &["siege"],
        &["seine", "sienna"],
        &["seeing"],
        &["senior"],
        &["seniors"],
        &["series"],
    ],
    range: 2..=4,
};

static WORD_SEH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SEH_CHILDREN),
    value: Some(&["she"]),
};

pub static WORD_SEH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[],
    values: &[],
    range: 0..=0,
};

static WORD_SEG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SEG_CHILDREN),
    value: None,
};

pub static WORD_SEG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ault"),
        dictgen::InsensitiveStr::Ascii("aults"),
        dictgen::InsensitiveStr::Ascii("egrated"),
        dictgen::InsensitiveStr::Ascii("ement"),
        dictgen::InsensitiveStr::Ascii("ementation"),
        dictgen::InsensitiveStr::Ascii("emented"),
        dictgen::InsensitiveStr::Ascii("ements"),
        dictgen::InsensitiveStr::Ascii("emnet"),
        dictgen::InsensitiveStr::Ascii("emnt"),
        dictgen::InsensitiveStr::Ascii("emntation"),
        dictgen::InsensitiveStr::Ascii("emnted"),
        dictgen::InsensitiveStr::Ascii("emnts"),
        dictgen::InsensitiveStr::Ascii("ergation"),
        dictgen::InsensitiveStr::Ascii("fualt"),
        dictgen::InsensitiveStr::Ascii("fualts"),
        dictgen::InsensitiveStr::Ascii("mantation"),
        dictgen::InsensitiveStr::Ascii("mend"),
        dictgen::InsensitiveStr::Ascii("mendation"),
        dictgen::InsensitiveStr::Ascii("mended"),
        dictgen::InsensitiveStr::Ascii("mends"),
        dictgen::InsensitiveStr::Ascii("menet"),
        dictgen::InsensitiveStr::Ascii("menetd"),
        dictgen::InsensitiveStr::Ascii("meneted"),
        dictgen::InsensitiveStr::Ascii("menets"),
        dictgen::InsensitiveStr::Ascii("mens"),
        dictgen::InsensitiveStr::Ascii("menst"),
        dictgen::InsensitiveStr::Ascii("mentaion"),
        dictgen::InsensitiveStr::Ascii("mente"),
        dictgen::InsensitiveStr::Ascii("mentes"),
        dictgen::InsensitiveStr::Ascii("metn"),
        dictgen::InsensitiveStr::Ascii("metned"),
        dictgen::InsensitiveStr::Ascii("metns"),
        dictgen::InsensitiveStr::Ascii("mnet"),
        dictgen::InsensitiveStr::Ascii("mnets"),
        dictgen::InsensitiveStr::Ascii("ragated"),
        dictgen::InsensitiveStr::Ascii("ragation"),
        dictgen::InsensitiveStr::Ascii("regacion"),
        dictgen::InsensitiveStr::Ascii("regaded"),
        dictgen::InsensitiveStr::Ascii("regatie"),
        dictgen::InsensitiveStr::Ascii("retated"),
        dictgen::InsensitiveStr::Ascii("retation"),
        dictgen::InsensitiveStr::Ascii("rigated"),
        dictgen::InsensitiveStr::Ascii("rigation"),
        dictgen::InsensitiveStr::Ascii("ument"),
        dictgen::InsensitiveStr::Ascii("uoys"),
        dictgen::InsensitiveStr::Ascii("way"),
        dictgen::InsensitiveStr::Ascii("wayed"),
        dictgen::InsensitiveStr::Ascii("waying"),
    ],
    values: &[
        &["segfault"],
        &["segfaults"],
        &["segregated"],
        &["segment"],
        &["segmentation"],
        &["segmented"],
        &["segments"],
        &["segment"],
        &["segment"],
        &["segmentation"],
        &["segmented"],
        &["segments"],
        &["segregation"],
        &["segfault"],
        &["segfaults"],
        &["segmentation"],
        &["segment"],
        &["segmentation"],
        &["segmented"],
        &["segments"],
        &["segment"],
        &["segmented"],
        &["segmented"],
        &["segments"],
        &["segment", "segments"],
        &["segments"],
        &["segmentation"],
        &["segment"],
        &["segments"],
        &["segment"],
        &["segmented"],
        &["segments"],
        &["segment"],
        &["segments"],
        &["segregated"],
        &["segregation"],
        &["segregation"],
        &["segregated"],
        &["segregated"],
        &["segregated"],
        &["segregation"],
        &["segregated"],
        &["segregation"],
        &["segment"],
        &["segues"],
        &["segue"],
        &["segued"],
        &["segueing"],
    ],
    range: 3..=10,
};

static WORD_SEF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SEF_CHILDREN),
    value: None,
};

pub static WORD_SEF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("lies"),
        dictgen::InsensitiveStr::Ascii("lishness"),
    ],
    values: &[&["selfies"], &["selfishness"]],
    range: 4..=8,
};

static WORD_SEE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SEE_CHILDREN),
    value: None,
};

pub static WORD_SEE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("em"),
        dictgen::InsensitiveStr::Ascii("en"),
        dictgen::InsensitiveStr::Ascii("ge"),
        dictgen::InsensitiveStr::Ascii("ged"),
        dictgen::InsensitiveStr::Ascii("ges"),
        dictgen::InsensitiveStr::Ascii("ging"),
        dictgen::InsensitiveStr::Ascii("ked"),
        dictgen::InsensitiveStr::Ascii("lect"),
        dictgen::InsensitiveStr::Ascii("lected"),
        dictgen::InsensitiveStr::Ascii("mes"),
        dictgen::InsensitiveStr::Ascii("mless"),
        dictgen::InsensitiveStr::Ascii("mlessly"),
        dictgen::InsensitiveStr::Ascii("sion"),
        dictgen::InsensitiveStr::Ascii("sions"),
        dictgen::InsensitiveStr::Ascii("ting"),
        dictgen::InsensitiveStr::Ascii("tings"),
        dictgen::InsensitiveStr::Ascii("verities"),
        dictgen::InsensitiveStr::Ascii("verity"),
        dictgen::InsensitiveStr::Ascii("z"),
        dictgen::InsensitiveStr::Ascii("zed"),
        dictgen::InsensitiveStr::Ascii("zes"),
        dictgen::InsensitiveStr::Ascii("zing"),
        dictgen::InsensitiveStr::Ascii("zure"),
        dictgen::InsensitiveStr::Ascii("zures"),
    ],
    values: &[
        &["seem"],
        &["seen"],
        &["siege"],
        &["sieged"],
        &["sieges"],
        &["sieging"],
        &["sought"],
        &["select"],
        &["selected"],
        &["seems"],
        &["seamless"],
        &["seamlessly"],
        &["session"],
        &["sessions"],
        &["seating", "setting", "seething"],
        &["settings"],
        &["severities"],
        &["severity"],
        &["seize"],
        &["seized"],
        &["seizes"],
        &["seizing"],
        &["seizure"],
        &["seizures"],
    ],
    range: 1..=8,
};

static WORD_SED_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SED_CHILDREN),
    value: None,
};

pub static WORD_SED_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("entarity"),
        dictgen::InsensitiveStr::Ascii("ereal"),
        dictgen::InsensitiveStr::Ascii("netary"),
        dictgen::InsensitiveStr::Ascii("uciton"),
    ],
    values: &[
        &["sedentary"],
        &["sidereal"],
        &["sedentary"],
        &["seduction"],
    ],
    range: 5..=8,
};

static WORD_SEC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_SEC_CHILDREN),
    value: None,
};

static WORD_SEC_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    Some(&WORD_SECC_NODE),
    None,
    Some(&WORD_SECE_NODE),
    None,
    None,
    None,
    Some(&WORD_SECI_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_SECN_NODE),
    Some(&WORD_SECO_NODE),
    Some(&WORD_SECP_NODE),
    Some(&WORD_SECQ_NODE),
    Some(&WORD_SECR_NODE),
    None,
    Some(&WORD_SECT_NODE),
    Some(&WORD_SECU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_SECU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SECU_CHILDREN),
    value: None,
};

pub static WORD_SECU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("ely"),
        dictgen::InsensitiveStr::Ascii("ence"),
        dictgen::InsensitiveStr::Ascii("enced"),
        dictgen::InsensitiveStr::Ascii("ences"),
        dictgen::InsensitiveStr::Ascii("encial"),
        dictgen::InsensitiveStr::Ascii("encing"),
        dictgen::InsensitiveStr::Ascii("irty"),
        dictgen::InsensitiveStr::Ascii("ity"),
        dictgen::InsensitiveStr::Ascii("nd"),
        dictgen::InsensitiveStr::Ascii("nds"),
        dictgen::InsensitiveStr::Ascii("riy"),
        dictgen::InsensitiveStr::Ascii("riyt"),
        dictgen::InsensitiveStr::Ascii("rly"),
        dictgen::InsensitiveStr::Ascii("rre"),
        dictgen::InsensitiveStr::Ascii("rrely"),
        dictgen::InsensitiveStr::Ascii("rrly"),
        dictgen::InsensitiveStr::Ascii("rtity"),
        dictgen::InsensitiveStr::Ascii("rtiy"),
        dictgen::InsensitiveStr::Ascii("rty"),
        dictgen::InsensitiveStr::Ascii("ruity"),
    ],
    values: &[
        &["secure"],
        &["securely"],
        &["sequence"],
        &["sequenced"],
        &["sequences"],
        &["sequential"],
        &["sequencing"],
        &["security"],
        &["security"],
        &["second"],
        &["seconds"],
        &["security"],
        &["security"],
        &["securely"],
        &["secure"],
        &["securely"],
        &["securely"],
        &["security"],
        &["security"],
        &["security"],
        &["security"],
    ],
    range: 1..=6,
};

static WORD_SECT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SECT_CHILDREN),
    value: None,
};

pub static WORD_SECT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("in"),
        dictgen::InsensitiveStr::Ascii("ins"),
        dictgen::InsensitiveStr::Ascii("ionis"),
        dictgen::InsensitiveStr::Ascii("ionning"),
        dictgen::InsensitiveStr::Ascii("iont"),
        dictgen::InsensitiveStr::Ascii("on"),
        dictgen::InsensitiveStr::Ascii("oned"),
        dictgen::InsensitiveStr::Ascii("oning"),
        dictgen::InsensitiveStr::Ascii("ons"),
        dictgen::InsensitiveStr::Ascii("opm"),
        dictgen::InsensitiveStr::Ascii("opmed"),
        dictgen::InsensitiveStr::Ascii("opming"),
        dictgen::InsensitiveStr::Ascii("opms"),
        dictgen::InsensitiveStr::Ascii("opn"),
        dictgen::InsensitiveStr::Ascii("opned"),
        dictgen::InsensitiveStr::Ascii("opning"),
        dictgen::InsensitiveStr::Ascii("opns"),
    ],
    values: &[
        &["section"],
        &["sections"],
        &["sections"],
        &["sectioning"],
        &["sectioned", "section"],
        &["section"],
        &["sectioned"],
        &["sectioning"],
        &["sections"],
        &["section"],
        &["sectioned"],
        &["sectioning"],
        &["sections"],
        &["section"],
        &["sectioned"],
        &["sectioning"],
        &["sections"],
    ],
    range: 2..=7,
};

static WORD_SECR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SECR_CHILDREN),
    value: None,
};

pub static WORD_SECR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("atary"),
        dictgen::InsensitiveStr::Ascii("atery"),
        dictgen::InsensitiveStr::Ascii("ect"),
        dictgen::InsensitiveStr::Ascii("elty"),
        dictgen::InsensitiveStr::Ascii("est"),
        dictgen::InsensitiveStr::Ascii("etas"),
        dictgen::InsensitiveStr::Ascii("etery"),
        dictgen::InsensitiveStr::Ascii("etley"),
        dictgen::InsensitiveStr::Ascii("etos"),
        dictgen::InsensitiveStr::Ascii("ety"),
        dictgen::InsensitiveStr::Ascii("ion"),
        dictgen::InsensitiveStr::Ascii("uity"),
    ],
    values: &[
        &["secretary"],
        &["secretary"],
        &["secret"],
        &["secretly"],
        &["secrets"],
        &["secrets"],
        &["secretary"],
        &["secretly"],
        &["secrets"],
        &["secretly"],
        &["section"],
        &["security"],
    ],
    range: 3..=5,
};

static WORD_SECQ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SECQ_CHILDREN),
    value: None,
};

pub static WORD_SECQ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("uence")],
    values: &[&["sequence"]],
    range: 5..=5,
};

static WORD_SECP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SECP_CHILDREN),
    value: None,
};

pub static WORD_SECP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ter")],
    values: &[&["scepter"]],
    range: 3..=3,
};

static WORD_SECO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SECO_CHILDREN),
    value: None,
};

pub static WORD_SECO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("d"),
        dictgen::InsensitiveStr::Ascii("ds"),
        dictgen::InsensitiveStr::Ascii("nadry"),
        dictgen::InsensitiveStr::Ascii("ncary"),
        dictgen::InsensitiveStr::Ascii("ndaray"),
        dictgen::InsensitiveStr::Ascii("nday"),
        dictgen::InsensitiveStr::Ascii("ndy"),
        dictgen::InsensitiveStr::Ascii("nf"),
        dictgen::InsensitiveStr::Ascii("nfs"),
        dictgen::InsensitiveStr::Ascii("nly"),
        dictgen::InsensitiveStr::Ascii("ns"),
        dictgen::InsensitiveStr::Ascii("nt"),
        dictgen::InsensitiveStr::Ascii("ntary"),
        dictgen::InsensitiveStr::Ascii("ntly"),
        dictgen::InsensitiveStr::Ascii("nts"),
        dictgen::InsensitiveStr::Ascii("rd"),
        dictgen::InsensitiveStr::Ascii("rds"),
        dictgen::InsensitiveStr::Ascii("tr"),
        dictgen::InsensitiveStr::Ascii("und"),
        dictgen::InsensitiveStr::Ascii("undary"),
        dictgen::InsensitiveStr::Ascii("undly"),
        dictgen::InsensitiveStr::Ascii("unds"),
    ],
    values: &[
        &["second"],
        &["seconds"],
        &["secondary"],
        &["secondary"],
        &["secondary"],
        &["secondary"],
        &["secondly", "secondary"],
        &["second"],
        &["seconds"],
        &["secondly"],
        &["second", "seconds"],
        &["second"],
        &["secondary"],
        &["secondly"],
        &["seconds"],
        &["second"],
        &["seconds"],
        &["sector"],
        &["second"],
        &["secondary"],
        &["secondly"],
        &["seconds"],
    ],
    range: 1..=6,
};

static WORD_SECN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SECN_CHILDREN),
    value: None,
};

pub static WORD_SECN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("e")],
    values: &[&["scene"]],
    range: 1..=1,
};

static WORD_SECI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SECI_CHILDREN),
    value: None,
};

pub static WORD_SECI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("fic"),
        dictgen::InsensitiveStr::Ascii("fied"),
        dictgen::InsensitiveStr::Ascii("on"),
        dictgen::InsensitiveStr::Ascii("ons"),
        dictgen::InsensitiveStr::Ascii("rity"),
        dictgen::InsensitiveStr::Ascii("ton"),
        dictgen::InsensitiveStr::Ascii("tons"),
    ],
    values: &[
        &["specific"],
        &["specified"],
        &["section"],
        &["sections"],
        &["security"],
        &["section"],
        &["sections"],
    ],
    range: 2..=4,
};

static WORD_SECE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SECE_CHILDREN),
    value: None,
};

pub static WORD_SECE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("eded"),
        dictgen::InsensitiveStr::Ascii("ne"),
        dictgen::InsensitiveStr::Ascii("rtary"),
        dictgen::InsensitiveStr::Ascii("rtly"),
        dictgen::InsensitiveStr::Ascii("rts"),
    ],
    values: &[
        &["succeed", "secede"],
        &["succeeded", "seceded"],
        &["scene"],
        &["secretary"],
        &["secretly"],
        &["secrets"],
    ],
    range: 2..=5,
};

static WORD_SECC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SECC_CHILDREN),
    value: None,
};

pub static WORD_SECC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eeded"),
        dictgen::InsensitiveStr::Ascii("ond"),
        dictgen::InsensitiveStr::Ascii("onds"),
        dictgen::InsensitiveStr::Ascii("tion"),
    ],
    values: &[
        &["seceded", "succeeded"],
        &["second"],
        &["seconds"],
        &["section"],
    ],
    range: 3..=5,
};

static WORD_SEB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SEB_CHILDREN),
    value: None,
};

pub static WORD_SEB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("asitan"),
        dictgen::InsensitiveStr::Ascii("astain"),
        dictgen::InsensitiveStr::Ascii("astiaan"),
        dictgen::InsensitiveStr::Ascii("astin"),
        dictgen::InsensitiveStr::Ascii("rian"),
        dictgen::InsensitiveStr::Ascii("satian"),
    ],
    values: &[
        &["sebastian"],
        &["sebastian"],
        &["sebastian"],
        &["sebastian"],
        &["serbian"],
        &["sebastian"],
    ],
    range: 4..=7,
};

static WORD_SEA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SEA_CHILDREN),
    value: None,
};

pub static WORD_SEA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ch"),
        dictgen::InsensitiveStr::Ascii("ched"),
        dictgen::InsensitiveStr::Ascii("ches"),
        dictgen::InsensitiveStr::Ascii("ching"),
        dictgen::InsensitiveStr::Ascii("chkey"),
        dictgen::InsensitiveStr::Ascii("crchable"),
        dictgen::InsensitiveStr::Ascii("hakws"),
        dictgen::InsensitiveStr::Ascii("hawkers"),
        dictgen::InsensitiveStr::Ascii("haws"),
        dictgen::InsensitiveStr::Ascii("hwaks"),
        dictgen::InsensitiveStr::Ascii("mlessley"),
        dictgen::InsensitiveStr::Ascii("mlessy"),
        dictgen::InsensitiveStr::Ascii("ntor"),
        dictgen::InsensitiveStr::Ascii("ntors"),
        dictgen::InsensitiveStr::Ascii("onal"),
        dictgen::InsensitiveStr::Ascii("rcahble"),
        dictgen::InsensitiveStr::Ascii("rchd"),
        dictgen::InsensitiveStr::Ascii("rche"),
        dictgen::InsensitiveStr::Ascii("rcheable"),
        dictgen::InsensitiveStr::Ascii("rchign"),
        dictgen::InsensitiveStr::Ascii("rchin"),
        dictgen::InsensitiveStr::Ascii("rchs"),
        dictgen::InsensitiveStr::Ascii("rh"),
        dictgen::InsensitiveStr::Ascii("tch"),
    ],
    values: &[
        &["search"],
        &["searched"],
        &["searches"],
        &["searching"],
        &["searchkey"],
        &["searchable"],
        &["seahawks"],
        &["seahawks"],
        &["seahawks"],
        &["seahawks"],
        &["seamlessly"],
        &["seamlessly"],
        &["senator"],
        &["senators"],
        &["seasonal"],
        &["searchable"],
        &["searched"],
        &["search", "searched"],
        &["searchable"],
        &["searching"],
        &["searching"],
        &["searches"],
        &["search"],
        &["search"],
    ],
    range: 2..=8,
};

static WORD_SC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_SC_CHILDREN),
    value: None,
};

static WORD_SC_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_SCA_NODE),
    None,
    Some(&WORD_SCC_NODE),
    None,
    Some(&WORD_SCE_NODE),
    None,
    None,
    Some(&WORD_SCH_NODE),
    Some(&WORD_SCI_NODE),
    None,
    Some(&WORD_SCK_NODE),
    Some(&WORD_SCL_NODE),
    None,
    Some(&WORD_SCN_NODE),
    Some(&WORD_SCO_NODE),
    Some(&WORD_SCP_NODE),
    None,
    Some(&WORD_SCR_NODE),
    None,
    Some(&WORD_SCT_NODE),
    Some(&WORD_SCU_NODE),
    None,
    None,
    None,
    Some(&WORD_SCY_NODE),
    None,
];

static WORD_SCY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SCY_CHILDREN),
    value: None,
};

pub static WORD_SCY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("hter")],
    values: &[&["scyther"]],
    range: 4..=4,
};

static WORD_SCU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SCU_CHILDREN),
    value: None,
};

pub static WORD_SCU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("bscribe"),
        dictgen::InsensitiveStr::Ascii("bscribed"),
        dictgen::InsensitiveStr::Ascii("bscriber"),
        dictgen::InsensitiveStr::Ascii("bscribes"),
        dictgen::InsensitiveStr::Ascii("ccess"),
        dictgen::InsensitiveStr::Ascii("ccesses"),
        dictgen::InsensitiveStr::Ascii("ccessully"),
        dictgen::InsensitiveStr::Ascii("lpter"),
        dictgen::InsensitiveStr::Ascii("lpters"),
        dictgen::InsensitiveStr::Ascii("lpteur"),
        dictgen::InsensitiveStr::Ascii("lputre"),
        dictgen::InsensitiveStr::Ascii("ltpure"),
        dictgen::InsensitiveStr::Ascii("plture"),
        dictgen::InsensitiveStr::Ascii("pt"),
        dictgen::InsensitiveStr::Ascii("pted"),
        dictgen::InsensitiveStr::Ascii("pting"),
        dictgen::InsensitiveStr::Ascii("pture"),
        dictgen::InsensitiveStr::Ascii("ptures"),
        dictgen::InsensitiveStr::Ascii("rtiny"),
    ],
    values: &[
        &["subscribe"],
        &["subscribed"],
        &["subscriber"],
        &["subscribes"],
        &["success"],
        &["successes"],
        &["successfully"],
        &["sculpture", "sculptor"],
        &["sculptors", "sculptures"],
        &["sculpture"],
        &["sculpture"],
        &["sculpture"],
        &["sculpture"],
        &["sculpt"],
        &["sculpted"],
        &["sculpting"],
        &["sculpture"],
        &["sculptures"],
        &["scrutiny"],
    ],
    range: 2..=9,
};

static WORD_SCT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SCT_CHILDREN),
    value: None,
};

pub static WORD_SCT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ion"),
        dictgen::InsensitiveStr::Ascii("ional"),
        dictgen::InsensitiveStr::Ascii("ioned"),
        dictgen::InsensitiveStr::Ascii("ioning"),
        dictgen::InsensitiveStr::Ascii("ions"),
        dictgen::InsensitiveStr::Ascii("ipt"),
        dictgen::InsensitiveStr::Ascii("ipted"),
        dictgen::InsensitiveStr::Ascii("ipting"),
        dictgen::InsensitiveStr::Ascii("ipts"),
        dictgen::InsensitiveStr::Ascii("osman"),
        dictgen::InsensitiveStr::Ascii("ript"),
        dictgen::InsensitiveStr::Ascii("ripted"),
        dictgen::InsensitiveStr::Ascii("ripting"),
        dictgen::InsensitiveStr::Ascii("ripts"),
    ],
    values: &[
        &["section", "suction"],
        &["sectional", "suctional"],
        &["sectioned", "suctioned"],
        &["sectioning", "suctioning"],
        &["sections", "suctions"],
        &["script"],
        &["scripted"],
        &["scripting"],
        &["scripts"],
        &["scotsman"],
        &["script"],
        &["scripted"],
        &["scripting"],
        &["scripts"],
    ],
    range: 3..=7,
};

static WORD_SCR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_SCR_CHILDREN),
    value: None,
};

static WORD_SCR_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_SCRA_NODE),
    None,
    None,
    None,
    Some(&WORD_SCRE_NODE),
    None,
    None,
    None,
    Some(&WORD_SCRI_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_SCRO_NODE),
    Some(&WORD_SCRP_NODE),
    None,
    Some(&WORD_SCRR_NODE),
    None,
    Some(&WORD_SCRT_NODE),
    Some(&WORD_SCRU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_SCRU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SCRU_CHILDREN),
    value: None,
};

pub static WORD_SCRU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("itny"),
        dictgen::InsensitiveStr::Ascii("nity"),
        dictgen::InsensitiveStr::Ascii("tiney"),
        dictgen::InsensitiveStr::Ascii("tinity"),
        dictgen::InsensitiveStr::Ascii("tinty"),
    ],
    values: &[
        &["scrutiny"],
        &["scrutiny"],
        &["scrutiny"],
        &["scrutiny"],
        &["scrutiny"],
    ],
    range: 4..=6,
};

static WORD_SCRT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SCRT_CHILDREN),
    value: None,
};

pub static WORD_SCRT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ip"),
        dictgen::InsensitiveStr::Ascii("iped"),
        dictgen::InsensitiveStr::Ascii("iping"),
        dictgen::InsensitiveStr::Ascii("ips"),
    ],
    values: &[&["script"], &["scripted"], &["scripting"], &["scripts"]],
    range: 2..=5,
};

static WORD_SCRR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SCRR_CHILDREN),
    value: None,
};

pub static WORD_SCRR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("en")],
    values: &[&["screen"]],
    range: 2..=2,
};

static WORD_SCRP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SCRP_CHILDREN),
    value: None,
};

pub static WORD_SCRP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("it"),
        dictgen::InsensitiveStr::Ascii("ited"),
        dictgen::InsensitiveStr::Ascii("iting"),
        dictgen::InsensitiveStr::Ascii("its"),
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("ted"),
        dictgen::InsensitiveStr::Ascii("ting"),
        dictgen::InsensitiveStr::Ascii("ts"),
    ],
    values: &[
        &["script"],
        &["scripted"],
        &["scripting"],
        &["scripts"],
        &["script"],
        &["scripted"],
        &["scripting"],
        &["scripts"],
    ],
    range: 1..=5,
};

static WORD_SCRO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SCRO_CHILDREN),
    value: None,
};

pub static WORD_SCRO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ates"),
        dictgen::InsensitiveStr::Ascii("ipt"),
        dictgen::InsensitiveStr::Ascii("ipted"),
        dictgen::InsensitiveStr::Ascii("ipting"),
        dictgen::InsensitiveStr::Ascii("ipts"),
        dictgen::InsensitiveStr::Ascii("ipttype"),
        dictgen::InsensitiveStr::Ascii("llablbe"),
        dictgen::InsensitiveStr::Ascii("llade"),
        dictgen::InsensitiveStr::Ascii("lld"),
        dictgen::InsensitiveStr::Ascii("llin"),
        dictgen::InsensitiveStr::Ascii("olbar"),
        dictgen::InsensitiveStr::Ascii("pion"),
    ],
    values: &[
        &["socrates"],
        &["script"],
        &["scripted"],
        &["scripting"],
        &["scripts"],
        &["scripttype"],
        &["scrollable"],
        &["scrolled"],
        &["scrolled"],
        &["scrolling"],
        &["scrollbar"],
        &["scorpion"],
    ],
    range: 3..=7,
};

static WORD_SCRI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SCRI_CHILDREN),
    value: None,
};

pub static WORD_SCRI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ipt"),
        dictgen::InsensitiveStr::Ascii("ipted"),
        dictgen::InsensitiveStr::Ascii("ipting"),
        dictgen::InsensitiveStr::Ascii("opted"),
        dictgen::InsensitiveStr::Ascii("opting"),
        dictgen::InsensitiveStr::Ascii("opts"),
        dictgen::InsensitiveStr::Ascii("opttype"),
        dictgen::InsensitiveStr::Ascii("pe"),
        dictgen::InsensitiveStr::Ascii("ping"),
        dictgen::InsensitiveStr::Ascii("pot"),
        dictgen::InsensitiveStr::Ascii("poted"),
        dictgen::InsensitiveStr::Ascii("poting"),
        dictgen::InsensitiveStr::Ascii("pots"),
        dictgen::InsensitiveStr::Ascii("pst"),
        dictgen::InsensitiveStr::Ascii("pte"),
        dictgen::InsensitiveStr::Ascii("ptores"),
        dictgen::InsensitiveStr::Ascii("ptue"),
        dictgen::InsensitiveStr::Ascii("pturae"),
        dictgen::InsensitiveStr::Ascii("ptus"),
        dictgen::InsensitiveStr::Ascii("ptype"),
        dictgen::InsensitiveStr::Ascii("putres"),
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("tp"),
        dictgen::InsensitiveStr::Ascii("tped"),
        dictgen::InsensitiveStr::Ascii("tping"),
        dictgen::InsensitiveStr::Ascii("tps"),
        dictgen::InsensitiveStr::Ascii("tpt"),
        dictgen::InsensitiveStr::Ascii("tpts"),
        dictgen::InsensitiveStr::Ascii("tpures"),
        dictgen::InsensitiveStr::Ascii("ts"),
    ],
    values: &[
        &["script"],
        &["scripted"],
        &["scripting"],
        &["scripted"],
        &["scripting"],
        &["scripts"],
        &["scripttype"],
        &["scrape", "scribe", "scrip", "script", "stripe"],
        &["scripting"],
        &["script"],
        &["scripted"],
        &["scripting"],
        &["scripts"],
        &["scripts"],
        &["script", "scripted"],
        &["scriptures"],
        &["scriptures"],
        &["scriptures"],
        &["scripts"],
        &["scripttype"],
        &["scriptures"],
        &["scrip", "script"],
        &["script"],
        &["scripted"],
        &["scripting"],
        &["scripts"],
        &["script"],
        &["scripts"],
        &["scriptures"],
        &["scripts"],
    ],
    range: 1..=7,
};

static WORD_SCRE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SCRE_CHILDREN),
    value: None,
};

pub static WORD_SCRE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eb"),
        dictgen::InsensitiveStr::Ascii("ebs"),
        dictgen::InsensitiveStr::Ascii("em"),
        dictgen::InsensitiveStr::Ascii("enchot"),
        dictgen::InsensitiveStr::Ascii("enchots"),
        dictgen::InsensitiveStr::Ascii("enshat"),
        dictgen::InsensitiveStr::Ascii("enshit"),
        dictgen::InsensitiveStr::Ascii("enshoot"),
        dictgen::InsensitiveStr::Ascii("enshoots"),
        dictgen::InsensitiveStr::Ascii("enwrighter"),
        dictgen::InsensitiveStr::Ascii("nn"),
    ],
    values: &[
        &["screen"],
        &["screens"],
        &["scream", "screen"],
        &["screenshot"],
        &["screenshots"],
        &["screenshot"],
        &["screenshot"],
        &["screenshot"],
        &["screenshot"],
        &["screenwriter"],
        &["screen"],
    ],
    range: 2..=10,
};

static WORD_SCRA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SCRA_CHILDREN),
    value: None,
};

pub static WORD_SCRA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ch"),
        dictgen::InsensitiveStr::Ascii("ched"),
        dictgen::InsensitiveStr::Ascii("ches"),
        dictgen::InsensitiveStr::Ascii("ching"),
        dictgen::InsensitiveStr::Ascii("chs"),
        dictgen::InsensitiveStr::Ascii("cth"),
        dictgen::InsensitiveStr::Ascii("cthed"),
        dictgen::InsensitiveStr::Ascii("cthes"),
        dictgen::InsensitiveStr::Ascii("cthing"),
        dictgen::InsensitiveStr::Ascii("mbe"),
        dictgen::InsensitiveStr::Ascii("mbeld"),
        dictgen::InsensitiveStr::Ascii("mbleing"),
        dictgen::InsensitiveStr::Ascii("mblies"),
        dictgen::InsensitiveStr::Ascii("o"),
        dictgen::InsensitiveStr::Ascii("tchs"),
        dictgen::InsensitiveStr::Ascii("thces"),
    ],
    values: &[
        &["scratch"],
        &["scratched"],
        &["scratches"],
        &["scratching"],
        &["scratches"],
        &["scratch"],
        &["scratched"],
        &["scratches"],
        &["scratching"],
        &["scramble"],
        &["scrambled"],
        &["scrambling"],
        &["scramble"],
        &["scrap"],
        &["scratches"],
        &["scratches"],
    ],
    range: 1..=7,
};

static WORD_SCP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SCP_CHILDREN),
    value: None,
};

pub static WORD_SCP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("eter")],
    values: &[&["scepter"]],
    range: 4..=4,
};

static WORD_SCO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SCO_CHILDREN),
    value: None,
};

pub static WORD_SCO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ket"),
        dictgen::InsensitiveStr::Ascii("ll"),
        dictgen::InsensitiveStr::Ascii("lling"),
        dictgen::InsensitiveStr::Ascii("ndary"),
        dictgen::InsensitiveStr::Ascii("oterers"),
        dictgen::InsensitiveStr::Ascii("otes"),
        dictgen::InsensitiveStr::Ascii("peing"),
        dictgen::InsensitiveStr::Ascii("prion"),
        dictgen::InsensitiveStr::Ascii("rates"),
        dictgen::InsensitiveStr::Ascii("rebaord"),
        dictgen::InsensitiveStr::Ascii("reboad"),
        dictgen::InsensitiveStr::Ascii("reborad"),
        dictgen::InsensitiveStr::Ascii("rebord"),
        dictgen::InsensitiveStr::Ascii("rebored"),
        dictgen::InsensitiveStr::Ascii("ripon"),
        dictgen::InsensitiveStr::Ascii("rpin"),
        dictgen::InsensitiveStr::Ascii("rpiomon"),
        dictgen::InsensitiveStr::Ascii("rpoin"),
        dictgen::InsensitiveStr::Ascii("stman"),
        dictgen::InsensitiveStr::Ascii("ttisch"),
        dictgen::InsensitiveStr::Ascii("urce"),
        dictgen::InsensitiveStr::Ascii("urced"),
        dictgen::InsensitiveStr::Ascii("urcer"),
        dictgen::InsensitiveStr::Ascii("urces"),
    ],
    values: &[
        &["socket"],
        &["scroll"],
        &["scrolling"],
        &["secondary"],
        &["scooters"],
        &["scooters"],
        &["scoping"],
        &["scorpion"],
        &["socrates"],
        &["scoreboard"],
        &["scoreboard"],
        &["scoreboard"],
        &["scoreboard"],
        &["scoreboard"],
        &["scorpion"],
        &["scorpion"],
        &["scorpion"],
        &["scorpion"],
        &["scotsman"],
        &["scottish"],
        &["source", "scouse"],
        &["sourced", "scoured"],
        &["scourer", "sorcerer", "scouser"],
        &["sources"],
    ],
    range: 2..=7,
};

static WORD_SCN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SCN_CHILDREN),
    value: None,
};

pub static WORD_SCN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("adinavia"),
        dictgen::InsensitiveStr::Ascii("adinavian"),
        dictgen::InsensitiveStr::Ascii("eario"),
        dictgen::InsensitiveStr::Ascii("earios"),
    ],
    values: &[
        &["scandinavia"],
        &["scandinavian"],
        &["scenario"],
        &["scenarios"],
    ],
    range: 5..=9,
};

static WORD_SCL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SCL_CHILDREN),
    value: None,
};

pub static WORD_SCL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ar"),
        dictgen::InsensitiveStr::Ascii("upture"),
    ],
    values: &[&["scalar"], &["sculpture"]],
    range: 2..=6,
};

static WORD_SCK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SCK_CHILDREN),
    value: None,
};

pub static WORD_SCK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("etch"),
        dictgen::InsensitiveStr::Ascii("etched"),
        dictgen::InsensitiveStr::Ascii("etches"),
        dictgen::InsensitiveStr::Ascii("etching"),
    ],
    values: &[&["sketch"], &["sketched"], &["sketches"], &["sketching"]],
    range: 4..=7,
};

static WORD_SCI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SCI_CHILDREN),
    value: None,
};

pub static WORD_SCI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("encers"),
        dictgen::InsensitiveStr::Ascii("encists"),
        dictgen::InsensitiveStr::Ascii("ense"),
        dictgen::InsensitiveStr::Ascii("entests"),
        dictgen::InsensitiveStr::Ascii("entfic"),
        dictgen::InsensitiveStr::Ascii("entfically"),
        dictgen::InsensitiveStr::Ascii("entficaly"),
        dictgen::InsensitiveStr::Ascii("entficly"),
        dictgen::InsensitiveStr::Ascii("entic"),
        dictgen::InsensitiveStr::Ascii("entiests"),
        dictgen::InsensitiveStr::Ascii("entifc"),
        dictgen::InsensitiveStr::Ascii("entifcally"),
        dictgen::InsensitiveStr::Ascii("entifcaly"),
        dictgen::InsensitiveStr::Ascii("entifcly"),
        dictgen::InsensitiveStr::Ascii("entificaly"),
        dictgen::InsensitiveStr::Ascii("entificlly"),
        dictgen::InsensitiveStr::Ascii("entis"),
        dictgen::InsensitiveStr::Ascii("entiss"),
        dictgen::InsensitiveStr::Ascii("entisst"),
        dictgen::InsensitiveStr::Ascii("entits"),
        dictgen::InsensitiveStr::Ascii("nce"),
        dictgen::InsensitiveStr::Ascii("nece"),
        dictgen::InsensitiveStr::Ascii("ntiallation"),
        dictgen::InsensitiveStr::Ascii("ntillatqt"),
        dictgen::InsensitiveStr::Ascii("prt"),
        dictgen::InsensitiveStr::Ascii("prted"),
        dictgen::InsensitiveStr::Ascii("prting"),
        dictgen::InsensitiveStr::Ascii("prts"),
        dictgen::InsensitiveStr::Ascii("pt"),
        dictgen::InsensitiveStr::Ascii("pted"),
        dictgen::InsensitiveStr::Ascii("pting"),
        dictgen::InsensitiveStr::Ascii("pts"),
        dictgen::InsensitiveStr::Ascii("ript"),
        dictgen::InsensitiveStr::Ascii("ripts"),
        dictgen::InsensitiveStr::Ascii("rpt"),
        dictgen::InsensitiveStr::Ascii("rpts"),
        dictgen::InsensitiveStr::Ascii("rptures"),
    ],
    values: &[
        &["sciences"],
        &["scientists"],
        &["sciences"],
        &["scientists"],
        &["scientific"],
        &["scientifically"],
        &["scientifically"],
        &["scientifically"],
        &["scientific"],
        &["scientists"],
        &["scientific"],
        &["scientifically"],
        &["scientifically"],
        &["scientifically"],
        &["scientifically"],
        &["scientifically"],
        &["scientist"],
        &["scientist"],
        &["scientists", "scientist"],
        &["scientist"],
        &["science"],
        &["science"],
        &["scintillation"],
        &["scintillaqt"],
        &["script"],
        &["scripted"],
        &["scripting"],
        &["scripts"],
        &["script", "skipped"],
        &["scripted"],
        &["scripting"],
        &["scripts", "skips"],
        &["script"],
        &["scripts"],
        &["script"],
        &["scripts"],
        &["scriptures"],
    ],
    range: 2..=11,
};

static WORD_SCH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SCH_CHILDREN),
    value: None,
};

pub static WORD_SCH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("dule"),
        dictgen::InsensitiveStr::Ascii("duled"),
        dictgen::InsensitiveStr::Ascii("duleing"),
        dictgen::InsensitiveStr::Ascii("duler"),
        dictgen::InsensitiveStr::Ascii("dules"),
        dictgen::InsensitiveStr::Ascii("duling"),
        dictgen::InsensitiveStr::Ascii("eam"),
        dictgen::InsensitiveStr::Ascii("edual"),
        dictgen::InsensitiveStr::Ascii("eduald"),
        dictgen::InsensitiveStr::Ascii("edualed"),
        dictgen::InsensitiveStr::Ascii("edualing"),
        dictgen::InsensitiveStr::Ascii("eduleing"),
        dictgen::InsensitiveStr::Ascii("edulier"),
        dictgen::InsensitiveStr::Ascii("edulling"),
        dictgen::InsensitiveStr::Ascii("eduluing"),
        dictgen::InsensitiveStr::Ascii("eems"),
        dictgen::InsensitiveStr::Ascii("em"),
        dictgen::InsensitiveStr::Ascii("emd"),
        dictgen::InsensitiveStr::Ascii("ems"),
        dictgen::InsensitiveStr::Ascii("eudling"),
        dictgen::InsensitiveStr::Ascii("isophrenic"),
        dictgen::InsensitiveStr::Ascii("iziphrenic"),
        dictgen::InsensitiveStr::Ascii("izophernia"),
        dictgen::InsensitiveStr::Ascii("izophernic"),
        dictgen::InsensitiveStr::Ascii("izophrania"),
        dictgen::InsensitiveStr::Ascii("izophrena"),
        dictgen::InsensitiveStr::Ascii("izophreniiic"),
        dictgen::InsensitiveStr::Ascii("izophrentic"),
        dictgen::InsensitiveStr::Ascii("izoprhenia"),
        dictgen::InsensitiveStr::Ascii("izoprhenic"),
        dictgen::InsensitiveStr::Ascii("me"),
        dictgen::InsensitiveStr::Ascii("mea"),
        dictgen::InsensitiveStr::Ascii("meas"),
        dictgen::InsensitiveStr::Ascii("mes"),
        dictgen::InsensitiveStr::Ascii("oalrs"),
        dictgen::InsensitiveStr::Ascii("oalrship"),
        dictgen::InsensitiveStr::Ascii("olalry"),
        dictgen::InsensitiveStr::Ascii("olarhip"),
        dictgen::InsensitiveStr::Ascii("olarhips"),
        dictgen::InsensitiveStr::Ascii("olarhsips"),
        dictgen::InsensitiveStr::Ascii("olarley"),
        dictgen::InsensitiveStr::Ascii("olarstic"),
        dictgen::InsensitiveStr::Ascii("olary"),
        dictgen::InsensitiveStr::Ascii("olership"),
        dictgen::InsensitiveStr::Ascii("olerships"),
        dictgen::InsensitiveStr::Ascii("olorship"),
        dictgen::InsensitiveStr::Ascii("olorships"),
        dictgen::InsensitiveStr::Ascii("oodle"),
        dictgen::InsensitiveStr::Ascii("oold"),
        dictgen::InsensitiveStr::Ascii("oole"),
        dictgen::InsensitiveStr::Ascii("ould"),
        dictgen::InsensitiveStr::Ascii("ozophrenia"),
        dictgen::InsensitiveStr::Ascii("ozophrenic"),
        dictgen::InsensitiveStr::Ascii("yzophrenia"),
        dictgen::InsensitiveStr::Ascii("yzophrenic"),
        dictgen::InsensitiveStr::Ascii("ziophrenia"),
        dictgen::InsensitiveStr::Ascii("ziophrenic"),
    ],
    values: &[
        &["schedule"],
        &["scheduled"],
        &["scheduling"],
        &["scheduler"],
        &["schedules"],
        &["scheduling"],
        &["schema"],
        &["schedule"],
        &["scheduled"],
        &["scheduled"],
        &["scheduling"],
        &["scheduling"],
        &["scheduler"],
        &["scheduling"],
        &["scheduling"],
        &["schemes"],
        &["scheme"],
        &["schemed"],
        &["schemes", "schemas"],
        &["scheduling"],
        &["schizophrenic"],
        &["schizophrenic"],
        &["schizophrenia"],
        &["schizophrenic"],
        &["schizophrenia"],
        &["schizophrenia"],
        &["schizophrenic"],
        &["schizophrenic"],
        &["schizophrenia"],
        &["schizophrenic"],
        &["scheme"],
        &["schema"],
        &["schemas"],
        &["schemes"],
        &["scholars"],
        &["scholarships"],
        &["scholarly"],
        &["scholarship"],
        &["scholarship", "scholarships"],
        &["scholarships"],
        &["scholarly"],
        &["scholastic", "scholarly"],
        &["scholarly"],
        &["scholarship"],
        &["scholarships"],
        &["scholarship"],
        &["scholarships"],
        &["schooled"],
        &["schooled"],
        &["schooled", "schools"],
        &["should"],
        &["schizophrenia"],
        &["schizophrenic"],
        &["schizophrenia"],
        &["schizophrenic"],
        &["schizophrenia"],
        &["schizophrenic"],
    ],
    range: 2..=12,
};

static WORD_SCE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SCE_CHILDREN),
    value: None,
};

pub static WORD_SCE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("anrio"),
        dictgen::InsensitiveStr::Ascii("anrios"),
        dictgen::InsensitiveStr::Ascii("cified"),
        dictgen::InsensitiveStr::Ascii("en"),
        dictgen::InsensitiveStr::Ascii("ens"),
        dictgen::InsensitiveStr::Ascii("intific"),
        dictgen::InsensitiveStr::Ascii("intifically"),
        dictgen::InsensitiveStr::Ascii("intist"),
        dictgen::InsensitiveStr::Ascii("intists"),
        dictgen::InsensitiveStr::Ascii("me"),
        dictgen::InsensitiveStr::Ascii("mes"),
        dictgen::InsensitiveStr::Ascii("naireo"),
        dictgen::InsensitiveStr::Ascii("naireos"),
        dictgen::InsensitiveStr::Ascii("narioes"),
        dictgen::InsensitiveStr::Ascii("narion"),
        dictgen::InsensitiveStr::Ascii("narions"),
        dictgen::InsensitiveStr::Ascii("narious"),
        dictgen::InsensitiveStr::Ascii("nce"),
        dictgen::InsensitiveStr::Ascii("nces"),
        dictgen::InsensitiveStr::Ascii("negraaph"),
        dictgen::InsensitiveStr::Ascii("negraaphs"),
        dictgen::InsensitiveStr::Ascii("ond"),
        dictgen::InsensitiveStr::Ascii("onds"),
        dictgen::InsensitiveStr::Ascii("pture"),
        dictgen::InsensitiveStr::Ascii("stion"),
        dictgen::InsensitiveStr::Ascii("tch"),
        dictgen::InsensitiveStr::Ascii("tched"),
        dictgen::InsensitiveStr::Ascii("tches"),
        dictgen::InsensitiveStr::Ascii("tching"),
    ],
    values: &[
        &["scenario"],
        &["scenarios"],
        &["specified"],
        &["scene", "seen", "screen", "scheme"],
        &["scenes", "screens", "schemes"],
        &["scientific"],
        &["scientifically"],
        &["scientist"],
        &["scientists"],
        &["scheme", "scene"],
        &["schemes", "scenes"],
        &["scenario"],
        &["scenarios"],
        &["scenarios"],
        &["scenario"],
        &["scenarios"],
        &["scenarios"],
        &["scene", "science", "sense"],
        &["scenes", "sciences", "senses", "census"],
        &["scenegraph"],
        &["scenegraphs"],
        &["second"],
        &["seconds"],
        &["sceptre"],
        &["section"],
        &["sketch"],
        &["sketched"],
        &["sketches"],
        &["sketching"],
    ],
    range: 2..=11,
};

static WORD_SCC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SCC_CHILDREN),
    value: None,
};

pub static WORD_SCC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ess"),
        dictgen::InsensitiveStr::Ascii("esses"),
        dictgen::InsensitiveStr::Ascii("essful"),
        dictgen::InsensitiveStr::Ascii("essfully"),
        dictgen::InsensitiveStr::Ascii("ope"),
        dictgen::InsensitiveStr::Ascii("opes"),
        dictgen::InsensitiveStr::Ascii("riping"),
        dictgen::InsensitiveStr::Ascii("ript"),
        dictgen::InsensitiveStr::Ascii("ripted"),
        dictgen::InsensitiveStr::Ascii("ripts"),
    ],
    values: &[
        &["success"],
        &["successes"],
        &["successful"],
        &["successfully"],
        &["scope"],
        &["scopes"],
        &["scripting"],
        &["script"],
        &["scripted"],
        &["scripts"],
    ],
    range: 3..=8,
};

static WORD_SCA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_SCA_CHILDREN),
    value: None,
};

static WORD_SCA_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    None,
    None,
    Some(&WORD_SCAE_NODE),
    Some(&WORD_SCAF_NODE),
    None,
    Some(&WORD_SCAH_NODE),
    None,
    None,
    None,
    Some(&WORD_SCAL_NODE),
    None,
    Some(&WORD_SCAN_NODE),
    None,
    None,
    None,
    Some(&WORD_SCAR_NODE),
    None,
    Some(&WORD_SCAT_NODE),
    None,
    Some(&WORD_SCAV_NODE),
    None,
    None,
    None,
    None,
];

static WORD_SCAV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SCAV_CHILDREN),
    value: None,
};

pub static WORD_SCAV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ange"),
        dictgen::InsensitiveStr::Ascii("anged"),
        dictgen::InsensitiveStr::Ascii("anger"),
        dictgen::InsensitiveStr::Ascii("angers"),
        dictgen::InsensitiveStr::Ascii("anges"),
    ],
    values: &[
        &["scavenge"],
        &["scavenged"],
        &["scavenger"],
        &["scavengers"],
        &["scavenges"],
    ],
    range: 4..=6,
};

static WORD_SCAT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SCAT_CHILDREN),
    value: None,
};

pub static WORD_SCAT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ch"),
        dictgen::InsensitiveStr::Ascii("ched"),
        dictgen::InsensitiveStr::Ascii("cher"),
        dictgen::InsensitiveStr::Ascii("ches"),
        dictgen::InsensitiveStr::Ascii("ching"),
        dictgen::InsensitiveStr::Ascii("chs"),
        dictgen::InsensitiveStr::Ascii("chss"),
        dictgen::InsensitiveStr::Ascii("eboarding"),
    ],
    values: &[
        &["catch", "scratch", "sketch"],
        &["caught", "scratched", "sketched"],
        &["catcher", "scratcher", "sketcher"],
        &["catches", "scratches", "sketches"],
        &["catching", "scratching", "sketching"],
        &["catches", "scratches", "sketches"],
        &["catches", "scratches", "sketches"],
        &["skateboarding"],
    ],
    range: 2..=9,
};

static WORD_SCAR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SCAR_CHILDREN),
    value: None,
};

pub static WORD_SCAR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("amento"),
        dictgen::InsensitiveStr::Ascii("ch"),
        dictgen::InsensitiveStr::Ascii("icity"),
        dictgen::InsensitiveStr::Ascii("ifice"),
        dictgen::InsensitiveStr::Ascii("ificed"),
        dictgen::InsensitiveStr::Ascii("ifices"),
        dictgen::InsensitiveStr::Ascii("ificing"),
        dictgen::InsensitiveStr::Ascii("mble"),
        dictgen::InsensitiveStr::Ascii("mbled"),
        dictgen::InsensitiveStr::Ascii("mbling"),
        dictgen::InsensitiveStr::Ascii("tch"),
        dictgen::InsensitiveStr::Ascii("tched"),
        dictgen::InsensitiveStr::Ascii("tches"),
        dictgen::InsensitiveStr::Ascii("tching"),
    ],
    values: &[
        &["sacramento"],
        &["search", "scorch", "scratch"],
        &["scarcity"],
        &["sacrifice"],
        &["sacrificed"],
        &["sacrifices"],
        &["sacrificing"],
        &["scramble"],
        &["scrambled"],
        &["scrambling"],
        &["scratch"],
        &["scratched"],
        &["scratches"],
        &["scratching"],
    ],
    range: 2..=7,
};

static WORD_SCAN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SCAN_CHILDREN),
    value: None,
};

pub static WORD_SCAN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("dales"),
        dictgen::InsensitiveStr::Ascii("dalos"),
        dictgen::InsensitiveStr::Ascii("dalosa"),
        dictgen::InsensitiveStr::Ascii("dalose"),
        dictgen::InsensitiveStr::Ascii("dalosi"),
        dictgen::InsensitiveStr::Ascii("daloso"),
        dictgen::InsensitiveStr::Ascii("danavia"),
        dictgen::InsensitiveStr::Ascii("daniva"),
        dictgen::InsensitiveStr::Ascii("danivia"),
        dictgen::InsensitiveStr::Ascii("danivian"),
        dictgen::InsensitiveStr::Ascii("das"),
        dictgen::InsensitiveStr::Ascii("denavia"),
        dictgen::InsensitiveStr::Ascii("denavian"),
        dictgen::InsensitiveStr::Ascii("dianvia"),
        dictgen::InsensitiveStr::Ascii("dianvian"),
        dictgen::InsensitiveStr::Ascii("dianvians"),
        dictgen::InsensitiveStr::Ascii("dimania"),
        dictgen::InsensitiveStr::Ascii("dinacian"),
        dictgen::InsensitiveStr::Ascii("dinaiva"),
        dictgen::InsensitiveStr::Ascii("dinaivan"),
        dictgen::InsensitiveStr::Ascii("dinava"),
        dictgen::InsensitiveStr::Ascii("dinavan"),
        dictgen::InsensitiveStr::Ascii("dinavica"),
        dictgen::InsensitiveStr::Ascii("dinavien"),
        dictgen::InsensitiveStr::Ascii("dinavion"),
        dictgen::InsensitiveStr::Ascii("dinvia"),
        dictgen::InsensitiveStr::Ascii("divania"),
        dictgen::InsensitiveStr::Ascii("divanian"),
        dictgen::InsensitiveStr::Ascii("dlas"),
        dictgen::InsensitiveStr::Ascii("donavia"),
        dictgen::InsensitiveStr::Ascii("donavian"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("nig"),
        dictgen::InsensitiveStr::Ascii("nign"),
        dictgen::InsensitiveStr::Ascii("nning"),
        dictgen::InsensitiveStr::Ascii("tuary"),
    ],
    values: &[
        &["scandals"],
        &["scandals"],
        &["scandals"],
        &["scandals"],
        &["scandals"],
        &["scandals"],
        &["scandinavia"],
        &["scandinavia"],
        &["scandinavian"],
        &["scandinavian"],
        &["scandals"],
        &["scandinavia"],
        &["scandinavian"],
        &["scandinavian"],
        &["scandinavian"],
        &["scandinavian"],
        &["scandinavia"],
        &["scandinavian"],
        &["scandinavian"],
        &["scandinavia"],
        &["scandinavian"],
        &["scandinavian"],
        &["scandinavian"],
        &["scandinavian"],
        &["scandinavian"],
        &["scandinavia"],
        &["scandinavian"],
        &["scandinavian"],
        &["scandals"],
        &["scandinavia"],
        &["scandinavian"],
        &["scanned"],
        &["scanning"],
        &["scanning"],
        &["scanning"],
        &["scanning"],
        &["sanctuary"],
    ],
    range: 2..=9,
};

static WORD_SCAL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SCAL_CHILDREN),
    value: None,
};

pub static WORD_SCAL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("arizaiton"),
        dictgen::InsensitiveStr::Ascii("arr"),
        dictgen::InsensitiveStr::Ascii("eability"),
        dictgen::InsensitiveStr::Ascii("eable"),
        dictgen::InsensitiveStr::Ascii("eing"),
        dictgen::InsensitiveStr::Ascii("led"),
    ],
    values: &[
        &["scalarization"],
        &["scalar"],
        &["scalability"],
        &["scalable"],
        &["scaling"],
        &["scaled"],
    ],
    range: 3..=9,
};

static WORD_SCAH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SCAH_CHILDREN),
    value: None,
};

pub static WORD_SCAH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("r")],
    values: &[&["schar"]],
    range: 1..=1,
};

static WORD_SCAF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SCAF_CHILDREN),
    value: None,
};

pub static WORD_SCAF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("old"),
        dictgen::InsensitiveStr::Ascii("olded"),
        dictgen::InsensitiveStr::Ascii("older"),
        dictgen::InsensitiveStr::Ascii("oldes"),
        dictgen::InsensitiveStr::Ascii("olding"),
        dictgen::InsensitiveStr::Ascii("olds"),
    ],
    values: &[
        &["scaffold"],
        &["scaffolded"],
        &["scaffolder"],
        &["scaffolds"],
        &["scaffolding"],
        &["scaffolds"],
    ],
    range: 3..=6,
};

static WORD_SCAE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SCAE_CHILDREN),
    value: None,
};

pub static WORD_SCAE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("pgoat")],
    values: &[&["scapegoat"]],
    range: 5..=5,
};

static WORD_SB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SB_CHILDREN),
    value: None,
};

pub static WORD_SB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("sampling")],
    values: &[&["subsampling"]],
    range: 8..=8,
};

static WORD_SA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_SA_CHILDREN),
    value: None,
};

static WORD_SA_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_SAA_NODE),
    Some(&WORD_SAB_NODE),
    Some(&WORD_SAC_NODE),
    Some(&WORD_SAD_NODE),
    Some(&WORD_SAE_NODE),
    Some(&WORD_SAF_NODE),
    Some(&WORD_SAG_NODE),
    None,
    Some(&WORD_SAI_NODE),
    None,
    Some(&WORD_SAK_NODE),
    Some(&WORD_SAL_NODE),
    Some(&WORD_SAM_NODE),
    Some(&WORD_SAN_NODE),
    None,
    Some(&WORD_SAP_NODE),
    None,
    Some(&WORD_SAR_NODE),
    Some(&WORD_SAS_NODE),
    Some(&WORD_SAT_NODE),
    Some(&WORD_SAU_NODE),
    Some(&WORD_SAV_NODE),
    Some(&WORD_SAW_NODE),
    Some(&WORD_SAX_NODE),
    None,
    None,
];

static WORD_SAX_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SAX_CHILDREN),
    value: None,
};

pub static WORD_SAX_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("aphone")],
    values: &[&["saxophone"]],
    range: 6..=6,
};

static WORD_SAW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SAW_CHILDREN),
    value: None,
};

pub static WORD_SAW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("nsea"),
        dictgen::InsensitiveStr::Ascii("nson"),
        dictgen::InsensitiveStr::Ascii("stika"),
        dictgen::InsensitiveStr::Ascii("tay"),
        dictgen::InsensitiveStr::Ascii("tayed"),
        dictgen::InsensitiveStr::Ascii("tayes"),
        dictgen::InsensitiveStr::Ascii("taying"),
        dictgen::InsensitiveStr::Ascii("tays"),
        dictgen::InsensitiveStr::Ascii("te"),
        dictgen::InsensitiveStr::Ascii("teed"),
        dictgen::InsensitiveStr::Ascii("tees"),
        dictgen::InsensitiveStr::Ascii("teing"),
        dictgen::InsensitiveStr::Ascii("tes"),
    ],
    values: &[
        &["swansea"],
        &["swanson"],
        &["swastika"],
        &["sauté"],
        &["sautéd"],
        &["sautés"],
        &["sautéing"],
        &["sautés"],
        &["sauté"],
        &["sautéd"],
        &["sautés"],
        &["sautéing"],
        &["sautés"],
    ],
    range: 2..=6,
};

static WORD_SAV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SAV_CHILDREN),
    value: Some(&["save"]),
};

pub static WORD_SAV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("anha"),
        dictgen::InsensitiveStr::Ascii("annh"),
        dictgen::InsensitiveStr::Ascii("ees"),
        dictgen::InsensitiveStr::Ascii("eing"),
        dictgen::InsensitiveStr::Ascii("elt"),
        dictgen::InsensitiveStr::Ascii("ely"),
        dictgen::InsensitiveStr::Ascii("en"),
        dictgen::InsensitiveStr::Ascii("ere"),
        dictgen::InsensitiveStr::Ascii("ety"),
        dictgen::InsensitiveStr::Ascii("group"),
        dictgen::InsensitiveStr::Ascii("ve"),
        dictgen::InsensitiveStr::Ascii("ves"),
        dictgen::InsensitiveStr::Ascii("y"),
    ],
    values: &[
        &["savanna"],
        &["savannah"],
        &["saves"],
        &["saving"],
        &["svelte"],
        &["safely"],
        &["save"],
        &["severe"],
        &["safety"],
        &["savegroup"],
        &["save", "savvy", "salve"],
        &["salves", "saves"],
        &["savvy"],
    ],
    range: 1..=5,
};

static WORD_SAU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SAU_CHILDREN),
    value: None,
};

pub static WORD_SAU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ght"),
        dictgen::InsensitiveStr::Ascii("tay"),
        dictgen::InsensitiveStr::Ascii("tayed"),
        dictgen::InsensitiveStr::Ascii("tayes"),
        dictgen::InsensitiveStr::Ascii("taying"),
        dictgen::InsensitiveStr::Ascii("tays"),
    ],
    values: &[
        &["sought"],
        &["sauté"],
        &["sautéd"],
        &["sautés"],
        &["sautéing"],
        &["sautés"],
    ],
    range: 3..=6,
};

static WORD_SAT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_SAT_CHILDREN),
    value: None,
};

static WORD_SAT_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_SATA_NODE),
    None,
    None,
    None,
    Some(&WORD_SATE_NODE),
    None,
    None,
    None,
    Some(&WORD_SATI_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_SATR_NODE),
    Some(&WORD_SATS_NODE),
    Some(&WORD_SATT_NODE),
    Some(&WORD_SATU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_SATU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SATU_CHILDREN),
    value: None,
};

pub static WORD_SATU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aday"),
        dictgen::InsensitiveStr::Ascii("adays"),
        dictgen::InsensitiveStr::Ascii("racion"),
        dictgen::InsensitiveStr::Ascii("rdey"),
        dictgen::InsensitiveStr::Ascii("rdsy"),
        dictgen::InsensitiveStr::Ascii("rsday"),
        dictgen::InsensitiveStr::Ascii("s"),
    ],
    values: &[
        &["saturday"],
        &["saturdays"],
        &["saturation"],
        &["saturday"],
        &["saturdays"],
        &["saturday"],
        &["status"],
    ],
    range: 1..=6,
};

static WORD_SATT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SATT_CHILDREN),
    value: None,
};

pub static WORD_SATT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("elit"),
        dictgen::InsensitiveStr::Ascii("elite"),
        dictgen::InsensitiveStr::Ascii("elites"),
        dictgen::InsensitiveStr::Ascii("elits"),
        dictgen::InsensitiveStr::Ascii("ellite"),
        dictgen::InsensitiveStr::Ascii("ellites"),
    ],
    values: &[
        &["satellite"],
        &["satellite"],
        &["satellites"],
        &["satellites"],
        &["satellite"],
        &["satellites"],
    ],
    range: 4..=7,
};

static WORD_SATS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SATS_CHILDREN),
    value: None,
};

pub static WORD_SATS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ifaction"),
        dictgen::InsensitiveStr::Ascii("ifactory"),
        dictgen::InsensitiveStr::Ascii("ified"),
        dictgen::InsensitiveStr::Ascii("ifies"),
        dictgen::InsensitiveStr::Ascii("ify"),
        dictgen::InsensitiveStr::Ascii("ifying"),
        dictgen::InsensitiveStr::Ascii("ohi"),
    ],
    values: &[
        &["satisfaction"],
        &["satisfactory"],
        &["satisfied"],
        &["satisfies"],
        &["satisfy"],
        &["satisfying"],
        &["satoshi"],
    ],
    range: 3..=8,
};

static WORD_SATR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SATR_CHILDREN),
    value: None,
};

pub static WORD_SATR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ic"),
        dictgen::InsensitiveStr::Ascii("ical"),
        dictgen::InsensitiveStr::Ascii("ically"),
        dictgen::InsensitiveStr::Ascii("uation"),
        dictgen::InsensitiveStr::Ascii("uday"),
        dictgen::InsensitiveStr::Ascii("udays"),
    ],
    values: &[
        &["satiric"],
        &["satirical"],
        &["satirically"],
        &["saturation"],
        &["saturday"],
        &["saturdays"],
    ],
    range: 2..=6,
};

static WORD_SATI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SATI_CHILDREN),
    value: None,
};

pub static WORD_SATI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("fied"),
        dictgen::InsensitiveStr::Ascii("fies"),
        dictgen::InsensitiveStr::Ascii("fsy"),
        dictgen::InsensitiveStr::Ascii("fsying"),
        dictgen::InsensitiveStr::Ascii("fy"),
        dictgen::InsensitiveStr::Ascii("fying"),
        dictgen::InsensitiveStr::Ascii("sfaccion"),
        dictgen::InsensitiveStr::Ascii("sfacion"),
        dictgen::InsensitiveStr::Ascii("sfacory"),
        dictgen::InsensitiveStr::Ascii("sfacting"),
        dictgen::InsensitiveStr::Ascii("sfactorally"),
        dictgen::InsensitiveStr::Ascii("sfactoraly"),
        dictgen::InsensitiveStr::Ascii("sfactorilly"),
        dictgen::InsensitiveStr::Ascii("sfactority"),
        dictgen::InsensitiveStr::Ascii("sfactorly"),
        dictgen::InsensitiveStr::Ascii("sfcation"),
        dictgen::InsensitiveStr::Ascii("sfiabilty"),
        dictgen::InsensitiveStr::Ascii("sfiction"),
        dictgen::InsensitiveStr::Ascii("sfing"),
        dictgen::InsensitiveStr::Ascii("sfiy"),
        dictgen::InsensitiveStr::Ascii("sfyied"),
        dictgen::InsensitiveStr::Ascii("sifed"),
        dictgen::InsensitiveStr::Ascii("sifes"),
        dictgen::InsensitiveStr::Ascii("sified"),
        dictgen::InsensitiveStr::Ascii("sifies"),
        dictgen::InsensitiveStr::Ascii("sify"),
        dictgen::InsensitiveStr::Ascii("sifying"),
        dictgen::InsensitiveStr::Ascii("stactory"),
        dictgen::InsensitiveStr::Ascii("stying"),
        dictgen::InsensitiveStr::Ascii("sy"),
    ],
    values: &[
        &["satisfied"],
        &["satisfies"],
        &["satisfy"],
        &["satisfying"],
        &["satisfy"],
        &["satisfying"],
        &["satisfaction"],
        &["satisfaction"],
        &["satisfactory"],
        &["satisfaction"],
        &["satisfactory", "satisfactorily"],
        &["satisfactory"],
        &["satisfactory"],
        &["satisfactorily"],
        &["satisfactory"],
        &["satisfaction"],
        &["satisfiability"],
        &["satisfaction"],
        &["satisfying"],
        &["satisfy"],
        &["satisfied"],
        &["satisfied"],
        &["satisfies"],
        &["satisfied"],
        &["satisfies"],
        &["satisfy"],
        &["satisfying"],
        &["satisfactory"],
        &["satisfying"],
        &["satisfy"],
    ],
    range: 2..=11,
};

static WORD_SATE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SATE_CHILDREN),
    value: None,
};

pub static WORD_SATE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("lite"),
        dictgen::InsensitiveStr::Ascii("lites"),
        dictgen::InsensitiveStr::Ascii("litte"),
        dictgen::InsensitiveStr::Ascii("llie"),
        dictgen::InsensitiveStr::Ascii("llitte"),
        dictgen::InsensitiveStr::Ascii("llittes"),
        dictgen::InsensitiveStr::Ascii("ment"),
        dictgen::InsensitiveStr::Ascii("ments"),
        dictgen::InsensitiveStr::Ascii("rday"),
        dictgen::InsensitiveStr::Ascii("rdays"),
    ],
    values: &[
        &["satellite"],
        &["satellites"],
        &["satellite"],
        &["satellites"],
        &["satellites"],
        &["satellites"],
        &["statement"],
        &["statements"],
        &["saturday"],
        &["saturdays"],
    ],
    range: 4..=7,
};

static WORD_SATA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SATA_CHILDREN),
    value: None,
};

pub static WORD_SATA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ndard"),
        dictgen::InsensitiveStr::Ascii("ndards"),
        dictgen::InsensitiveStr::Ascii("sfaction"),
        dictgen::InsensitiveStr::Ascii("sfactory"),
    ],
    values: &[
        &["standard"],
        &["standards"],
        &["satisfaction"],
        &["satisfactory"],
    ],
    range: 5..=8,
};

static WORD_SAS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SAS_CHILDREN),
    value: None,
};

pub static WORD_SAS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("auges"),
        dictgen::InsensitiveStr::Ascii("catchewan"),
        dictgen::InsensitiveStr::Ascii("katcehwan"),
        dictgen::InsensitiveStr::Ascii("katchawan"),
        dictgen::InsensitiveStr::Ascii("katchewinian"),
        dictgen::InsensitiveStr::Ascii("katchewn"),
        dictgen::InsensitiveStr::Ascii("katchwan"),
        dictgen::InsensitiveStr::Ascii("katechwan"),
        dictgen::InsensitiveStr::Ascii("ketchawan"),
        dictgen::InsensitiveStr::Ascii("ketchewan"),
        dictgen::InsensitiveStr::Ascii("ktachewan"),
        dictgen::InsensitiveStr::Ascii("tified"),
        dictgen::InsensitiveStr::Ascii("tifies"),
        dictgen::InsensitiveStr::Ascii("tifying"),
        dictgen::InsensitiveStr::Ascii("tisfies"),
        dictgen::InsensitiveStr::Ascii("uage"),
        dictgen::InsensitiveStr::Ascii("uages"),
        dictgen::InsensitiveStr::Ascii("y"),
    ],
    values: &[
        &["sausages"],
        &["saskatchewan"],
        &["saskatchewan"],
        &["saskatchewan"],
        &["saskatchewan"],
        &["saskatchewan"],
        &["saskatchewan"],
        &["saskatchewan"],
        &["saskatchewan"],
        &["saskatchewan"],
        &["saskatchewan"],
        &["satisfied"],
        &["satisfies"],
        &["satisfying"],
        &["satisfies"],
        &["sausage"],
        &["sausages"],
        &["says", "sassy"],
    ],
    range: 1..=12,
};

static WORD_SAR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SAR_CHILDREN),
    value: None,
};

pub static WORD_SAR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cams"),
        dictgen::InsensitiveStr::Ascii("casam"),
        dictgen::InsensitiveStr::Ascii("casim"),
        dictgen::InsensitiveStr::Ascii("casitcally"),
        dictgen::InsensitiveStr::Ascii("castc"),
        dictgen::InsensitiveStr::Ascii("casticaly"),
        dictgen::InsensitiveStr::Ascii("casticlly"),
        dictgen::InsensitiveStr::Ascii("castisch"),
        dictgen::InsensitiveStr::Ascii("gant"),
        dictgen::InsensitiveStr::Ascii("geant"),
        dictgen::InsensitiveStr::Ascii("imonial"),
        dictgen::InsensitiveStr::Ascii("imonies"),
        dictgen::InsensitiveStr::Ascii("imony"),
        dictgen::InsensitiveStr::Ascii("imonys"),
        dictgen::InsensitiveStr::Ascii("inomial"),
        dictgen::InsensitiveStr::Ascii("inomies"),
        dictgen::InsensitiveStr::Ascii("inomy"),
        dictgen::InsensitiveStr::Ascii("inomys"),
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("ted"),
        dictgen::InsensitiveStr::Ascii("ter"),
        dictgen::InsensitiveStr::Ascii("ters"),
        dictgen::InsensitiveStr::Ascii("ting"),
        dictgen::InsensitiveStr::Ascii("ts"),
    ],
    values: &[
        &["sarcasm"],
        &["sarcasm"],
        &["sarcasm"],
        &["sarcastically"],
        &["sarcastic"],
        &["sarcastically"],
        &["sarcastically"],
        &["sarcastic"],
        &["sergeant"],
        &["sergeant"],
        &["ceremonial"],
        &["ceremonies"],
        &["ceremony"],
        &["ceremonies"],
        &["ceremonial"],
        &["ceremonies"],
        &["ceremony"],
        &["ceremonies"],
        &["star", "start"],
        &["started"],
        &["starter"],
        &["starters"],
        &["starting", "sorting"],
        &["stars", "starts"],
    ],
    range: 1..=10,
};

static WORD_SAP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SAP_CHILDREN),
    value: None,
};

pub static WORD_SAP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cebar"),
        dictgen::InsensitiveStr::Ascii("eena"),
        dictgen::InsensitiveStr::Ascii("eenad"),
        dictgen::InsensitiveStr::Ascii("eenaing"),
        dictgen::InsensitiveStr::Ascii("eenas"),
        dictgen::InsensitiveStr::Ascii("hire"),
        dictgen::InsensitiveStr::Ascii("hires"),
        dictgen::InsensitiveStr::Ascii("phie"),
        dictgen::InsensitiveStr::Ascii("phirre"),
        dictgen::InsensitiveStr::Ascii("phrie"),
    ],
    values: &[
        &["spacebar"],
        &["subpoena"],
        &["subpoenaed"],
        &["subpoenaing"],
        &["subpoenas"],
        &["sapphire"],
        &["sapphires"],
        &["sapphire"],
        &["sapphire"],
        &["sapphire"],
    ],
    range: 4..=7,
};

static WORD_SAN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SAN_CHILDREN),
    value: None,
};

pub static WORD_SAN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aty"),
        dictgen::InsensitiveStr::Ascii("box"),
        dictgen::InsensitiveStr::Ascii("ctiond"),
        dictgen::InsensitiveStr::Ascii("ctionne"),
        dictgen::InsensitiveStr::Ascii("ctionned"),
        dictgen::InsensitiveStr::Ascii("ctionning"),
        dictgen::InsensitiveStr::Ascii("cturay"),
        dictgen::InsensitiveStr::Ascii("cutary"),
        dictgen::InsensitiveStr::Ascii("dales"),
        dictgen::InsensitiveStr::Ascii("dalls"),
        dictgen::InsensitiveStr::Ascii("dard"),
        dictgen::InsensitiveStr::Ascii("dity"),
        dictgen::InsensitiveStr::Ascii("diwches"),
        dictgen::InsensitiveStr::Ascii("dlas"),
        dictgen::InsensitiveStr::Ascii("dnig"),
        dictgen::InsensitiveStr::Ascii("dobx"),
        dictgen::InsensitiveStr::Ascii("dstom"),
        dictgen::InsensitiveStr::Ascii("dstrom"),
        dictgen::InsensitiveStr::Ascii("dviches"),
        dictgen::InsensitiveStr::Ascii("dwhich"),
        dictgen::InsensitiveStr::Ascii("dwishes"),
        dictgen::InsensitiveStr::Ascii("hedrim"),
        dictgen::InsensitiveStr::Ascii("itazion"),
        dictgen::InsensitiveStr::Ascii("itizisation"),
        dictgen::InsensitiveStr::Ascii("izer"),
        dictgen::InsensitiveStr::Ascii("lder"),
        dictgen::InsensitiveStr::Ascii("otrum"),
        dictgen::InsensitiveStr::Ascii("pshot"),
        dictgen::InsensitiveStr::Ascii("psnots"),
        dictgen::InsensitiveStr::Ascii("sitizer"),
        dictgen::InsensitiveStr::Ascii("sitizers"),
        dictgen::InsensitiveStr::Ascii("tcuary"),
        dictgen::InsensitiveStr::Ascii("tiation"),
        dictgen::InsensitiveStr::Ascii("tioned"),
        dictgen::InsensitiveStr::Ascii("tity"),
        dictgen::InsensitiveStr::Ascii("tize"),
        dictgen::InsensitiveStr::Ascii("tized"),
        dictgen::InsensitiveStr::Ascii("tizes"),
        dictgen::InsensitiveStr::Ascii("tizing"),
        dictgen::InsensitiveStr::Ascii("torm"),
        dictgen::InsensitiveStr::Ascii("tourm"),
        dictgen::InsensitiveStr::Ascii("troum"),
        dictgen::InsensitiveStr::Ascii("turom"),
        dictgen::InsensitiveStr::Ascii("wich"),
        dictgen::InsensitiveStr::Ascii("wiches"),
        dictgen::InsensitiveStr::Ascii("ytise"),
        dictgen::InsensitiveStr::Ascii("ytize"),
    ],
    values: &[
        &["sanity"],
        &["sandbox"],
        &["sanctioned"],
        &["sanctioned"],
        &["sanctioned"],
        &["sanctioning"],
        &["sanctuary"],
        &["sanctuary"],
        &["sandals"],
        &["sandals"],
        &["standard"],
        &["sanity"],
        &["sandwiches"],
        &["sandals"],
        &["sanding"],
        &["sandbox"],
        &["sandstorm"],
        &["sandstorm"],
        &["sandwiches"],
        &["sandwich"],
        &["sandwiches"],
        &["sanhedrin"],
        &["sanitation"],
        &["sanitization"],
        &["sanitizer"],
        &["sandler"],
        &["santorum"],
        &["snapshot"],
        &["snapshots"],
        &["sanitizer"],
        &["sanitizers"],
        &["sanctuary"],
        &["sanitation"],
        &["sanctioned"],
        &["sanctity", "sanity"],
        &["sanitize"],
        &["sanitized"],
        &["sanitizes"],
        &["sanitizing"],
        &["santorum"],
        &["santorum"],
        &["santorum"],
        &["santorum"],
        &["sandwich"],
        &["sandwiches"],
        &["sanitise"],
        &["sanitize"],
    ],
    range: 3..=11,
};

static WORD_SAM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SAM_CHILDREN),
    value: None,
};

pub static WORD_SAM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ckdown"),
        dictgen::InsensitiveStr::Ascii("le"),
        dictgen::InsensitiveStr::Ascii("led"),
        dictgen::InsensitiveStr::Ascii("les"),
        dictgen::InsensitiveStr::Ascii("ll"),
        dictgen::InsensitiveStr::Ascii("ller"),
        dictgen::InsensitiveStr::Ascii("mon"),
        dictgen::InsensitiveStr::Ascii("ori"),
        dictgen::InsensitiveStr::Ascii("pel"),
        dictgen::InsensitiveStr::Ascii("peld"),
        dictgen::InsensitiveStr::Ascii("pels"),
        dictgen::InsensitiveStr::Ascii("ruai"),
        dictgen::InsensitiveStr::Ascii("uari"),
        dictgen::InsensitiveStr::Ascii("ue"),
        dictgen::InsensitiveStr::Ascii("uria"),
        dictgen::InsensitiveStr::Ascii("wich"),
        dictgen::InsensitiveStr::Ascii("wiches"),
    ],
    values: &[
        &["smackdown"],
        &["sample"],
        &["sampled"],
        &["samples", "seamless"],
        &["small"],
        &["smaller"],
        &["salmon"],
        &["samurai"],
        &["sample"],
        &["sampled"],
        &["samples"],
        &["samurai"],
        &["samurai"],
        &["same", "samuel"],
        &["samurai"],
        &["sandwich"],
        &["sandwiches"],
    ],
    range: 2..=6,
};

static WORD_SAL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SAL_CHILDREN),
    value: None,
};

pub static WORD_SAL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aires"),
        dictgen::InsensitiveStr::Ascii("aris"),
        dictgen::InsensitiveStr::Ascii("avge"),
        dictgen::InsensitiveStr::Ascii("eries"),
        dictgen::InsensitiveStr::Ascii("ery"),
        dictgen::InsensitiveStr::Ascii("ughter"),
        dictgen::InsensitiveStr::Ascii("ughtered"),
        dictgen::InsensitiveStr::Ascii("ughtering"),
        dictgen::InsensitiveStr::Ascii("veof"),
        dictgen::InsensitiveStr::Ascii("very"),
        dictgen::InsensitiveStr::Ascii("ying"),
    ],
    values: &[
        &["salaries"],
        &["salaries"],
        &["salvage"],
        &["salaries"],
        &["salary"],
        &["slaughter"],
        &["slaughtered"],
        &["slaughtering"],
        &["slaveof"],
        &["slavery"],
        &["slaying"],
    ],
    range: 3..=9,
};

static WORD_SAK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SAK_CHILDREN),
    value: None,
};

pub static WORD_SAK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("satchewan")],
    values: &[&["saskatchewan"]],
    range: 9..=9,
};

static WORD_SAI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SAI_CHILDREN),
    value: None,
};

pub static WORD_SAI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("s")],
    values: &[&["says"]],
    range: 1..=1,
};

static WORD_SAG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SAG_CHILDREN),
    value: None,
};

pub static WORD_SAG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("gital"),
        dictgen::InsensitiveStr::Ascii("ital"),
        dictgen::InsensitiveStr::Ascii("itarius"),
    ],
    values: &[&["sagittal"], &["sagittal"], &["sagittarius"]],
    range: 4..=7,
};

static WORD_SAF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SAF_CHILDREN),
    value: None,
};

pub static WORD_SAF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eguared"),
        dictgen::InsensitiveStr::Ascii("eing"),
        dictgen::InsensitiveStr::Ascii("epooint"),
        dictgen::InsensitiveStr::Ascii("epooints"),
        dictgen::InsensitiveStr::Ascii("equard"),
        dictgen::InsensitiveStr::Ascii("eri"),
        dictgen::InsensitiveStr::Ascii("etly"),
        dictgen::InsensitiveStr::Ascii("ly"),
        dictgen::InsensitiveStr::Ascii("tey"),
        dictgen::InsensitiveStr::Ascii("ty"),
    ],
    values: &[
        &["safeguard", "safeguarded"],
        &["saving"],
        &["safepoint"],
        &["safepoints"],
        &["safeguard"],
        &["safari"],
        &["safely"],
        &["safely"],
        &["safety"],
        &["safety"],
    ],
    range: 2..=8,
};

static WORD_SAE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SAE_CHILDREN),
    value: None,
};

pub static WORD_SAE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("m")],
    values: &[&["same"]],
    range: 1..=1,
};

static WORD_SAD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SAD_CHILDREN),
    value: None,
};

pub static WORD_SAD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("dends"),
        dictgen::InsensitiveStr::Ascii("denes"),
        dictgen::InsensitiveStr::Ascii("dly"),
        dictgen::InsensitiveStr::Ascii("dnes"),
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("isitc"),
        dictgen::InsensitiveStr::Ascii("istc"),
        dictgen::InsensitiveStr::Ascii("istisch"),
        dictgen::InsensitiveStr::Ascii("ning"),
    ],
    values: &[
        &["saddens"],
        &["saddens"],
        &["saddle", "sadly"],
        &["saddens"],
        &["sad"],
        &["sadistic"],
        &["sadistic"],
        &["sadistic"],
        &["sanding"],
    ],
    range: 1..=7,
};

static WORD_SAC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SAC_CHILDREN),
    value: None,
};

pub static WORD_SAC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("alar"),
        dictgen::InsensitiveStr::Ascii("alars"),
        dictgen::InsensitiveStr::Ascii("arin"),
        dictgen::InsensitiveStr::Ascii("armento"),
        dictgen::InsensitiveStr::Ascii("arstic"),
        dictgen::InsensitiveStr::Ascii("ksonville"),
        dictgen::InsensitiveStr::Ascii("le"),
        dictgen::InsensitiveStr::Ascii("ntioned"),
        dictgen::InsensitiveStr::Ascii("ntuary"),
        dictgen::InsensitiveStr::Ascii("rafice"),
        dictgen::InsensitiveStr::Ascii("raficed"),
        dictgen::InsensitiveStr::Ascii("rafices"),
        dictgen::InsensitiveStr::Ascii("ramenno"),
        dictgen::InsensitiveStr::Ascii("rasm"),
        dictgen::InsensitiveStr::Ascii("rastic"),
        dictgen::InsensitiveStr::Ascii("rastically"),
        dictgen::InsensitiveStr::Ascii("reficed"),
        dictgen::InsensitiveStr::Ascii("refices"),
        dictgen::InsensitiveStr::Ascii("religious"),
        dictgen::InsensitiveStr::Ascii("remento"),
        dictgen::InsensitiveStr::Ascii("rifaced"),
        dictgen::InsensitiveStr::Ascii("rifaces"),
        dictgen::InsensitiveStr::Ascii("rifacing"),
        dictgen::InsensitiveStr::Ascii("rifical"),
        dictgen::InsensitiveStr::Ascii("rificare"),
        dictgen::InsensitiveStr::Ascii("rificas"),
        dictgen::InsensitiveStr::Ascii("rificeing"),
        dictgen::InsensitiveStr::Ascii("rificie"),
        dictgen::InsensitiveStr::Ascii("rificied"),
        dictgen::InsensitiveStr::Ascii("rificies"),
        dictgen::InsensitiveStr::Ascii("rificng"),
        dictgen::InsensitiveStr::Ascii("rifie"),
        dictgen::InsensitiveStr::Ascii("rifieced"),
        dictgen::InsensitiveStr::Ascii("rifise"),
        dictgen::InsensitiveStr::Ascii("rifises"),
        dictgen::InsensitiveStr::Ascii("rifising"),
        dictgen::InsensitiveStr::Ascii("rifized"),
        dictgen::InsensitiveStr::Ascii("rifizes"),
        dictgen::InsensitiveStr::Ascii("rifizing"),
        dictgen::InsensitiveStr::Ascii("rifying"),
        dictgen::InsensitiveStr::Ascii("rilegeous"),
        dictgen::InsensitiveStr::Ascii("rin"),
        dictgen::InsensitiveStr::Ascii("romento"),
    ],
    values: &[
        &["scalar"],
        &["scalars"],
        &["saccharin"],
        &["sacramento"],
        &["sarcastic"],
        &["jacksonville"],
        &["scale"],
        &["sanctioned"],
        &["sanctuary"],
        &["sacrifice"],
        &["sacrificed"],
        &["sacrifices"],
        &["sacramento"],
        &["sarcasm"],
        &["sarcastic"],
        &["sarcastically"],
        &["sacrificed"],
        &["sacrifices"],
        &["sacrilegious"],
        &["sacramento"],
        &["sacrificed"],
        &["sacrifices"],
        &["sacrificing"],
        &["sacrificial"],
        &["sacrifice"],
        &["sacrifices"],
        &["sacrificing"],
        &["sacrificed"],
        &["sacrifice"],
        &["sacrifice"],
        &["sacrificing"],
        &["sacrifice"],
        &["sacrificed"],
        &["sacrifices"],
        &["sacrifices"],
        &["sacrificing"],
        &["sacrificed"],
        &["sacrifices"],
        &["sacrificing"],
        &["sacrificing"],
        &["sacrilegious"],
        &["saccharin"],
        &["sacramento"],
    ],
    range: 2..=10,
};

static WORD_SAB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SAB_CHILDREN),
    value: None,
};

pub static WORD_SAB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("atage"),
        dictgen::InsensitiveStr::Ascii("atosh"),
        dictgen::InsensitiveStr::Ascii("atoshed"),
        dictgen::InsensitiveStr::Ascii("atoshes"),
        dictgen::InsensitiveStr::Ascii("atoshing"),
        dictgen::InsensitiveStr::Ascii("atour"),
        dictgen::InsensitiveStr::Ascii("ility"),
    ],
    values: &[
        &["sabotage"],
        &["sabotage"],
        &["sabotaged"],
        &["sabotages"],
        &["sabotaging"],
        &["saboteur"],
        &["stability"],
    ],
    range: 5..=8,
};

static WORD_SAA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_SAA_CHILDREN),
    value: None,
};

pub static WORD_SAA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("me")],
    values: &[&["same"]],
    range: 2..=2,
};

static WORD_R_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_R_CHILDREN),
    value: None,
};

static WORD_R_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_RA_NODE),
    None,
    Some(&WORD_RC_NODE),
    Some(&WORD_RD_NODE),
    Some(&WORD_RE_NODE),
    Some(&WORD_RF_NODE),
    Some(&WORD_RG_NODE),
    Some(&WORD_RH_NODE),
    Some(&WORD_RI_NODE),
    None,
    None,
    Some(&WORD_RL_NODE),
    Some(&WORD_RM_NODE),
    Some(&WORD_RN_NODE),
    Some(&WORD_RO_NODE),
    Some(&WORD_RP_NODE),
    Some(&WORD_RQ_NODE),
    Some(&WORD_RR_NODE),
    Some(&WORD_RS_NODE),
    Some(&WORD_RT_NODE),
    Some(&WORD_RU_NODE),
    None,
    Some(&WORD_RW_NODE),
    None,
    Some(&WORD_RY_NODE),
    None,
];

static WORD_RY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RY_CHILDREN),
    value: None,
};

pub static WORD_RY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("enolds"),
        dictgen::InsensitiveStr::Ascii("snc"),
        dictgen::InsensitiveStr::Ascii("surrection"),
        dictgen::InsensitiveStr::Ascii("them"),
        dictgen::InsensitiveStr::Ascii("thim"),
        dictgen::InsensitiveStr::Ascii("thm"),
        dictgen::InsensitiveStr::Ascii("thmic"),
        dictgen::InsensitiveStr::Ascii("thyms"),
    ],
    values: &[
        &["reynolds"],
        &["rsync"],
        &["resurrection"],
        &["rhythm"],
        &["rhythm"],
        &["rhythm"],
        &["rhythmic"],
        &["rhythms"],
    ],
    range: 3..=10,
};

static WORD_RW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RW_CHILDREN),
    value: None,
};

pub static WORD_RW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ite")],
    values: &[&["write"]],
    range: 3..=3,
};

static WORD_RU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RU_CHILDREN),
    value: None,
};

pub static WORD_RU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("barb"),
        dictgen::InsensitiveStr::Ascii("cuperate"),
        dictgen::InsensitiveStr::Ascii("dimentally"),
        dictgen::InsensitiveStr::Ascii("dimentatry"),
        dictgen::InsensitiveStr::Ascii("dimentery"),
        dictgen::InsensitiveStr::Ascii("dimentory"),
        dictgen::InsensitiveStr::Ascii("dimentry"),
        dictgen::InsensitiveStr::Ascii("gters"),
        dictgen::InsensitiveStr::Ascii("idmentary"),
        dictgen::InsensitiveStr::Ascii("lebok"),
        dictgen::InsensitiveStr::Ascii("leboook"),
        dictgen::InsensitiveStr::Ascii("lle"),
        dictgen::InsensitiveStr::Ascii("matic"),
        dictgen::InsensitiveStr::Ascii("morus"),
        dictgen::InsensitiveStr::Ascii("mtime"),
        dictgen::InsensitiveStr::Ascii("muors"),
        dictgen::InsensitiveStr::Ascii("ning"),
        dictgen::InsensitiveStr::Ascii("nn"),
        dictgen::InsensitiveStr::Ascii("nned"),
        dictgen::InsensitiveStr::Ascii("nnging"),
        dictgen::InsensitiveStr::Ascii("nnig"),
        dictgen::InsensitiveStr::Ascii("nnign"),
        dictgen::InsensitiveStr::Ascii("nnigng"),
        dictgen::InsensitiveStr::Ascii("nnin"),
        dictgen::InsensitiveStr::Ascii("nnint"),
        dictgen::InsensitiveStr::Ascii("nnners"),
        dictgen::InsensitiveStr::Ascii("nnnig"),
        dictgen::InsensitiveStr::Ascii("nnning"),
        dictgen::InsensitiveStr::Ascii("nns"),
        dictgen::InsensitiveStr::Ascii("nnung"),
        dictgen::InsensitiveStr::Ascii("ntimr"),
        dictgen::InsensitiveStr::Ascii("ntine"),
        dictgen::InsensitiveStr::Ascii("nting"),
        dictgen::InsensitiveStr::Ascii("rrent"),
        dictgen::InsensitiveStr::Ascii("slted"),
        dictgen::InsensitiveStr::Ascii("ssina"),
        dictgen::InsensitiveStr::Ascii("ssion"),
        dictgen::InsensitiveStr::Ascii("steld"),
        dictgen::InsensitiveStr::Ascii("te"),
        dictgen::InsensitiveStr::Ascii("tes"),
        dictgen::InsensitiveStr::Ascii("tgerus"),
    ],
    values: &[
        &["rhubarb"],
        &["recuperate"],
        &["rudimentary"],
        &["rudimentary"],
        &["rudimentary"],
        &["rudimentary"],
        &["rudimentary"],
        &["rutgers"],
        &["rudimentary"],
        &["rulebook"],
        &["rulebook"],
        &["rule"],
        &["rheumatic"],
        &["rumors"],
        &["runtime"],
        &["rumors"],
        &["running", "ruining"],
        &["run"],
        &["ran", "run", "ruined"],
        &["running", "rummaging"],
        &["running"],
        &["running"],
        &["running"],
        &["running"],
        &["running"],
        &["runners"],
        &["running"],
        &["running"],
        &["runs"],
        &["running"],
        &["runtime"],
        &["runtime", "routine"],
        &["runtime"],
        &["current"],
        &["rustled"],
        &["russian"],
        &["russian"],
        &["rustled"],
        &["brute", "route", "rule"],
        &["brutes", "routes", "rules"],
        &["rutgers"],
    ],
    range: 2..=10,
};

static WORD_RT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RT_CHILDREN),
    value: None,
};

pub static WORD_RT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("urn"),
        dictgen::InsensitiveStr::Ascii("urned"),
        dictgen::InsensitiveStr::Ascii("urning"),
        dictgen::InsensitiveStr::Ascii("urns"),
    ],
    values: &[
        &["return"],
        &["returned"],
        &["returning"],
        &["returns", "turns"],
    ],
    range: 3..=6,
};

static WORD_RS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RS_CHILDREN),
    value: None,
};

pub static WORD_RS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("icv"),
        dictgen::InsensitiveStr::Ascii("izing"),
        dictgen::InsensitiveStr::Ascii("ource"),
        dictgen::InsensitiveStr::Ascii("ourced"),
        dictgen::InsensitiveStr::Ascii("ources"),
        dictgen::InsensitiveStr::Ascii("ourcing"),
    ],
    values: &[
        &["riscv"],
        &["resizing", "sizing"],
        &["resource", "source"],
        &["resourced", "sourced"],
        &["resources", "sources"],
        &["resourcing", "sourcing"],
    ],
    range: 3..=7,
};

static WORD_RR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RR_CHILDREN),
    value: None,
};

pub static WORD_RR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("anslation"),
        dictgen::InsensitiveStr::Ascii("anslations"),
        dictgen::InsensitiveStr::Ascii("ase"),
        dictgen::InsensitiveStr::Ascii("ror"),
        dictgen::InsensitiveStr::Ascii("rored"),
        dictgen::InsensitiveStr::Ascii("roring"),
        dictgen::InsensitiveStr::Ascii("rors"),
    ],
    values: &[
        &["translation"],
        &["translations"],
        &["erase"],
        &["error"],
        &["errored"],
        &["erroring"],
        &["errors"],
    ],
    range: 3..=10,
};

static WORD_RQ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RQ_CHILDREN),
    value: None,
};

pub static WORD_RQ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("euest"),
        dictgen::InsensitiveStr::Ascii("euested"),
        dictgen::InsensitiveStr::Ascii("euesting"),
        dictgen::InsensitiveStr::Ascii("euests"),
        dictgen::InsensitiveStr::Ascii("uest"),
        dictgen::InsensitiveStr::Ascii("uested"),
        dictgen::InsensitiveStr::Ascii("uesting"),
        dictgen::InsensitiveStr::Ascii("uests"),
        dictgen::InsensitiveStr::Ascii("uire"),
        dictgen::InsensitiveStr::Ascii("uired"),
        dictgen::InsensitiveStr::Ascii("uirement"),
        dictgen::InsensitiveStr::Ascii("uires"),
        dictgen::InsensitiveStr::Ascii("uiring"),
    ],
    values: &[
        &["request", "quest"],
        &["requested"],
        &["requesting"],
        &["requests", "quests"],
        &["request", "quest"],
        &["requested"],
        &["requesting"],
        &["requests", "quests"],
        &["require"],
        &["required"],
        &["requirement"],
        &["requires"],
        &["requiring"],
    ],
    range: 4..=8,
};

static WORD_RP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RP_CHILDREN),
    value: None,
};

pub static WORD_RP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("lace")],
    values: &[&["replace"]],
    range: 4..=4,
};

static WORD_RO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_RO_CHILDREN),
    value: None,
};

static WORD_RO_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_ROA_NODE),
    Some(&WORD_ROB_NODE),
    Some(&WORD_ROC_NODE),
    Some(&WORD_ROD_NODE),
    Some(&WORD_ROE_NODE),
    None,
    Some(&WORD_ROG_NODE),
    None,
    Some(&WORD_ROI_NODE),
    None,
    None,
    Some(&WORD_ROL_NODE),
    Some(&WORD_ROM_NODE),
    Some(&WORD_RON_NODE),
    Some(&WORD_ROO_NODE),
    Some(&WORD_ROP_NODE),
    None,
    Some(&WORD_ROR_NODE),
    Some(&WORD_ROS_NODE),
    Some(&WORD_ROT_NODE),
    Some(&WORD_ROU_NODE),
    Some(&WORD_ROV_NODE),
    None,
    None,
    Some(&WORD_ROY_NODE),
    None,
];

static WORD_ROY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ROY_CHILDREN),
    value: None,
};

pub static WORD_ROY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("alites"),
        dictgen::InsensitiveStr::Ascii("laties"),
    ],
    values: &[&["royalties"], &["royalties"]],
    range: 6..=6,
};

static WORD_ROV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ROV_CHILDREN),
    value: None,
};

pub static WORD_ROV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ide"),
        dictgen::InsensitiveStr::Ascii("ided"),
        dictgen::InsensitiveStr::Ascii("ider"),
        dictgen::InsensitiveStr::Ascii("ides"),
        dictgen::InsensitiveStr::Ascii("iding"),
    ],
    values: &[
        &["provide"],
        &["provided"],
        &["provider"],
        &["provides"],
        &["providing"],
    ],
    range: 3..=5,
};

static WORD_ROU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ROU_CHILDREN),
    value: None,
};

pub static WORD_ROU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ding"),
        dictgen::InsensitiveStr::Ascii("ghtly"),
        dictgen::InsensitiveStr::Ascii("gly"),
        dictgen::InsensitiveStr::Ascii("ine"),
        dictgen::InsensitiveStr::Ascii("ines"),
        dictgen::InsensitiveStr::Ascii("ndabaout"),
        dictgen::InsensitiveStr::Ascii("ndaboot"),
        dictgen::InsensitiveStr::Ascii("ndabount"),
        dictgen::InsensitiveStr::Ascii("ndabounts"),
        dictgen::InsensitiveStr::Ascii("ndign"),
        dictgen::InsensitiveStr::Ascii("ndtriped"),
        dictgen::InsensitiveStr::Ascii("ndtriping"),
        dictgen::InsensitiveStr::Ascii("ndtripp"),
        dictgen::InsensitiveStr::Ascii("ng"),
        dictgen::InsensitiveStr::Ascii("ntine"),
        dictgen::InsensitiveStr::Ascii("ntines"),
        dictgen::InsensitiveStr::Ascii("ntrip"),
        dictgen::InsensitiveStr::Ascii("ntriped"),
        dictgen::InsensitiveStr::Ascii("ntriping"),
        dictgen::InsensitiveStr::Ascii("ntripped"),
        dictgen::InsensitiveStr::Ascii("ntripping"),
        dictgen::InsensitiveStr::Ascii("teros"),
        dictgen::InsensitiveStr::Ascii("tet"),
        dictgen::InsensitiveStr::Ascii("tiens"),
        dictgen::InsensitiveStr::Ascii("tin"),
        dictgen::InsensitiveStr::Ascii("tins"),
    ],
    values: &[
        &["rounding"],
        &["roughly"],
        &["roughly"],
        &["routine"],
        &["routines"],
        &["roundabout"],
        &["roundabout"],
        &["roundabout"],
        &["roundabout"],
        &["rounding"],
        &["roundtripped"],
        &["roundtripping"],
        &["roundtrip"],
        &["round"],
        &["routine"],
        &["routines"],
        &["roundtrip"],
        &["roundtripped"],
        &["roundtripping"],
        &["roundtripped"],
        &["roundtripping"],
        &["routers"],
        &["routed", "route", "router"],
        &["routines"],
        &["routine", "routing"],
        &["routines"],
    ],
    range: 2..=9,
};

static WORD_ROT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ROT_CHILDREN),
    value: None,
};

pub static WORD_ROT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aion"),
        dictgen::InsensitiveStr::Ascii("aions"),
        dictgen::InsensitiveStr::Ascii("aiton"),
        dictgen::InsensitiveStr::Ascii("aitons"),
        dictgen::InsensitiveStr::Ascii("at"),
        dictgen::InsensitiveStr::Ascii("ataion"),
        dictgen::InsensitiveStr::Ascii("ataions"),
        dictgen::InsensitiveStr::Ascii("atd"),
        dictgen::InsensitiveStr::Ascii("ateable"),
        dictgen::InsensitiveStr::Ascii("atio"),
        dictgen::InsensitiveStr::Ascii("atios"),
        dictgen::InsensitiveStr::Ascii("ats"),
        dictgen::InsensitiveStr::Ascii("uers"),
    ],
    values: &[
        &["rotation"],
        &["rotations"],
        &["rotation"],
        &["rotations"],
        &["rotate"],
        &["rotation"],
        &["rotations"],
        &["rotated", "rotate"],
        &["rotatable"],
        &["rotation", "ratio"],
        &["rotations", "ratios"],
        &["rotates", "rotate"],
        &["routers"],
    ],
    range: 2..=7,
};

static WORD_ROS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ROS_CHILDREN),
    value: None,
};

pub static WORD_ROS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ettta"),
        dictgen::InsensitiveStr::Ascii("ponse"),
        dictgen::InsensitiveStr::Ascii("ponsive"),
        dictgen::InsensitiveStr::Ascii("taing"),
    ],
    values: &[&["rosetta"], &["response"], &["responsive"], &["roasting"]],
    range: 5..=7,
};

static WORD_ROR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ROR_CHILDREN),
    value: None,
};

pub static WORD_ROR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ated")],
    values: &[&["rotated"]],
    range: 4..=4,
};

static WORD_ROP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ROP_CHILDREN),
    value: None,
};

pub static WORD_ROP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eat"),
        dictgen::InsensitiveStr::Ascii("ository"),
    ],
    values: &[&["repeat"], &["repository"]],
    range: 3..=7,
};

static WORD_ROO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ROO_CHILDREN),
    value: None,
};

pub static WORD_ROO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("mate")],
    values: &[&["roommate"]],
    range: 4..=4,
};

static WORD_RON_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RON_CHILDREN),
    value: None,
};

pub static WORD_RON_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("dayvoo"),
        dictgen::InsensitiveStr::Ascii("dayvooed"),
        dictgen::InsensitiveStr::Ascii("dayvou"),
        dictgen::InsensitiveStr::Ascii("dayvoued"),
        dictgen::InsensitiveStr::Ascii("dazyvoo"),
        dictgen::InsensitiveStr::Ascii("dazyvooed"),
        dictgen::InsensitiveStr::Ascii("dazyvou"),
        dictgen::InsensitiveStr::Ascii("dazyvoued"),
    ],
    values: &[
        &["rendezvous"],
        &["rendezvoused"],
        &["rendezvous"],
        &["rendezvoused"],
        &["rendezvous"],
        &["rendezvoused"],
        &["rendezvous"],
        &["rendezvoused"],
    ],
    range: 6..=9,
};

static WORD_ROM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ROM_CHILDREN),
    value: None,
};

pub static WORD_ROM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aanin"),
        dictgen::InsensitiveStr::Ascii("aina"),
        dictgen::InsensitiveStr::Ascii("ainan"),
        dictgen::InsensitiveStr::Ascii("aing"),
        dictgen::InsensitiveStr::Ascii("anain"),
        dictgen::InsensitiveStr::Ascii("anica"),
        dictgen::InsensitiveStr::Ascii("anin"),
        dictgen::InsensitiveStr::Ascii("anitcally"),
        dictgen::InsensitiveStr::Ascii("anmania"),
        dictgen::InsensitiveStr::Ascii("anna"),
        dictgen::InsensitiveStr::Ascii("anticaly"),
        dictgen::InsensitiveStr::Ascii("ote"),
        dictgen::InsensitiveStr::Ascii("oted"),
        dictgen::InsensitiveStr::Ascii("oteing"),
        dictgen::InsensitiveStr::Ascii("otely"),
        dictgen::InsensitiveStr::Ascii("otes"),
        dictgen::InsensitiveStr::Ascii("oting"),
        dictgen::InsensitiveStr::Ascii("otly"),
        dictgen::InsensitiveStr::Ascii("oves"),
    ],
    values: &[
        &["romanian"],
        &["romania"],
        &["romanian"],
        &["roaming"],
        &["romanian"],
        &["romania"],
        &["romanian"],
        &["romantically"],
        &["romanian"],
        &["romanian"],
        &["romantically"],
        &["remote"],
        &["remoted"],
        &["remoting"],
        &["remotely"],
        &["remotes"],
        &["remoting"],
        &["remotely"],
        &["removes"],
    ],
    range: 3..=9,
};

static WORD_ROL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ROL_CHILDREN),
    value: None,
};

pub static WORD_ROL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("epaly"),
        dictgen::InsensitiveStr::Ascii("epalying"),
        dictgen::InsensitiveStr::Ascii("eplaing"),
        dictgen::InsensitiveStr::Ascii("eply"),
        dictgen::InsensitiveStr::Ascii("larcoaster"),
        dictgen::InsensitiveStr::Ascii("lercaoster"),
        dictgen::InsensitiveStr::Ascii("lercoaser"),
        dictgen::InsensitiveStr::Ascii("lercoater"),
        dictgen::InsensitiveStr::Ascii("lercoaters"),
        dictgen::InsensitiveStr::Ascii("lercoatser"),
        dictgen::InsensitiveStr::Ascii("lerocaster"),
        dictgen::InsensitiveStr::Ascii("lertoaster"),
        dictgen::InsensitiveStr::Ascii("lorcoaster"),
    ],
    values: &[
        &["roleplay"],
        &["roleplaying"],
        &["roleplaying"],
        &["roleplay"],
        &["rollercoaster"],
        &["rollercoaster"],
        &["rollercoaster"],
        &["rollercoaster"],
        &["rollercoaster"],
        &["rollercoaster"],
        &["rollercoaster"],
        &["rollercoaster"],
        &["rollercoaster"],
    ],
    range: 4..=10,
};

static WORD_ROI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ROI_CHILDREN),
    value: None,
};

pub static WORD_ROI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("gin"),
        dictgen::InsensitiveStr::Ascii("ginal"),
        dictgen::InsensitiveStr::Ascii("ginally"),
        dictgen::InsensitiveStr::Ascii("ginals"),
        dictgen::InsensitiveStr::Ascii("ginating"),
        dictgen::InsensitiveStr::Ascii("gins"),
        dictgen::InsensitiveStr::Ascii("ters"),
    ],
    values: &[
        &["origin"],
        &["original"],
        &["originally"],
        &["originals"],
        &["originating"],
        &["origins"],
        &["rioters"],
    ],
    range: 3..=8,
};

static WORD_ROG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ROG_CHILDREN),
    value: None,
};

pub static WORD_ROG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("anism"),
        dictgen::InsensitiveStr::Ascii("anisms"),
    ],
    values: &[&["organism"], &["organisms"]],
    range: 5..=6,
};

static WORD_ROE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ROE_CHILDREN),
    value: None,
};

pub static WORD_ROE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("lplay"),
        dictgen::InsensitiveStr::Ascii("stta"),
    ],
    values: &[&["roleplay"], &["rosetta"]],
    range: 4..=5,
};

static WORD_ROD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ROD_CHILDREN),
    value: None,
};

pub static WORD_ROD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("uce"),
        dictgen::InsensitiveStr::Ascii("uceer"),
    ],
    values: &[&["reduce", "produce"], &["producer"]],
    range: 3..=5,
};

static WORD_ROC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ROC_CHILDREN),
    value: None,
};

pub static WORD_ROC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("kerfeller"),
        dictgen::InsensitiveStr::Ascii("occo"),
        dictgen::InsensitiveStr::Ascii("ord"),
        dictgen::InsensitiveStr::Ascii("orded"),
        dictgen::InsensitiveStr::Ascii("order"),
        dictgen::InsensitiveStr::Ascii("ording"),
        dictgen::InsensitiveStr::Ascii("ordings"),
        dictgen::InsensitiveStr::Ascii("ords"),
    ],
    values: &[
        &["rockefeller"],
        &["rococo"],
        &["record"],
        &["recorded"],
        &["recorder"],
        &["recording"],
        &["recordings"],
        &["records"],
    ],
    range: 3..=9,
};

static WORD_ROB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ROB_CHILDREN),
    value: None,
};

pub static WORD_ROB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("berts"),
        dictgen::InsensitiveStr::Ascii("berys"),
        dictgen::InsensitiveStr::Ascii("ocoop"),
        dictgen::InsensitiveStr::Ascii("ocorp"),
        dictgen::InsensitiveStr::Ascii("ocoup"),
        dictgen::InsensitiveStr::Ascii("oticus"),
        dictgen::InsensitiveStr::Ascii("otis"),
        dictgen::InsensitiveStr::Ascii("oustness"),
        dictgen::InsensitiveStr::Ascii("ustnes"),
    ],
    values: &[
        &["robbers"],
        &["robbers"],
        &["robocop"],
        &["robocop"],
        &["robocop"],
        &["robotics"],
        &["robotics"],
        &["robustness"],
        &["robustness"],
    ],
    range: 4..=8,
};

static WORD_ROA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ROA_CHILDREN),
    value: None,
};

pub static WORD_ROA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("chers"),
        dictgen::InsensitiveStr::Ascii("hces"),
        dictgen::InsensitiveStr::Ascii("taion"),
        dictgen::InsensitiveStr::Ascii("tation"),
        dictgen::InsensitiveStr::Ascii("ted"),
        dictgen::InsensitiveStr::Ascii("tion"),
        dictgen::InsensitiveStr::Ascii("ylties"),
    ],
    values: &[
        &["roaches"],
        &["roaches"],
        &["rotation"],
        &["rotation"],
        &["rotated"],
        &["rotation"],
        &["royalties"],
    ],
    range: 3..=6,
};

static WORD_RN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RN_CHILDREN),
    value: None,
};

pub static WORD_RN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("age")],
    values: &[&["rage", "range"]],
    range: 3..=3,
};

static WORD_RM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RM_CHILDREN),
    value: None,
};

pub static WORD_RM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eote"),
        dictgen::InsensitiveStr::Ascii("eove"),
        dictgen::InsensitiveStr::Ascii("eoved"),
        dictgen::InsensitiveStr::Ascii("eoves"),
        dictgen::InsensitiveStr::Ascii("ove"),
        dictgen::InsensitiveStr::Ascii("oved"),
        dictgen::InsensitiveStr::Ascii("oving"),
    ],
    values: &[
        &["remote"],
        &["remove"],
        &["removed"],
        &["removes"],
        &["remove"],
        &["removed"],
        &["removing"],
    ],
    range: 3..=5,
};

static WORD_RL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RL_CHILDREN),
    value: None,
};

pub static WORD_RL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ation"),
        dictgen::InsensitiveStr::Ascii("se"),
    ],
    values: &[&["relation"], &["else"]],
    range: 2..=5,
};

static WORD_RI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_RI_CHILDREN),
    value: None,
};

static WORD_RI_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_RIA_NODE),
    None,
    Some(&WORD_RIC_NODE),
    Some(&WORD_RID_NODE),
    Some(&WORD_RIE_NODE),
    None,
    Some(&WORD_RIG_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_RIL_NODE),
    Some(&WORD_RIM_NODE),
    Some(&WORD_RIN_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_RIS_NODE),
    Some(&WORD_RIT_NODE),
    None,
    Some(&WORD_RIV_NODE),
    None,
    None,
    None,
    Some(&WORD_RIZ_NODE),
];

static WORD_RIZ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RIZ_CHILDREN),
    value: None,
};

pub static WORD_RIZ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("es")],
    values: &[&["rises"]],
    range: 2..=2,
};

static WORD_RIV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RIV_CHILDREN),
    value: None,
};

pub static WORD_RIV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("alrly"),
        dictgen::InsensitiveStr::Ascii("arlies"),
        dictgen::InsensitiveStr::Ascii("arly"),
        dictgen::InsensitiveStr::Ascii("ised"),
        dictgen::InsensitiveStr::Ascii("laries"),
        dictgen::InsensitiveStr::Ascii("lary"),
    ],
    values: &[
        &["rivalry"],
        &["rivalries"],
        &["rivalry"],
        &["revised"],
        &["rivalries"],
        &["rivalry"],
    ],
    range: 4..=6,
};

static WORD_RIT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RIT_CHILDREN),
    value: None,
};

pub static WORD_RIT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("able"),
        dictgen::InsensitiveStr::Ascii("alian"),
        dictgen::InsensitiveStr::Ascii("h"),
        dictgen::InsensitiveStr::Ascii("hm"),
        dictgen::InsensitiveStr::Ascii("hmic"),
        dictgen::InsensitiveStr::Ascii("hmicly"),
        dictgen::InsensitiveStr::Ascii("lain"),
        dictgen::InsensitiveStr::Ascii("oers"),
        dictgen::InsensitiveStr::Ascii("tle"),
        dictgen::InsensitiveStr::Ascii("tled"),
        dictgen::InsensitiveStr::Ascii("tler"),
        dictgen::InsensitiveStr::Ascii("tles"),
        dictgen::InsensitiveStr::Ascii("tling"),
    ],
    values: &[
        &["writable"],
        &["ritalin"],
        &["with"],
        &["rhythm"],
        &["rhythmic"],
        &["rhythmically"],
        &["ritalin"],
        &["rioters"],
        &["rattle", "riddle"],
        &["rattled", "riddled"],
        &["rattler", "riddler"],
        &["rattles", "riddles"],
        &["rattling", "riddling"],
    ],
    range: 1..=6,
};

static WORD_RIS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RIS_CHILDREN),
    value: None,
};

pub static WORD_RIS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("kay"),
        dictgen::InsensitiveStr::Ascii("pective"),
        dictgen::InsensitiveStr::Ascii("trict"),
        dictgen::InsensitiveStr::Ascii("tricted"),
        dictgen::InsensitiveStr::Ascii("triction"),
    ],
    values: &[
        &["raised", "rose"],
        &["risky", "risqué"],
        &["respective"],
        &["restrict"],
        &["restricted"],
        &["restriction"],
    ],
    range: 2..=8,
};

static WORD_RIN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RIN_CHILDREN),
    value: None,
};

pub static WORD_RIN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("gotne"),
        dictgen::InsensitiveStr::Ascii("inging"),
        dictgen::InsensitiveStr::Ascii("osarus"),
        dictgen::InsensitiveStr::Ascii("osaruses"),
        dictgen::InsensitiveStr::Ascii("osaruss"),
    ],
    values: &[
        &["ringtone"],
        &["ringing"],
        &["rhinoceros"],
        &["rhinoceroses"],
        &["rhinoceroses"],
    ],
    range: 5..=8,
};

static WORD_RIM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RIM_CHILDREN),
    value: None,
};

pub static WORD_RIM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aniss"),
        dictgen::InsensitiveStr::Ascii("anissed"),
        dictgen::InsensitiveStr::Ascii("anissent"),
        dictgen::InsensitiveStr::Ascii("anisser"),
        dictgen::InsensitiveStr::Ascii("anisses"),
        dictgen::InsensitiveStr::Ascii("anissing"),
        dictgen::InsensitiveStr::Ascii("inder"),
        dictgen::InsensitiveStr::Ascii("inders"),
        dictgen::InsensitiveStr::Ascii("inding"),
        dictgen::InsensitiveStr::Ascii("iniced"),
        dictgen::InsensitiveStr::Ascii("inicent"),
        dictgen::InsensitiveStr::Ascii("inicer"),
        dictgen::InsensitiveStr::Ascii("inices"),
        dictgen::InsensitiveStr::Ascii("inicing"),
        dictgen::InsensitiveStr::Ascii("itives"),
    ],
    values: &[
        &["reminisce"],
        &["reminisced"],
        &["reminiscent"],
        &["reminiscer"],
        &["reminisces"],
        &["reminiscing"],
        &["reminder"],
        &["reminders"],
        &["reminding"],
        &["reminisced"],
        &["reminiscent"],
        &["reminiscer"],
        &["reminisces"],
        &["reminiscing"],
        &["primitives"],
    ],
    range: 5..=8,
};

static WORD_RIL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RIL_CHILDREN),
    value: None,
};

pub static WORD_RIL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("varies")],
    values: &[&["rivalries"]],
    range: 6..=6,
};

static WORD_RIG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RIG_CHILDREN),
    value: None,
};

pub static WORD_RIG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("eur"),
        dictgen::InsensitiveStr::Ascii("h"),
        dictgen::InsensitiveStr::Ascii("hetous"),
        dictgen::InsensitiveStr::Ascii("hetousness"),
        dictgen::InsensitiveStr::Ascii("hht"),
        dictgen::InsensitiveStr::Ascii("hmost"),
        dictgen::InsensitiveStr::Ascii("hteos"),
        dictgen::InsensitiveStr::Ascii("hteouness"),
        dictgen::InsensitiveStr::Ascii("hteoussness"),
        dictgen::InsensitiveStr::Ascii("htfullly"),
        dictgen::InsensitiveStr::Ascii("htfuly"),
        dictgen::InsensitiveStr::Ascii("htiousness"),
        dictgen::InsensitiveStr::Ascii("htoues"),
        dictgen::InsensitiveStr::Ascii("htt"),
        dictgen::InsensitiveStr::Ascii("ntone"),
        dictgen::InsensitiveStr::Ascii("oreous"),
        dictgen::InsensitiveStr::Ascii("ourous"),
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("th"),
        dictgen::InsensitiveStr::Ascii("theous"),
        dictgen::InsensitiveStr::Ascii("theousness"),
        dictgen::InsensitiveStr::Ascii("thfully"),
        dictgen::InsensitiveStr::Ascii("ths"),
        dictgen::InsensitiveStr::Ascii("urous"),
    ],
    values: &[
        &["rice", "ride", "ridge", "rigs"],
        &["rides", "ridges"],
        &["rigueur", "rigour"],
        &["right"],
        &["righteous"],
        &["righteousness"],
        &["right"],
        &["rightmost"],
        &["righteous"],
        &["righteousness"],
        &["righteousness"],
        &["rightfully"],
        &["rightfully"],
        &["righteousness"],
        &["righteous"],
        &["right"],
        &["ringtone"],
        &["rigorous"],
        &["rigorous"],
        &["right"],
        &["right"],
        &["righteous"],
        &["righteousness"],
        &["rightfully"],
        &["rights"],
        &["rigorous"],
    ],
    range: 1..=11,
};

static WORD_RIE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RIE_CHILDREN),
    value: None,
};

pub static WORD_RIE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ndeer"),
        dictgen::InsensitiveStr::Ascii("ndeers"),
        dictgen::InsensitiveStr::Ascii("nforced"),
        dictgen::InsensitiveStr::Ascii("nforcement"),
        dictgen::InsensitiveStr::Ascii("nforcements"),
    ],
    values: &[
        &["reindeer"],
        &["reindeers"],
        &["reenforced"],
        &["reinforcements"],
        &["reinforcements"],
    ],
    range: 5..=11,
};

static WORD_RID_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RID_CHILDREN),
    value: None,
};

pub static WORD_RID_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("icilous"),
        dictgen::InsensitiveStr::Ascii("icilously"),
        dictgen::InsensitiveStr::Ascii("icilousness"),
        dictgen::InsensitiveStr::Ascii("icoulus"),
        dictgen::InsensitiveStr::Ascii("icoulusly"),
        dictgen::InsensitiveStr::Ascii("icoulusness"),
        dictgen::InsensitiveStr::Ascii("iculious"),
        dictgen::InsensitiveStr::Ascii("iculled"),
        dictgen::InsensitiveStr::Ascii("iculos"),
        dictgen::InsensitiveStr::Ascii("iculose"),
        dictgen::InsensitiveStr::Ascii("iculosly"),
        dictgen::InsensitiveStr::Ascii("iculouly"),
        dictgen::InsensitiveStr::Ascii("iculouness"),
        dictgen::InsensitiveStr::Ascii("iculoussness"),
        dictgen::InsensitiveStr::Ascii("iculousy"),
        dictgen::InsensitiveStr::Ascii("iculue"),
        dictgen::InsensitiveStr::Ascii("iculued"),
        dictgen::InsensitiveStr::Ascii("iculus"),
    ],
    values: &[
        &["ridiculous"],
        &["ridiculously"],
        &["ridiculousness"],
        &["ridiculous"],
        &["ridiculously"],
        &["ridiculousness"],
        &["ridiculous"],
        &["ridicule"],
        &["ridiculous"],
        &["ridicule"],
        &["ridiculously"],
        &["ridiculously"],
        &["ridiculousness"],
        &["ridiculousness"],
        &["ridiculously"],
        &["ridicule"],
        &["ridicule"],
        &["ridiculous"],
    ],
    range: 6..=12,
};

static WORD_RIC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RIC_CHILDREN),
    value: None,
};

pub static WORD_RIC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("koshay"),
        dictgen::InsensitiveStr::Ascii("koshayed"),
        dictgen::InsensitiveStr::Ascii("koshaying"),
        dictgen::InsensitiveStr::Ascii("koshays"),
        dictgen::InsensitiveStr::Ascii("tatorship"),
    ],
    values: &[
        &["ricochet"],
        &["ricocheted"],
        &["ricocheting"],
        &["ricochets"],
        &["dictatorship"],
    ],
    range: 6..=9,
};

static WORD_RIA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RIA_CHILDREN),
    value: None,
};

pub static WORD_RIA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ders")],
    values: &[&["raiders"]],
    range: 4..=4,
};

static WORD_RH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RH_CHILDREN),
    value: None,
};

pub static WORD_RH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aposdy"),
        dictgen::InsensitiveStr::Ascii("apsodomy"),
        dictgen::InsensitiveStr::Ascii("apsoy"),
        dictgen::InsensitiveStr::Ascii("aspody"),
        dictgen::InsensitiveStr::Ascii("eotric"),
        dictgen::InsensitiveStr::Ascii("ethoric"),
        dictgen::InsensitiveStr::Ascii("ethorical"),
        dictgen::InsensitiveStr::Ascii("ethorically"),
        dictgen::InsensitiveStr::Ascii("etorisch"),
        dictgen::InsensitiveStr::Ascii("inosarus"),
        dictgen::InsensitiveStr::Ascii("inosaruses"),
        dictgen::InsensitiveStr::Ascii("inosaruss"),
        dictgen::InsensitiveStr::Ascii("ymme"),
        dictgen::InsensitiveStr::Ascii("ythem"),
        dictgen::InsensitiveStr::Ascii("ythim"),
        dictgen::InsensitiveStr::Ascii("ythimcally"),
        dictgen::InsensitiveStr::Ascii("ytmic"),
    ],
    values: &[
        &["rhapsody"],
        &["rhapsody"],
        &["rhapsody"],
        &["rhapsody"],
        &["rhetoric"],
        &["rhetoric"],
        &["rhetorical"],
        &["rhetorically"],
        &["rhetoric"],
        &["rhinoceros"],
        &["rhinoceroses"],
        &["rhinoceroses"],
        &["rhyme"],
        &["rhythm"],
        &["rhythm"],
        &["rhythmically"],
        &["rhythmic"],
    ],
    range: 4..=11,
};

static WORD_RG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RG_CHILDREN),
    value: None,
};

pub static WORD_RG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ister")],
    values: &[&["register"]],
    range: 5..=5,
};

static WORD_RF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RF_CHILDREN),
    value: None,
};

pub static WORD_RF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("erence"),
        dictgen::InsensitiveStr::Ascii("erences"),
        dictgen::InsensitiveStr::Ascii("eturned"),
    ],
    values: &[&["reference"], &["references"], &["returned"]],
    range: 6..=7,
};

static WORD_RE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_RE_CHILDREN),
    value: None,
};

static WORD_RE_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_REA_NODE),
    Some(&WORD_REB_NODE),
    Some(&WORD_REC_NODE),
    Some(&WORD_RED_NODE),
    Some(&WORD_REE_NODE),
    Some(&WORD_REF_NODE),
    Some(&WORD_REG_NODE),
    Some(&WORD_REH_NODE),
    Some(&WORD_REI_NODE),
    Some(&WORD_REJ_NODE),
    Some(&WORD_REK_NODE),
    Some(&WORD_REL_NODE),
    Some(&WORD_REM_NODE),
    Some(&WORD_REN_NODE),
    Some(&WORD_REO_NODE),
    Some(&WORD_REP_NODE),
    Some(&WORD_REQ_NODE),
    Some(&WORD_RER_NODE),
    Some(&WORD_RES_NODE),
    Some(&WORD_RET_NODE),
    Some(&WORD_REU_NODE),
    Some(&WORD_REV_NODE),
    Some(&WORD_REW_NODE),
    None,
    Some(&WORD_REY_NODE),
    Some(&WORD_REZ_NODE),
];

static WORD_REZ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REZ_CHILDREN),
    value: None,
};

pub static WORD_REZ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("urrection")],
    values: &[&["resurrection"]],
    range: 9..=9,
};

static WORD_REY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REY_CHILDREN),
    value: None,
};

pub static WORD_REY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("nlods"),
        dictgen::InsensitiveStr::Ascii("nols"),
        dictgen::InsensitiveStr::Ascii("onlds"),
    ],
    values: &[&["reynolds"], &["reynolds"], &["reynolds"]],
    range: 4..=5,
};

static WORD_REW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REW_CHILDREN),
    value: None,
};

pub static WORD_REW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("achted"),
        dictgen::InsensitiveStr::Ascii("arching"),
        dictgen::InsensitiveStr::Ascii("atchd"),
        dictgen::InsensitiveStr::Ascii("atchibg"),
        dictgen::InsensitiveStr::Ascii("atchig"),
        dictgen::InsensitiveStr::Ascii("atchign"),
        dictgen::InsensitiveStr::Ascii("atchimg"),
        dictgen::InsensitiveStr::Ascii("iev"),
        dictgen::InsensitiveStr::Ascii("ieved"),
        dictgen::InsensitiveStr::Ascii("iever"),
        dictgen::InsensitiveStr::Ascii("ieving"),
        dictgen::InsensitiveStr::Ascii("ievs"),
        dictgen::InsensitiveStr::Ascii("irtable"),
        dictgen::InsensitiveStr::Ascii("irte"),
        dictgen::InsensitiveStr::Ascii("irtten"),
        dictgen::InsensitiveStr::Ascii("itable"),
        dictgen::InsensitiveStr::Ascii("ite"),
        dictgen::InsensitiveStr::Ascii("itten"),
        dictgen::InsensitiveStr::Ascii("orkd"),
        dictgen::InsensitiveStr::Ascii("riable"),
        dictgen::InsensitiveStr::Ascii("riet"),
        dictgen::InsensitiveStr::Ascii("riite"),
        dictgen::InsensitiveStr::Ascii("rited"),
        dictgen::InsensitiveStr::Ascii("riten"),
        dictgen::InsensitiveStr::Ascii("ritte"),
        dictgen::InsensitiveStr::Ascii("ritting"),
        dictgen::InsensitiveStr::Ascii("tched"),
        dictgen::InsensitiveStr::Ascii("uired"),
    ],
    values: &[
        &["rewatched"],
        &["rewatching"],
        &["rewatched"],
        &["rewatching"],
        &["rewatching"],
        &["rewatching"],
        &["rewatching"],
        &["review"],
        &["reviewed"],
        &["reviewer"],
        &["reviewing"],
        &["reviews"],
        &["rewritable"],
        &["rewrite"],
        &["rewritten"],
        &["rewritable"],
        &["rewrite"],
        &["rewritten"],
        &["reworked"],
        &["rewritable", "reliable"],
        &["rewrite"],
        &["rewrite"],
        &["rewrote", "rewritten"],
        &["rewritten"],
        &["rewrite"],
        &["rewriting"],
        &["wretched"],
        &["required"],
    ],
    range: 3..=7,
};

static WORD_REV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_REV_CHILDREN),
    value: None,
};

static WORD_REV_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_REVA_NODE),
    None,
    None,
    None,
    Some(&WORD_REVE_NODE),
    None,
    None,
    None,
    Some(&WORD_REVI_NODE),
    None,
    None,
    Some(&WORD_REVL_NODE),
    None,
    None,
    Some(&WORD_REVO_NODE),
    None,
    None,
    Some(&WORD_REVR_NODE),
    Some(&WORD_REVS_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_REVS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REVS_CHILDREN),
    value: None,
};

pub static WORD_REVS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("erse"),
        dictgen::InsensitiveStr::Ascii("ion"),
    ],
    values: &[&["reverse"], &["revision"]],
    range: 3..=4,
};

static WORD_REVR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REVR_CHILDREN),
    value: None,
};

pub static WORD_REVR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ese"),
        dictgen::InsensitiveStr::Ascii("ieve"),
        dictgen::InsensitiveStr::Ascii("ieved"),
        dictgen::InsensitiveStr::Ascii("iever"),
        dictgen::InsensitiveStr::Ascii("ievers"),
        dictgen::InsensitiveStr::Ascii("ieves"),
    ],
    values: &[
        &["reverse"],
        &["retrieve"],
        &["retrieved"],
        &["retriever"],
        &["retrievers"],
        &["retrieves"],
    ],
    range: 3..=6,
};

static WORD_REVO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REVO_CHILDREN),
    value: None,
};

pub static WORD_REVO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ce"),
        dictgen::InsensitiveStr::Ascii("kation"),
        dictgen::InsensitiveStr::Ascii("lations"),
        dictgen::InsensitiveStr::Ascii("ltuion"),
        dictgen::InsensitiveStr::Ascii("ltuionary"),
        dictgen::InsensitiveStr::Ascii("ltuions"),
        dictgen::InsensitiveStr::Ascii("luion"),
        dictgen::InsensitiveStr::Ascii("luionary"),
        dictgen::InsensitiveStr::Ascii("luions"),
        dictgen::InsensitiveStr::Ascii("luiton"),
        dictgen::InsensitiveStr::Ascii("luitonary"),
        dictgen::InsensitiveStr::Ascii("luitons"),
        dictgen::InsensitiveStr::Ascii("lulionary"),
        dictgen::InsensitiveStr::Ascii("lutin"),
        dictgen::InsensitiveStr::Ascii("lutinary"),
        dictgen::InsensitiveStr::Ascii("lutins"),
        dictgen::InsensitiveStr::Ascii("lutionaary"),
        dictgen::InsensitiveStr::Ascii("lutionair"),
        dictgen::InsensitiveStr::Ascii("lutionairy"),
        dictgen::InsensitiveStr::Ascii("lutionar"),
        dictgen::InsensitiveStr::Ascii("lutionaryy"),
        dictgen::InsensitiveStr::Ascii("lutionay"),
        dictgen::InsensitiveStr::Ascii("lutionens"),
        dictgen::InsensitiveStr::Ascii("lutioners"),
        dictgen::InsensitiveStr::Ascii("lutionnary"),
        dictgen::InsensitiveStr::Ascii("lutionos"),
        dictgen::InsensitiveStr::Ascii("lutoin"),
        dictgen::InsensitiveStr::Ascii("lutoinary"),
        dictgen::InsensitiveStr::Ascii("lutoins"),
        dictgen::InsensitiveStr::Ascii("luttionary"),
        dictgen::InsensitiveStr::Ascii("luutionary"),
        dictgen::InsensitiveStr::Ascii("lvr"),
        dictgen::InsensitiveStr::Ascii("lvs"),
        dictgen::InsensitiveStr::Ascii("ultion"),
        dictgen::InsensitiveStr::Ascii("ultionary"),
        dictgen::InsensitiveStr::Ascii("ultions"),
        dictgen::InsensitiveStr::Ascii("vler"),
        dictgen::InsensitiveStr::Ascii("vles"),
    ],
    values: &[
        &["revoke"],
        &["revocation"],
        &["revolutions"],
        &["revolution"],
        &["revolutionary"],
        &["revolutions"],
        &["revolution"],
        &["revolutionary"],
        &["revolutions"],
        &["revolutions", "revolution"],
        &["revolutionary"],
        &["revolutions"],
        &["revolutionary"],
        &["revolutions", "revolution"],
        &["revolutionary"],
        &["revolutions"],
        &["revolutionary"],
        &["revolutionary"],
        &["revolutionary"],
        &["revolutionary"],
        &["revolutionary"],
        &["revolutionary"],
        &["revolutions"],
        &["revolutions"],
        &["revolutionary"],
        &["revolutions"],
        &["revolutions"],
        &["revolutionary"],
        &["revolutionss"],
        &["revolutionary"],
        &["revolutionary"],
        &["revolver"],
        &["revolves"],
        &["revolution"],
        &["revolutionary"],
        &["revolutions"],
        &["revolver"],
        &["revolves"],
    ],
    range: 2..=10,
};

static WORD_REVL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REVL_CHILDREN),
    value: None,
};

pub static WORD_REVL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("over"),
        dictgen::InsensitiveStr::Ascii("oves"),
    ],
    values: &[&["revolver"], &["revolves"]],
    range: 4..=4,
};

static WORD_REVI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REVI_CHILDREN),
    value: None,
};

pub static WORD_REVI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ere"),
        dictgen::InsensitiveStr::Ascii("ewd"),
        dictgen::InsensitiveStr::Ascii("ewes"),
        dictgen::InsensitiveStr::Ascii("ewl"),
        dictgen::InsensitiveStr::Ascii("ewr"),
        dictgen::InsensitiveStr::Ascii("ewsectio"),
        dictgen::InsensitiveStr::Ascii("ewtrue"),
        dictgen::InsensitiveStr::Ascii("siones"),
        dictgen::InsensitiveStr::Ascii("sionis"),
        dictgen::InsensitiveStr::Ascii("sisions"),
        dictgen::InsensitiveStr::Ascii("son"),
        dictgen::InsensitiveStr::Ascii("sons"),
        dictgen::InsensitiveStr::Ascii("st"),
        dictgen::InsensitiveStr::Ascii("sted"),
        dictgen::InsensitiveStr::Ascii("sting"),
        dictgen::InsensitiveStr::Ascii("sts"),
        dictgen::InsensitiveStr::Ascii("wed"),
        dictgen::InsensitiveStr::Ascii("wer"),
        dictgen::InsensitiveStr::Ascii("wers"),
        dictgen::InsensitiveStr::Ascii("wing"),
    ],
    values: &[
        &["reviewer"],
        &["reviewed"],
        &["reviewers"],
        &["review"],
        &["reviewer"],
        &["reviewsection"],
        &["reviewer"],
        &["revisions"],
        &["revisions"],
        &["revisions"],
        &["revision"],
        &["revisions"],
        &["revisit"],
        &["revisited"],
        &["revisiting"],
        &["revisits"],
        &["reviewed"],
        &["reviewer"],
        &["reviewers"],
        &["reviewing"],
    ],
    range: 2..=8,
};

static WORD_REVE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REVE_CHILDREN),
    value: None,
};

pub static WORD_REVE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ald"),
        dictgen::InsensitiveStr::Ascii("ales"),
        dictgen::InsensitiveStr::Ascii("altion"),
        dictgen::InsensitiveStr::Ascii("altions"),
        dictgen::InsensitiveStr::Ascii("ive"),
        dictgen::InsensitiveStr::Ascii("iw"),
        dictgen::InsensitiveStr::Ascii("iwed"),
        dictgen::InsensitiveStr::Ascii("iwer"),
        dictgen::InsensitiveStr::Ascii("iwers"),
        dictgen::InsensitiveStr::Ascii("iwes"),
        dictgen::InsensitiveStr::Ascii("iwing"),
        dictgen::InsensitiveStr::Ascii("iws"),
        dictgen::InsensitiveStr::Ascii("laed"),
        dictgen::InsensitiveStr::Ascii("laing"),
        dictgen::InsensitiveStr::Ascii("laiton"),
        dictgen::InsensitiveStr::Ascii("laitons"),
        dictgen::InsensitiveStr::Ascii("lance"),
        dictgen::InsensitiveStr::Ascii("lant"),
        dictgen::InsensitiveStr::Ascii("las"),
        dictgen::InsensitiveStr::Ascii("latons"),
        dictgen::InsensitiveStr::Ascii("lead"),
        dictgen::InsensitiveStr::Ascii("lent"),
        dictgen::InsensitiveStr::Ascii("lution"),
        dictgen::InsensitiveStr::Ascii("lutionary"),
        dictgen::InsensitiveStr::Ascii("lutions"),
        dictgen::InsensitiveStr::Ascii("okes"),
        dictgen::InsensitiveStr::Ascii("r"),
        dictgen::InsensitiveStr::Ascii("ral"),
        dictgen::InsensitiveStr::Ascii("rals"),
        dictgen::InsensitiveStr::Ascii("rce"),
        dictgen::InsensitiveStr::Ascii("rced"),
        dictgen::InsensitiveStr::Ascii("rece"),
        dictgen::InsensitiveStr::Ascii("reces"),
        dictgen::InsensitiveStr::Ascii("rese"),
        dictgen::InsensitiveStr::Ascii("resed"),
        dictgen::InsensitiveStr::Ascii("ret"),
        dictgen::InsensitiveStr::Ascii("reted"),
        dictgen::InsensitiveStr::Ascii("rsable"),
        dictgen::InsensitiveStr::Ascii("rsably"),
        dictgen::InsensitiveStr::Ascii("rseed"),
        dictgen::InsensitiveStr::Ascii("rsees"),
        dictgen::InsensitiveStr::Ascii("rve"),
        dictgen::InsensitiveStr::Ascii("rved"),
        dictgen::InsensitiveStr::Ascii("wrse"),
    ],
    values: &[
        &["revealed"],
        &["reveals"],
        &["revelations"],
        &["revelations"],
        &["receive", "revive"],
        &["review"],
        &["reviewed"],
        &["reviewer"],
        &["reviewers"],
        &["reviews", "reviewers"],
        &["reviewing"],
        &["reviews"],
        &["revealed"],
        &["revealing"],
        &["revelations"],
        &["revelations"],
        &["relevance"],
        &["relevant"],
        &["reveals"],
        &["revelations"],
        &["revealed"],
        &["relevant"],
        &["revelation", "revolution"],
        &["revolutionary"],
        &["revolutions"],
        &["revokes"],
        &["revert", "refer", "fever"],
        &["reversal", "referral"],
        &["reversal"],
        &["reverse"],
        &["reversed"],
        &["reference", "reverence"],
        &["references"],
        &["reverse"],
        &["reversed"],
        &["revert"],
        &["reverted"],
        &["reversible"],
        &["reversal"],
        &["reversed"],
        &["reverses"],
        &["reserve"],
        &["reserved"],
        &["reverse"],
    ],
    range: 1..=9,
};

static WORD_REVA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REVA_CHILDREN),
    value: None,
};

pub static WORD_REVA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ildating"),
        dictgen::InsensitiveStr::Ascii("luated"),
    ],
    values: &[&["revalidating"], &["reevaluated"]],
    range: 6..=8,
};

static WORD_REU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REU_CHILDREN),
    value: None,
};

pub static WORD_REU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("asble"),
        dictgen::InsensitiveStr::Ascii("dce"),
        dictgen::InsensitiveStr::Ascii("dced"),
        dictgen::InsensitiveStr::Ascii("dces"),
        dictgen::InsensitiveStr::Ascii("dction"),
        dictgen::InsensitiveStr::Ascii("dctions"),
        dictgen::InsensitiveStr::Ascii("est"),
        dictgen::InsensitiveStr::Ascii("ests"),
        dictgen::InsensitiveStr::Ascii("inon"),
        dictgen::InsensitiveStr::Ascii("lator"),
        dictgen::InsensitiveStr::Ascii("ndant"),
        dictgen::InsensitiveStr::Ascii("ndantly"),
        dictgen::InsensitiveStr::Ascii("plad"),
        dictgen::InsensitiveStr::Ascii("pladad"),
        dictgen::InsensitiveStr::Ascii("pladed"),
        dictgen::InsensitiveStr::Ascii("plader"),
        dictgen::InsensitiveStr::Ascii("pladers"),
        dictgen::InsensitiveStr::Ascii("plading"),
        dictgen::InsensitiveStr::Ascii("plads"),
        dictgen::InsensitiveStr::Ascii("plaod"),
        dictgen::InsensitiveStr::Ascii("plaodad"),
        dictgen::InsensitiveStr::Ascii("plaoded"),
        dictgen::InsensitiveStr::Ascii("plaoder"),
        dictgen::InsensitiveStr::Ascii("plaoders"),
        dictgen::InsensitiveStr::Ascii("plaoding"),
        dictgen::InsensitiveStr::Ascii("plaods"),
        dictgen::InsensitiveStr::Ascii("plod"),
        dictgen::InsensitiveStr::Ascii("plodad"),
        dictgen::InsensitiveStr::Ascii("ploded"),
        dictgen::InsensitiveStr::Ascii("ploder"),
        dictgen::InsensitiveStr::Ascii("ploders"),
        dictgen::InsensitiveStr::Ascii("ploding"),
        dictgen::InsensitiveStr::Ascii("plods"),
        dictgen::InsensitiveStr::Ascii("ptable"),
        dictgen::InsensitiveStr::Ascii("qest"),
        dictgen::InsensitiveStr::Ascii("qested"),
        dictgen::InsensitiveStr::Ascii("qesting"),
        dictgen::InsensitiveStr::Ascii("qests"),
        dictgen::InsensitiveStr::Ascii("qire"),
        dictgen::InsensitiveStr::Ascii("quest"),
        dictgen::InsensitiveStr::Ascii("rn"),
        dictgen::InsensitiveStr::Ascii("rsively"),
        dictgen::InsensitiveStr::Ascii("seable"),
        dictgen::InsensitiveStr::Ascii("slt"),
        dictgen::InsensitiveStr::Ascii("ssing"),
        dictgen::InsensitiveStr::Ascii("tnred"),
        dictgen::InsensitiveStr::Ascii("trn"),
        dictgen::InsensitiveStr::Ascii("trns"),
    ],
    values: &[
        &["reusable"],
        &["reduce"],
        &["reduced"],
        &["reduces"],
        &["reduction"],
        &["reductions"],
        &["request"],
        &["requests"],
        &["reunion"],
        &["regulator"],
        &["redundant"],
        &["redundantly"],
        &["reupload"],
        &["reupload", "reuploaded"],
        &["reuploaded"],
        &["reuploader"],
        &["reuploaders"],
        &["reuploading"],
        &["reuploads"],
        &["reupload"],
        &["reupload", "reuploaded"],
        &["reuploaded"],
        &["reuploader"],
        &["reuploaders"],
        &["reuploading"],
        &["reuploads"],
        &["reupload"],
        &["reupload", "reuploaded"],
        &["reuploaded"],
        &["reuploader"],
        &["reuploaders"],
        &["reuploading"],
        &["reuploads"],
        &["reputable"],
        &["request"],
        &["requested"],
        &["requesting"],
        &["requests"],
        &["required"],
        &["request"],
        &["return"],
        &["recursively"],
        &["reusable"],
        &["result"],
        &["reusing"],
        &["returned"],
        &["return"],
        &["returns"],
    ],
    range: 2..=8,
};

static WORD_RET_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_RET_CHILDREN),
    value: None,
};

static WORD_RET_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_RETA_NODE),
    None,
    Some(&WORD_RETC_NODE),
    None,
    Some(&WORD_RETE_NODE),
    None,
    None,
    Some(&WORD_RETH_NODE),
    Some(&WORD_RETI_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_RETO_NODE),
    Some(&WORD_RETP_NODE),
    Some(&WORD_RETQ_NODE),
    Some(&WORD_RETR_NODE),
    Some(&WORD_RETS_NODE),
    None,
    Some(&WORD_RETU_NODE),
    None,
    None,
    None,
    Some(&WORD_RETY_NODE),
    None,
];

static WORD_RETY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RETY_CHILDREN),
    value: None,
};

pub static WORD_RETY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ring")],
    values: &[&["retrying"]],
    range: 4..=4,
};

static WORD_RETU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RETU_CHILDREN),
    value: None,
};

pub static WORD_RETU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("n"),
        dictgen::InsensitiveStr::Ascii("nr"),
        dictgen::InsensitiveStr::Ascii("nred"),
        dictgen::InsensitiveStr::Ascii("nrned"),
        dictgen::InsensitiveStr::Ascii("nrs"),
        dictgen::InsensitiveStr::Ascii("ns"),
        dictgen::InsensitiveStr::Ascii("r"),
        dictgen::InsensitiveStr::Ascii("re"),
        dictgen::InsensitiveStr::Ascii("red"),
        dictgen::InsensitiveStr::Ascii("rend"),
        dictgen::InsensitiveStr::Ascii("res"),
        dictgen::InsensitiveStr::Ascii("ring"),
        dictgen::InsensitiveStr::Ascii("rm"),
        dictgen::InsensitiveStr::Ascii("rmed"),
        dictgen::InsensitiveStr::Ascii("rming"),
        dictgen::InsensitiveStr::Ascii("rms"),
        dictgen::InsensitiveStr::Ascii("rnd"),
        dictgen::InsensitiveStr::Ascii("rne"),
        dictgen::InsensitiveStr::Ascii("rnes"),
        dictgen::InsensitiveStr::Ascii("rnig"),
        dictgen::InsensitiveStr::Ascii("rnn"),
        dictgen::InsensitiveStr::Ascii("rnned"),
        dictgen::InsensitiveStr::Ascii("rnning"),
        dictgen::InsensitiveStr::Ascii("rs"),
        dictgen::InsensitiveStr::Ascii("rsn"),
        dictgen::InsensitiveStr::Ascii("tning"),
    ],
    values: &[
        &["return"],
        &["return", "retune"],
        &["returned"],
        &["returned"],
        &["returns"],
        &["returns"],
        &["return"],
        &["return"],
        &["returned"],
        &["returned"],
        &["returns"],
        &["returning"],
        &["return"],
        &["returned"],
        &["returning"],
        &["returns"],
        &["returned"],
        &["return", "returned"],
        &["returns"],
        &["returning"],
        &["return"],
        &["returned"],
        &["returning"],
        &["returns"],
        &["returns"],
        &["returning"],
    ],
    range: 1..=6,
};

static WORD_RETS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RETS_CHILDREN),
    value: None,
};

pub static WORD_RETS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("art"),
        dictgen::InsensitiveStr::Ascii("arts"),
    ],
    values: &[&["restart"], &["restarts"]],
    range: 3..=4,
};

static WORD_RETR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_RETR_CHILDREN),
    value: None,
};

static WORD_RETR_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_RETRA_NODE),
    None,
    None,
    None,
    Some(&WORD_RETRE_NODE),
    None,
    None,
    None,
    Some(&WORD_RETRI_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_RETRN_NODE),
    Some(&WORD_RETRO_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_RETRU_NODE),
    Some(&WORD_RETRV_NODE),
    None,
    None,
    None,
    None,
];

static WORD_RETRV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RETRV_CHILDREN),
    value: None,
};

pub static WORD_RETRV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ieve"),
        dictgen::InsensitiveStr::Ascii("ieved"),
        dictgen::InsensitiveStr::Ascii("iever"),
        dictgen::InsensitiveStr::Ascii("ievers"),
        dictgen::InsensitiveStr::Ascii("ieves"),
    ],
    values: &[
        &["retrieve"],
        &["retrieved"],
        &["retriever"],
        &["retrievers"],
        &["retrieves"],
    ],
    range: 4..=6,
};

static WORD_RETRU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RETRU_CHILDREN),
    value: None,
};

pub static WORD_RETRU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("bution"),
        dictgen::InsensitiveStr::Ascii("n"),
        dictgen::InsensitiveStr::Ascii("ned"),
        dictgen::InsensitiveStr::Ascii("ns"),
        dictgen::InsensitiveStr::Ascii("rns"),
    ],
    values: &[
        &["retribution"],
        &["return"],
        &["returned"],
        &["returns"],
        &["returns"],
    ],
    range: 1..=6,
};

static WORD_RETRO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RETRO_CHILDREN),
    value: None,
};

pub static WORD_RETRO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("activelly"),
        dictgen::InsensitiveStr::Ascii("activily"),
        dictgen::InsensitiveStr::Ascii("activley"),
        dictgen::InsensitiveStr::Ascii("activly"),
        dictgen::InsensitiveStr::Ascii("bution"),
        dictgen::InsensitiveStr::Ascii("catively"),
        dictgen::InsensitiveStr::Ascii("sepct"),
        dictgen::InsensitiveStr::Ascii("spekt"),
    ],
    values: &[
        &["retroactively"],
        &["retroactively"],
        &["retroactively"],
        &["retroactively"],
        &["retribution"],
        &["retroactively"],
        &["retrospect"],
        &["retrospect"],
    ],
    range: 5..=9,
};

static WORD_RETRN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RETRN_CHILDREN),
    value: Some(&["return"]),
};

pub static WORD_RETRN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("s"),
    ],
    values: &[&["returned"], &["returns"]],
    range: 1..=2,
};

static WORD_RETRI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RETRI_CHILDREN),
    value: None,
};

pub static WORD_RETRI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("bucion"),
        dictgen::InsensitiveStr::Ascii("buito"),
        dictgen::InsensitiveStr::Ascii("buiton"),
        dictgen::InsensitiveStr::Ascii("butioon"),
        dictgen::InsensitiveStr::Ascii("butivo"),
        dictgen::InsensitiveStr::Ascii("bvtion"),
        dictgen::InsensitiveStr::Ascii("ct"),
        dictgen::InsensitiveStr::Ascii("cted"),
        dictgen::InsensitiveStr::Ascii("ebe"),
        dictgen::InsensitiveStr::Ascii("ece"),
        dictgen::InsensitiveStr::Ascii("eces"),
        dictgen::InsensitiveStr::Ascii("ev"),
        dictgen::InsensitiveStr::Ascii("eveds"),
        dictgen::InsensitiveStr::Ascii("vable"),
        dictgen::InsensitiveStr::Ascii("val"),
        dictgen::InsensitiveStr::Ascii("ve"),
        dictgen::InsensitiveStr::Ascii("ved"),
        dictgen::InsensitiveStr::Ascii("ves"),
        dictgen::InsensitiveStr::Ascii("ving"),
    ],
    values: &[
        &["retribution"],
        &["retribution"],
        &["retribution"],
        &["retribution"],
        &["retribution"],
        &["retribution"],
        &["restrict"],
        &["restricted"],
        &["retrieve"],
        &["retrieve"],
        &["retrieves"],
        &["retrieve"],
        &["retrieved"],
        &["retrievable"],
        &["retrieval", "retrial"],
        &["retrieve"],
        &["retrieved"],
        &["retrieves"],
        &["retrieving"],
    ],
    range: 2..=7,
};

static WORD_RETRE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RETRE_CHILDREN),
    value: None,
};

pub static WORD_RETRE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("bution"),
        dictgen::InsensitiveStr::Ascii("evable"),
        dictgen::InsensitiveStr::Ascii("eval"),
        dictgen::InsensitiveStr::Ascii("eve"),
        dictgen::InsensitiveStr::Ascii("eved"),
        dictgen::InsensitiveStr::Ascii("eves"),
        dictgen::InsensitiveStr::Ascii("eving"),
        dictgen::InsensitiveStr::Ascii("ivable"),
        dictgen::InsensitiveStr::Ascii("ival"),
        dictgen::InsensitiveStr::Ascii("ive"),
        dictgen::InsensitiveStr::Ascii("ived"),
        dictgen::InsensitiveStr::Ascii("ives"),
        dictgen::InsensitiveStr::Ascii("iving"),
        dictgen::InsensitiveStr::Ascii("vable"),
        dictgen::InsensitiveStr::Ascii("val"),
        dictgen::InsensitiveStr::Ascii("ve"),
        dictgen::InsensitiveStr::Ascii("ved"),
        dictgen::InsensitiveStr::Ascii("ves"),
        dictgen::InsensitiveStr::Ascii("vier"),
        dictgen::InsensitiveStr::Ascii("ving"),
    ],
    values: &[
        &["retribution"],
        &["retrievable"],
        &["retrieval"],
        &["retrieve"],
        &["retrieved"],
        &["retrieves"],
        &["retrieving"],
        &["retrievable"],
        &["retrieval"],
        &["retrieve"],
        &["retrieved"],
        &["retrieves"],
        &["retrieving"],
        &["retrievable"],
        &["retrieval"],
        &["retrieve"],
        &["retrieved"],
        &["retrieves"],
        &["retriever"],
        &["retrieving"],
    ],
    range: 2..=6,
};

static WORD_RETRA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RETRA_CHILDREN),
    value: None,
};

pub static WORD_RETRA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("nser"),
        dictgen::InsensitiveStr::Ascii("nsferd"),
        dictgen::InsensitiveStr::Ascii("nsfered"),
        dictgen::InsensitiveStr::Ascii("nsfering"),
        dictgen::InsensitiveStr::Ascii("nsferrd"),
        dictgen::InsensitiveStr::Ascii("nsfert"),
        dictgen::InsensitiveStr::Ascii("nsmited"),
        dictgen::InsensitiveStr::Ascii("nsmition"),
    ],
    values: &[
        &["retransfer"],
        &["retransferred"],
        &["retransferred"],
        &["retransferring"],
        &["retransferred"],
        &["retransfer", "retransferred"],
        &["retransmitted"],
        &["retransmission"],
    ],
    range: 4..=8,
};

static WORD_RETQ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RETQ_CHILDREN),
    value: None,
};

pub static WORD_RETQ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("uirement"),
        dictgen::InsensitiveStr::Ascii("uirements"),
        dictgen::InsensitiveStr::Ascii("uireseek"),
        dictgen::InsensitiveStr::Ascii("uiresgpos"),
        dictgen::InsensitiveStr::Ascii("uiresgsub"),
        dictgen::InsensitiveStr::Ascii("uiressl"),
    ],
    values: &[
        &["requirement"],
        &["requirements"],
        &["requireseek"],
        &["requiresgpos"],
        &["requiresgsub"],
        &["requiressl"],
    ],
    range: 7..=9,
};

static WORD_RETP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RETP_CHILDREN),
    value: None,
};

pub static WORD_RETP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("resenting")],
    values: &[&["representing"]],
    range: 9..=9,
};

static WORD_RETO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RETO_CHILDREN),
    value: None,
};

pub static WORD_RETO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ractively"),
        dictgen::InsensitiveStr::Ascii("re"),
        dictgen::InsensitiveStr::Ascii("red"),
        dictgen::InsensitiveStr::Ascii("res"),
        dictgen::InsensitiveStr::Ascii("ric"),
        dictgen::InsensitiveStr::Ascii("rical"),
        dictgen::InsensitiveStr::Ascii("ring"),
        dictgen::InsensitiveStr::Ascii("urned"),
    ],
    values: &[
        &["retroactively"],
        &["restore"],
        &["restored"],
        &["restores"],
        &["rhetoric"],
        &["rhetorical"],
        &["restoring"],
        &["returned"],
    ],
    range: 2..=9,
};

static WORD_RETI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RETI_CHILDREN),
    value: None,
};

pub static WORD_RETI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("erment"),
        dictgen::InsensitiveStr::Ascii("eve"),
        dictgen::InsensitiveStr::Ascii("eved"),
        dictgen::InsensitiveStr::Ascii("eves"),
        dictgen::InsensitiveStr::Ascii("eving"),
        dictgen::InsensitiveStr::Ascii("new"),
        dictgen::InsensitiveStr::Ascii("rase"),
        dictgen::InsensitiveStr::Ascii("rbution"),
        dictgen::InsensitiveStr::Ascii("reds"),
        dictgen::InsensitiveStr::Ascii("reus"),
        dictgen::InsensitiveStr::Ascii("reve"),
        dictgen::InsensitiveStr::Ascii("reved"),
        dictgen::InsensitiveStr::Ascii("rever"),
        dictgen::InsensitiveStr::Ascii("revers"),
        dictgen::InsensitiveStr::Ascii("reves"),
        dictgen::InsensitiveStr::Ascii("reving"),
        dictgen::InsensitiveStr::Ascii("rned"),
    ],
    values: &[
        &["retirement"],
        &["retrieve"],
        &["retrieved"],
        &["retrieves"],
        &["retrieving"],
        &["retinue"],
        &["retires"],
        &["retribution"],
        &["retires"],
        &["retires"],
        &["retrieve"],
        &["retrieved"],
        &["retriever"],
        &["retrievers"],
        &["retrieves"],
        &["retrieving"],
        &["returned"],
    ],
    range: 3..=7,
};

static WORD_RETH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RETH_CHILDREN),
    value: None,
};

pub static WORD_RETH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("er"),
        dictgen::InsensitiveStr::Ascii("oric"),
        dictgen::InsensitiveStr::Ascii("orical"),
    ],
    values: &[&["rather"], &["rhetoric"], &["rhetorical"]],
    range: 2..=6,
};

static WORD_RETE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RETE_CHILDREN),
    value: None,
};

pub static WORD_RETE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("river"),
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("tting"),
    ],
    values: &[
        &["retriever"],
        &["reset", "retest"],
        &["resetting", "retesting"],
    ],
    range: 1..=5,
};

static WORD_RETC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RETC_CHILDREN),
    value: None,
};

pub static WORD_RETC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ieve"),
        dictgen::InsensitiveStr::Ascii("ieved"),
        dictgen::InsensitiveStr::Ascii("iever"),
        dictgen::InsensitiveStr::Ascii("ievers"),
        dictgen::InsensitiveStr::Ascii("ieves"),
    ],
    values: &[
        &["receive", "retrieve"],
        &["received", "retrieved"],
        &["receiver", "retriever"],
        &["receivers", "retrievers"],
        &["retrieves", "receives"],
    ],
    range: 4..=6,
};

static WORD_RETA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RETA_CHILDREN),
    value: None,
};

pub static WORD_RETA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ilate"),
        dictgen::InsensitiveStr::Ascii("ilation"),
        dictgen::InsensitiveStr::Ascii("iles"),
        dictgen::InsensitiveStr::Ascii("laite"),
        dictgen::InsensitiveStr::Ascii("liaton"),
        dictgen::InsensitiveStr::Ascii("lier"),
        dictgen::InsensitiveStr::Ascii("liers"),
        dictgen::InsensitiveStr::Ascii("litated"),
        dictgen::InsensitiveStr::Ascii("litation"),
        dictgen::InsensitiveStr::Ascii("ngles"),
        dictgen::InsensitiveStr::Ascii("nslate"),
        dictgen::InsensitiveStr::Ascii("rdathon"),
        dictgen::InsensitiveStr::Ascii("rdating"),
        dictgen::InsensitiveStr::Ascii("rdatron"),
        dictgen::InsensitiveStr::Ascii("rt"),
        dictgen::InsensitiveStr::Ascii("rtation"),
        dictgen::InsensitiveStr::Ascii("rted"),
        dictgen::InsensitiveStr::Ascii("rting"),
    ],
    values: &[
        &["retaliate"],
        &["retaliation"],
        &["retailers"],
        &["retaliate"],
        &["retaliation"],
        &["retailer"],
        &["retailers"],
        &["retaliated"],
        &["retaliation"],
        &["rectangles"],
        &["retranslate"],
        &["retardation"],
        &["retardation"],
        &["retardation"],
        &["restart"],
        &["retardation"],
        &["restarted"],
        &["restarting"],
    ],
    range: 2..=8,
};

static WORD_RES_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_RES_CHILDREN),
    value: None,
};

static WORD_RES_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_RESA_NODE),
    None,
    Some(&WORD_RESC_NODE),
    None,
    Some(&WORD_RESE_NODE),
    None,
    Some(&WORD_RESG_NODE),
    None,
    Some(&WORD_RESI_NODE),
    None,
    None,
    Some(&WORD_RESL_NODE),
    Some(&WORD_RESM_NODE),
    None,
    Some(&WORD_RESO_NODE),
    Some(&WORD_RESP_NODE),
    Some(&WORD_RESQ_NODE),
    Some(&WORD_RESR_NODE),
    Some(&WORD_RESS_NODE),
    Some(&WORD_REST_NODE),
    Some(&WORD_RESU_NODE),
    None,
    None,
    None,
    Some(&WORD_RESY_NODE),
    None,
];

static WORD_RESY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RESY_CHILDREN),
    value: None,
};

pub static WORD_RESY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("cn")],
    values: &[&["resync"]],
    range: 2..=2,
};

static WORD_RESU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RESU_CHILDREN),
    value: None,
};

pub static WORD_RESU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("able"),
        dictgen::InsensitiveStr::Ascii("ables"),
        dictgen::InsensitiveStr::Ascii("bstituion"),
        dictgen::InsensitiveStr::Ascii("ced"),
        dictgen::InsensitiveStr::Ascii("ces"),
        dictgen::InsensitiveStr::Ascii("ction"),
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("ilt"),
        dictgen::InsensitiveStr::Ascii("ilted"),
        dictgen::InsensitiveStr::Ascii("ilting"),
        dictgen::InsensitiveStr::Ascii("ilts"),
        dictgen::InsensitiveStr::Ascii("l"),
        dictgen::InsensitiveStr::Ascii("led"),
        dictgen::InsensitiveStr::Ascii("ling"),
        dictgen::InsensitiveStr::Ascii("llt"),
        dictgen::InsensitiveStr::Ascii("lotion"),
        dictgen::InsensitiveStr::Ascii("lsets"),
        dictgen::InsensitiveStr::Ascii("lst"),
        dictgen::InsensitiveStr::Ascii("ltion"),
        dictgen::InsensitiveStr::Ascii("ltions"),
        dictgen::InsensitiveStr::Ascii("ltung"),
        dictgen::InsensitiveStr::Ascii("lution"),
        dictgen::InsensitiveStr::Ascii("mbmitting"),
        dictgen::InsensitiveStr::Ascii("mitted"),
        dictgen::InsensitiveStr::Ascii("mt"),
        dictgen::InsensitiveStr::Ascii("orce"),
        dictgen::InsensitiveStr::Ascii("orced"),
        dictgen::InsensitiveStr::Ascii("orces"),
        dictgen::InsensitiveStr::Ascii("orcing"),
        dictgen::InsensitiveStr::Ascii("rce"),
        dictgen::InsensitiveStr::Ascii("rced"),
        dictgen::InsensitiveStr::Ascii("rces"),
        dictgen::InsensitiveStr::Ascii("rcing"),
        dictgen::InsensitiveStr::Ascii("recting"),
        dictgen::InsensitiveStr::Ascii("rreccion"),
        dictgen::InsensitiveStr::Ascii("rrecion"),
        dictgen::InsensitiveStr::Ascii("rrektion"),
        dictgen::InsensitiveStr::Ascii("rse"),
        dictgen::InsensitiveStr::Ascii("rsive"),
        dictgen::InsensitiveStr::Ascii("rsively"),
        dictgen::InsensitiveStr::Ascii("se"),
        dictgen::InsensitiveStr::Ascii("sed"),
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("tl"),
        dictgen::InsensitiveStr::Ascii("tls"),
        dictgen::InsensitiveStr::Ascii("ts"),
    ],
    values: &[
        &["reusable"],
        &["reusables"],
        &["resubstitution"],
        &["rescued"],
        &["rescues"],
        &["reduction"],
        &["reuse", "rescue"],
        &["reused", "rescued", "resumed"],
        &["result"],
        &["resulted"],
        &["resulting"],
        &["results"],
        &["result"],
        &["resulted", "resumed"],
        &["resulting"],
        &["result"],
        &["resolution"],
        &["resultsets"],
        &["results"],
        &["resolution"],
        &["resolutions"],
        &["resulting"],
        &["resolution"],
        &["resubmitting"],
        &["resubmitted"],
        &["resume"],
        &["resource"],
        &["resourced"],
        &["resources"],
        &["resourcing"],
        &["resource"],
        &["resourced"],
        &["resources"],
        &["resourcing"],
        &["resurrecting"],
        &["resurrection"],
        &["resurrection"],
        &["resurrection"],
        &["recurse", "resource"],
        &["recursive", "resourceful"],
        &["recursively"],
        &["reuse"],
        &["reused", "refused", "resumed"],
        &["result"],
        &["result"],
        &["results"],
        &["results"],
    ],
    range: 1..=9,
};

static WORD_REST_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_REST_CHILDREN),
    value: None,
};

static WORD_REST_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_RESTA_NODE),
    None,
    None,
    None,
    Some(&WORD_RESTE_NODE),
    None,
    None,
    None,
    Some(&WORD_RESTI_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_RESTO_NODE),
    None,
    None,
    Some(&WORD_RESTR_NODE),
    None,
    None,
    Some(&WORD_RESTU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_RESTU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RESTU_CHILDREN),
    value: None,
};

pub static WORD_RESTU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("arant"),
        dictgen::InsensitiveStr::Ascii("arants"),
        dictgen::InsensitiveStr::Ascii("cturing"),
        dictgen::InsensitiveStr::Ascii("rant"),
        dictgen::InsensitiveStr::Ascii("rants"),
        dictgen::InsensitiveStr::Ascii("raunt"),
        dictgen::InsensitiveStr::Ascii("raunts"),
        dictgen::InsensitiveStr::Ascii("rcturation"),
        dictgen::InsensitiveStr::Ascii("rcture"),
        dictgen::InsensitiveStr::Ascii("rctured"),
        dictgen::InsensitiveStr::Ascii("rctures"),
        dictgen::InsensitiveStr::Ascii("rcturing"),
        dictgen::InsensitiveStr::Ascii("rn"),
        dictgen::InsensitiveStr::Ascii("rns"),
    ],
    values: &[
        &["restaurant"],
        &["restaurants"],
        &["restructuring"],
        &["restaurant"],
        &["restaurants"],
        &["restaurant"],
        &["restaurants"],
        &["restructuration"],
        &["restructure"],
        &["restructured"],
        &["restructures"],
        &["restructuring"],
        &["return", "returns"],
        &["returns"],
    ],
    range: 2..=10,
};

static WORD_RESTR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RESTR_CHILDREN),
    value: None,
};

pub static WORD_RESTR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aind"),
        dictgen::InsensitiveStr::Ascii("aing"),
        dictgen::InsensitiveStr::Ascii("ainig"),
        dictgen::InsensitiveStr::Ascii("ainted"),
        dictgen::InsensitiveStr::Ascii("ainting"),
        dictgen::InsensitiveStr::Ascii("ait"),
        dictgen::InsensitiveStr::Ascii("aunt"),
        dictgen::InsensitiveStr::Ascii("aunts"),
        dictgen::InsensitiveStr::Ascii("cited"),
        dictgen::InsensitiveStr::Ascii("citions"),
        dictgen::InsensitiveStr::Ascii("cted"),
        dictgen::InsensitiveStr::Ascii("cting"),
        dictgen::InsensitiveStr::Ascii("cuture"),
        dictgen::InsensitiveStr::Ascii("ective"),
        dictgen::InsensitiveStr::Ascii("iant"),
        dictgen::InsensitiveStr::Ascii("iccion"),
        dictgen::InsensitiveStr::Ascii("iced"),
        dictgen::InsensitiveStr::Ascii("icing"),
        dictgen::InsensitiveStr::Ascii("icion"),
        dictgen::InsensitiveStr::Ascii("icitng"),
        dictgen::InsensitiveStr::Ascii("iciton"),
        dictgen::InsensitiveStr::Ascii("icitons"),
        dictgen::InsensitiveStr::Ascii("icitve"),
        dictgen::InsensitiveStr::Ascii("icive"),
        dictgen::InsensitiveStr::Ascii("ics"),
        dictgen::InsensitiveStr::Ascii("icte"),
        dictgen::InsensitiveStr::Ascii("icteds"),
        dictgen::InsensitiveStr::Ascii("icters"),
        dictgen::InsensitiveStr::Ascii("ictes"),
        dictgen::InsensitiveStr::Ascii("ictie"),
        dictgen::InsensitiveStr::Ascii("ictied"),
        dictgen::InsensitiveStr::Ascii("ictifs"),
        dictgen::InsensitiveStr::Ascii("ictins"),
        dictgen::InsensitiveStr::Ascii("ictios"),
        dictgen::InsensitiveStr::Ascii("ictivo"),
        dictgen::InsensitiveStr::Ascii("icton"),
        dictgen::InsensitiveStr::Ascii("ictons"),
        dictgen::InsensitiveStr::Ascii("iktion"),
        dictgen::InsensitiveStr::Ascii("iktive"),
        dictgen::InsensitiveStr::Ascii("ittive"),
        dictgen::InsensitiveStr::Ascii("oing"),
        dictgen::InsensitiveStr::Ascii("ucted"),
        dictgen::InsensitiveStr::Ascii("ucting"),
        dictgen::InsensitiveStr::Ascii("uction"),
    ],
    values: &[
        &["restrained"],
        &["restraining"],
        &["restraining"],
        &["restrained"],
        &["restraining"],
        &["restraint"],
        &["restraint", "restaurant"],
        &["restaurants", "restraints"],
        &["restricted"],
        &["restriction"],
        &["restricted"],
        &["restarting"],
        &["restructure"],
        &["restrictive"],
        &["restraint"],
        &["restriction"],
        &["restricted"],
        &["restricting"],
        &["restriction"],
        &["restricting"],
        &["restrictions"],
        &["restrictions"],
        &["restrictive"],
        &["restrictive"],
        &["restricts"],
        &["restrictive"],
        &["restricts"],
        &["restricts"],
        &["restricts"],
        &["restrictive"],
        &["restrictive"],
        &["restricts"],
        &["restricts"],
        &["restricts"],
        &["restriction"],
        &["restriction"],
        &["restricts"],
        &["restriction"],
        &["restrictive"],
        &["restrictive"],
        &["restoring"],
        &["restricted", "restructured"],
        &["restricting", "restructuring"],
        &["restriction"],
    ],
    range: 3..=7,
};

static WORD_RESTO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RESTO_CHILDREN),
    value: None,
};

pub static WORD_RESTO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ding"),
        dictgen::InsensitiveStr::Ascii("iring"),
        dictgen::InsensitiveStr::Ascii("r"),
        dictgen::InsensitiveStr::Ascii("rani"),
        dictgen::InsensitiveStr::Ascii("rarion"),
        dictgen::InsensitiveStr::Ascii("rated"),
        dictgen::InsensitiveStr::Ascii("rating"),
        dictgen::InsensitiveStr::Ascii("rd"),
        dictgen::InsensitiveStr::Ascii("reable"),
        dictgen::InsensitiveStr::Ascii("reble"),
        dictgen::InsensitiveStr::Ascii("reing"),
        dictgen::InsensitiveStr::Ascii("rs"),
        dictgen::InsensitiveStr::Ascii("rting"),
        dictgen::InsensitiveStr::Ascii("uration"),
    ],
    values: &[
        &["restoring"],
        &["restoring"],
        &["restore"],
        &["restoration"],
        &["restoration"],
        &["restored"],
        &["restoration"],
        &["restored"],
        &["restorable"],
        &["restorable"],
        &["restoring"],
        &["restores"],
        &["restarting"],
        &["restoration"],
    ],
    range: 1..=7,
};

static WORD_RESTI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RESTI_CHILDREN),
    value: None,
};

pub static WORD_RESTI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cted"),
        dictgen::InsensitiveStr::Ascii("ctive"),
        dictgen::InsensitiveStr::Ascii("rcted"),
        dictgen::InsensitiveStr::Ascii("rction"),
        dictgen::InsensitiveStr::Ascii("rctions"),
        dictgen::InsensitiveStr::Ascii("rcts"),
        dictgen::InsensitiveStr::Ascii("re"),
        dictgen::InsensitiveStr::Ascii("red"),
        dictgen::InsensitiveStr::Ascii("rer"),
        dictgen::InsensitiveStr::Ascii("res"),
        dictgen::InsensitiveStr::Ascii("ring"),
    ],
    values: &[
        &["restricted"],
        &["restrictive"],
        &["restricted"],
        &["restriction"],
        &["restrictions"],
        &["restricts"],
        &["restore"],
        &["restored"],
        &["restorer"],
        &["restores"],
        &["restoring"],
    ],
    range: 2..=7,
};

static WORD_RESTE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RESTE_CHILDREN),
    value: None,
};

pub static WORD_RESTE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("raunt"),
        dictgen::InsensitiveStr::Ascii("raunts"),
        dictgen::InsensitiveStr::Ascii("s"),
        dictgen::InsensitiveStr::Ascii("sting"),
    ],
    values: &[
        &["restaurant"],
        &["restaurants"],
        &["reset"],
        &["retesting"],
    ],
    range: 1..=6,
};

static WORD_RESTA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RESTA_CHILDREN),
    value: None,
};

pub static WORD_RESTA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("nti"),
        dictgen::InsensitiveStr::Ascii("rant"),
        dictgen::InsensitiveStr::Ascii("rants"),
        dictgen::InsensitiveStr::Ascii("raunt"),
        dictgen::InsensitiveStr::Ascii("raunteur"),
        dictgen::InsensitiveStr::Ascii("raunteurs"),
        dictgen::InsensitiveStr::Ascii("raunts"),
        dictgen::InsensitiveStr::Ascii("ruant"),
        dictgen::InsensitiveStr::Ascii("ruants"),
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("tting"),
        dictgen::InsensitiveStr::Ascii("urantes"),
        dictgen::InsensitiveStr::Ascii("uration"),
        dictgen::InsensitiveStr::Ascii("uraunt"),
        dictgen::InsensitiveStr::Ascii("uraunts"),
        dictgen::InsensitiveStr::Ascii("urent"),
        dictgen::InsensitiveStr::Ascii("urents"),
        dictgen::InsensitiveStr::Ascii("uring"),
        dictgen::InsensitiveStr::Ascii("urnad"),
        dictgen::InsensitiveStr::Ascii("urnat"),
    ],
    values: &[
        &["restarting"],
        &["restaurant"],
        &["restaurants"],
        &["restaurant"],
        &["restauranteur"],
        &["restauranteurs"],
        &["restaurants"],
        &["restaurant"],
        &["restaurants"],
        &["restart"],
        &["restarting", "restating"],
        &["restaurants"],
        &["restoration"],
        &["restaurant"],
        &["restaurants"],
        &["restaurant"],
        &["restaurants"],
        &["restarting"],
        &["restaurant"],
        &["restaurant"],
    ],
    range: 1..=9,
};

static WORD_RESS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RESS_CHILDREN),
    value: None,
};

pub static WORD_RESS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("apee"),
        dictgen::InsensitiveStr::Ascii("emblance"),
        dictgen::InsensitiveStr::Ascii("emble"),
        dictgen::InsensitiveStr::Ascii("embled"),
        dictgen::InsensitiveStr::Ascii("emblence"),
        dictgen::InsensitiveStr::Ascii("embling"),
        dictgen::InsensitiveStr::Ascii("emle"),
        dictgen::InsensitiveStr::Ascii("et"),
        dictgen::InsensitiveStr::Ascii("eted"),
        dictgen::InsensitiveStr::Ascii("ets"),
        dictgen::InsensitiveStr::Ascii("etting"),
        dictgen::InsensitiveStr::Ascii("its"),
        dictgen::InsensitiveStr::Ascii("ize"),
        dictgen::InsensitiveStr::Ascii("izes"),
        dictgen::InsensitiveStr::Ascii("ource"),
        dictgen::InsensitiveStr::Ascii("ourced"),
        dictgen::InsensitiveStr::Ascii("ources"),
        dictgen::InsensitiveStr::Ascii("ourcing"),
        dictgen::InsensitiveStr::Ascii("surecting"),
        dictgen::InsensitiveStr::Ascii("triction"),
        dictgen::InsensitiveStr::Ascii("trictions"),
        dictgen::InsensitiveStr::Ascii("ult"),
        dictgen::InsensitiveStr::Ascii("urect"),
        dictgen::InsensitiveStr::Ascii("urected"),
        dictgen::InsensitiveStr::Ascii("urecting"),
        dictgen::InsensitiveStr::Ascii("urection"),
        dictgen::InsensitiveStr::Ascii("urects"),
        dictgen::InsensitiveStr::Ascii("urrect"),
        dictgen::InsensitiveStr::Ascii("urrected"),
        dictgen::InsensitiveStr::Ascii("urrecting"),
        dictgen::InsensitiveStr::Ascii("urrection"),
        dictgen::InsensitiveStr::Ascii("urrects"),
    ],
    values: &[
        &["recipe"],
        &["resemblance"],
        &["reassemble", "resemble"],
        &["reassembled", "resembled"],
        &["resemblance"],
        &["resembling"],
        &["resemble"],
        &["reset"],
        &["reset"],
        &["resets"],
        &["resetting"],
        &["resists"],
        &["resize"],
        &["resizes"],
        &["resource"],
        &["resourced"],
        &["resources"],
        &["resourcing"],
        &["resurrecting"],
        &["restriction"],
        &["restrictions"],
        &["result"],
        &["resurrect"],
        &["resurrected"],
        &["resurrecting"],
        &["resurrection"],
        &["resurrects"],
        &["resurrect"],
        &["resurrected"],
        &["resurrecting"],
        &["resurrection"],
        &["resurrects"],
    ],
    range: 2..=9,
};

static WORD_RESR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RESR_CHILDREN),
    value: None,
};

pub static WORD_RESR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ouce"),
        dictgen::InsensitiveStr::Ascii("ouced"),
        dictgen::InsensitiveStr::Ascii("ouces"),
        dictgen::InsensitiveStr::Ascii("oucing"),
        dictgen::InsensitiveStr::Ascii("ved"),
    ],
    values: &[
        &["resource"],
        &["resourced"],
        &["resources"],
        &["resourcing"],
        &["reserved"],
    ],
    range: 3..=6,
};

static WORD_RESQ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RESQ_CHILDREN),
    value: None,
};

pub static WORD_RESQ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("uest")],
    values: &[&["request"]],
    range: 4..=4,
};

static WORD_RESP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_RESP_CHILDREN),
    value: None,
};

static WORD_RESP_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_RESPA_NODE),
    None,
    None,
    None,
    Some(&WORD_RESPE_NODE),
    None,
    None,
    None,
    Some(&WORD_RESPI_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_RESPN_NODE),
    Some(&WORD_RESPO_NODE),
    Some(&WORD_RESPP_NODE),
    None,
    Some(&WORD_RESPR_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_RESPW_NODE),
    None,
    None,
    None,
];

static WORD_RESPW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RESPW_CHILDREN),
    value: None,
};

pub static WORD_RESPW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("an"),
        dictgen::InsensitiveStr::Ascii("aned"),
        dictgen::InsensitiveStr::Ascii("aning"),
        dictgen::InsensitiveStr::Ascii("ans"),
    ],
    values: &[&["respawn"], &["respawned"], &["respawning"], &["respawns"]],
    range: 2..=5,
};

static WORD_RESPR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RESPR_CHILDREN),
    value: None,
};

pub static WORD_RESPR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("esent"),
        dictgen::InsensitiveStr::Ascii("esentation"),
        dictgen::InsensitiveStr::Ascii("esentational"),
        dictgen::InsensitiveStr::Ascii("esentations"),
        dictgen::InsensitiveStr::Ascii("esented"),
        dictgen::InsensitiveStr::Ascii("esenting"),
        dictgen::InsensitiveStr::Ascii("esents"),
        dictgen::InsensitiveStr::Ascii("iatory"),
    ],
    values: &[
        &["represent"],
        &["representation"],
        &["representational"],
        &["representations"],
        &["represented"],
        &["representing"],
        &["represents"],
        &["respiratory"],
    ],
    range: 5..=12,
};

static WORD_RESPP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RESPP_CHILDREN),
    value: None,
};

pub static WORD_RESPP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("onse"),
        dictgen::InsensitiveStr::Ascii("onses"),
    ],
    values: &[&["response"], &["responses"]],
    range: 4..=5,
};

static WORD_RESPO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_RESPO_CHILDREN),
    value: None,
};

static WORD_RESPO_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    None,
    Some(&WORD_RESPOD_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_RESPON_NODE),
    None,
    None,
    None,
    Some(&WORD_RESPOR_NODE),
    Some(&WORD_RESPOS_NODE),
    Some(&WORD_RESPOT_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_RESPOT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RESPOT_CHILDREN),
    value: None,
};

pub static WORD_RESPOT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("ing"),
    ],
    values: &[&["reposted"], &["reposting"]],
    range: 2..=3,
};

static WORD_RESPOS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RESPOS_CHILDREN),
    value: None,
};

pub static WORD_RESPOS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("ibility"),
        dictgen::InsensitiveStr::Ascii("ible"),
        dictgen::InsensitiveStr::Ascii("iblity"),
        dictgen::InsensitiveStr::Ascii("itories"),
        dictgen::InsensitiveStr::Ascii("itory"),
        dictgen::InsensitiveStr::Ascii("ive"),
        dictgen::InsensitiveStr::Ascii("iveness"),
        dictgen::InsensitiveStr::Ascii("ne"),
        dictgen::InsensitiveStr::Ascii("nes"),
    ],
    values: &[
        &["response"],
        &["responses"],
        &["responsibility"],
        &["responsible"],
        &["responsibility"],
        &["repositories"],
        &["repository"],
        &["responsive"],
        &["responsiveness"],
        &["response"],
        &["responses"],
    ],
    range: 1..=7,
};

static WORD_RESPOR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RESPOR_CHILDREN),
    value: None,
};

pub static WORD_RESPOR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("atory")],
    values: &[&["respiratory"]],
    range: 5..=5,
};

static WORD_RESPON_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_RESPON_CHILDREN),
    value: None,
};

static WORD_RESPON_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    Some(&WORD_RESPONC_NODE),
    Some(&WORD_RESPOND_NODE),
    Some(&WORD_RESPONE_NODE),
    None,
    None,
    None,
    Some(&WORD_RESPONI_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_RESPONN_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_RESPONS_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_RESPONS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RESPONS_CHILDREN),
    value: Some(&["response", "respond"]),
};

pub static WORD_RESPONS_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("abile"),
            dictgen::InsensitiveStr::Ascii("abilities"),
            dictgen::InsensitiveStr::Ascii("ability"),
            dictgen::InsensitiveStr::Ascii("able"),
            dictgen::InsensitiveStr::Ascii("ably"),
            dictgen::InsensitiveStr::Ascii("aveis"),
            dictgen::InsensitiveStr::Ascii("bile"),
            dictgen::InsensitiveStr::Ascii("bilty"),
            dictgen::InsensitiveStr::Ascii("bily"),
            dictgen::InsensitiveStr::Ascii("d"),
            dictgen::InsensitiveStr::Ascii("ebilities"),
            dictgen::InsensitiveStr::Ascii("ed"),
            dictgen::InsensitiveStr::Ascii("er"),
            dictgen::InsensitiveStr::Ascii("ers"),
            dictgen::InsensitiveStr::Ascii("ess"),
            dictgen::InsensitiveStr::Ascii("ibe"),
            dictgen::InsensitiveStr::Ascii("ibel"),
            dictgen::InsensitiveStr::Ascii("ibil"),
            dictgen::InsensitiveStr::Ascii("ibile"),
            dictgen::InsensitiveStr::Ascii("ibilies"),
            dictgen::InsensitiveStr::Ascii("ibilites"),
            dictgen::InsensitiveStr::Ascii("ibilitys"),
            dictgen::InsensitiveStr::Ascii("ibiliy"),
            dictgen::InsensitiveStr::Ascii("ibillities"),
            dictgen::InsensitiveStr::Ascii("ibillity"),
            dictgen::InsensitiveStr::Ascii("ibilties"),
            dictgen::InsensitiveStr::Ascii("ibilty"),
            dictgen::InsensitiveStr::Ascii("ibily"),
            dictgen::InsensitiveStr::Ascii("ibities"),
            dictgen::InsensitiveStr::Ascii("ibley"),
            dictgen::InsensitiveStr::Ascii("iblities"),
            dictgen::InsensitiveStr::Ascii("iblity"),
            dictgen::InsensitiveStr::Ascii("ibliy"),
            dictgen::InsensitiveStr::Ascii("iblty"),
            dictgen::InsensitiveStr::Ascii("iby"),
            dictgen::InsensitiveStr::Ascii("ile"),
            dictgen::InsensitiveStr::Ascii("ing"),
            dictgen::InsensitiveStr::Ascii("ivle"),
        ],
        values: &[
            &["responsible"],
            &["responsibilities"],
            &["responsibility"],
            &["responsible"],
            &["responsibly"],
            &["responsive"],
            &["responsible"],
            &["responsibly"],
            &["responsibly"],
            &["responds"],
            &["responsibilities"],
            &["responded", "responses"],
            &["responder"],
            &["responders"],
            &["responses"],
            &["responsive", "responsible"],
            &["responsibly"],
            &["responsibly"],
            &["responsible"],
            &["responsibilities"],
            &["responsibilities"],
            &["responsibilities"],
            &["responsibility"],
            &["responsibilities"],
            &["responsibility"],
            &["responsibilities"],
            &["responsibility"],
            &["responsibility"],
            &["responsibilities"],
            &["responsibly"],
            &["responsibilities"],
            &["responsibility"],
            &["responsibly"],
            &["responsibly"],
            &["responsibly"],
            &["responsive"],
            &["responding"],
            &["responsive"],
        ],
        range: 1..=10,
    };

static WORD_RESPONN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RESPONN_CHILDREN),
    value: None,
};

pub static WORD_RESPONN_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[dictgen::InsensitiveStr::Ascii("sibilty")],
        values: &[&["responsibility"]],
        range: 7..=7,
    };

static WORD_RESPONI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RESPONI_CHILDREN),
    value: None,
};

pub static WORD_RESPONI_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("bilities"),
            dictgen::InsensitiveStr::Ascii("ble"),
            dictgen::InsensitiveStr::Ascii("sbilities"),
            dictgen::InsensitiveStr::Ascii("sbility"),
            dictgen::InsensitiveStr::Ascii("sble"),
            dictgen::InsensitiveStr::Ascii("sbly"),
            dictgen::InsensitiveStr::Ascii("sve"),
        ],
        values: &[
            &["responsibilities"],
            &["responsible"],
            &["responsibilities"],
            &["responsibility"],
            &["responsible"],
            &["responsibly"],
            &["responsive"],
        ],
        range: 3..=9,
    };

static WORD_RESPONE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RESPONE_CHILDREN),
    value: Some(&["response", "respond"]),
};

pub static WORD_RESPONE_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("d"),
            dictgen::InsensitiveStr::Ascii("s"),
        ],
        values: &[&["respond"], &["response", "responses"]],
        range: 1..=1,
    };

static WORD_RESPOND_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RESPOND_CHILDREN),
    value: None,
};

pub static WORD_RESPOND_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("as"),
            dictgen::InsensitiveStr::Ascii("e"),
            dictgen::InsensitiveStr::Ascii("endo"),
            dictgen::InsensitiveStr::Ascii("ible"),
            dictgen::InsensitiveStr::Ascii("is"),
            dictgen::InsensitiveStr::Ascii("us"),
        ],
        values: &[
            &["responds"],
            &["respond", "response", "responds", "responded", "responder"],
            &["responded"],
            &["responsible"],
            &["responds"],
            &["responds"],
        ],
        range: 1..=4,
    };

static WORD_RESPONC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RESPONC_CHILDREN),
    value: Some(&["response", "respond"]),
};

pub static WORD_RESPONC_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("e"),
            dictgen::InsensitiveStr::Ascii("es"),
            dictgen::InsensitiveStr::Ascii("ibilities"),
            dictgen::InsensitiveStr::Ascii("ibility"),
            dictgen::InsensitiveStr::Ascii("ible"),
            dictgen::InsensitiveStr::Ascii("ibly"),
            dictgen::InsensitiveStr::Ascii("ive"),
        ],
        values: &[
            &["response"],
            &["response", "responses"],
            &["responsibilities"],
            &["responsibility"],
            &["responsible"],
            &["responsibly"],
            &["responsive"],
        ],
        range: 1..=9,
    };

static WORD_RESPOD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RESPOD_CHILDREN),
    value: None,
};

pub static WORD_RESPOD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("uce")],
    values: &[&["reproduce"]],
    range: 3..=3,
};

static WORD_RESPN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RESPN_CHILDREN),
    value: None,
};

pub static WORD_RESPN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("se"),
        dictgen::InsensitiveStr::Ascii("ses"),
    ],
    values: &[&["response"], &["responses"]],
    range: 2..=3,
};

static WORD_RESPI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RESPI_CHILDREN),
    value: None,
};

pub static WORD_RESPI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ratiory"),
        dictgen::InsensitiveStr::Ascii("ratoy"),
        dictgen::InsensitiveStr::Ascii("ritory"),
        dictgen::InsensitiveStr::Ascii("tatory"),
    ],
    values: &[
        &["respiratory"],
        &["respiratory"],
        &["respiratory"],
        &["respiratory"],
    ],
    range: 5..=7,
};

static WORD_RESPE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RESPE_CHILDREN),
    value: None,
};

pub static WORD_RESPE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("catble"),
        dictgen::InsensitiveStr::Ascii("citve"),
        dictgen::InsensitiveStr::Ascii("citvely"),
        dictgen::InsensitiveStr::Ascii("cive"),
        dictgen::InsensitiveStr::Ascii("cively"),
        dictgen::InsensitiveStr::Ascii("ctabil"),
        dictgen::InsensitiveStr::Ascii("ctabile"),
        dictgen::InsensitiveStr::Ascii("cte"),
        dictgen::InsensitiveStr::Ascii("ctes"),
        dictgen::InsensitiveStr::Ascii("ctfuly"),
        dictgen::InsensitiveStr::Ascii("ctible"),
        dictgen::InsensitiveStr::Ascii("ctifs"),
        dictgen::InsensitiveStr::Ascii("ction"),
        dictgen::InsensitiveStr::Ascii("ctivelly"),
        dictgen::InsensitiveStr::Ascii("ctivily"),
        dictgen::InsensitiveStr::Ascii("ctivley"),
        dictgen::InsensitiveStr::Ascii("ctivly"),
        dictgen::InsensitiveStr::Ascii("ctons"),
        dictgen::InsensitiveStr::Ascii("ctos"),
        dictgen::InsensitiveStr::Ascii("ctuflly"),
        dictgen::InsensitiveStr::Ascii("ctuful"),
        dictgen::InsensitiveStr::Ascii("ctuos"),
        dictgen::InsensitiveStr::Ascii("ktable"),
        dictgen::InsensitiveStr::Ascii("ktive"),
        dictgen::InsensitiveStr::Ascii("ratory"),
        dictgen::InsensitiveStr::Ascii("ritory"),
        dictgen::InsensitiveStr::Ascii("sct"),
        dictgen::InsensitiveStr::Ascii("st"),
    ],
    values: &[
        &["respectable"],
        &["respective"],
        &["respectively"],
        &["respective"],
        &["respectively"],
        &["respectable"],
        &["respectable"],
        &["respective"],
        &["respects"],
        &["respectfully"],
        &["respectable"],
        &["respects"],
        &["respecting"],
        &["respectively"],
        &["respectively"],
        &["respectively"],
        &["respectively"],
        &["respects"],
        &["respects"],
        &["respectfully"],
        &["respectful"],
        &["respects"],
        &["respectable"],
        &["respective"],
        &["respiratory"],
        &["respiratory"],
        &["respects"],
        &["respects"],
    ],
    range: 2..=8,
};

static WORD_RESPA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RESPA_CHILDREN),
    value: None,
};

pub static WORD_RESPA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("wining")],
    values: &[&["respawning"]],
    range: 6..=6,
};

static WORD_RESO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_RESO_CHILDREN),
    value: None,
};

static WORD_RESO_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    None,
    None,
    Some(&WORD_RESOE_NODE),
    None,
    None,
    None,
    Some(&WORD_RESOI_NODE),
    None,
    None,
    Some(&WORD_RESOL_NODE),
    None,
    Some(&WORD_RESON_NODE),
    Some(&WORD_RESOO_NODE),
    Some(&WORD_RESOP_NODE),
    None,
    Some(&WORD_RESOR_NODE),
    None,
    Some(&WORD_RESOT_NODE),
    Some(&WORD_RESOU_NODE),
    Some(&WORD_RESOV_NODE),
    None,
    None,
    None,
    None,
];

static WORD_RESOV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RESOV_CHILDREN),
    value: None,
};

pub static WORD_RESOV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("lable"),
        dictgen::InsensitiveStr::Ascii("le"),
        dictgen::InsensitiveStr::Ascii("led"),
        dictgen::InsensitiveStr::Ascii("ler"),
        dictgen::InsensitiveStr::Ascii("lers"),
        dictgen::InsensitiveStr::Ascii("les"),
        dictgen::InsensitiveStr::Ascii("ling"),
    ],
    values: &[
        &["resolves"],
        &["resolvable"],
        &["resolve"],
        &["resolved"],
        &["resolver"],
        &["resolvers"],
        &["resolves"],
        &["resolving"],
    ],
    range: 2..=5,
};

static WORD_RESOU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RESOU_CHILDREN),
    value: None,
};

pub static WORD_RESOU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ce"),
        dictgen::InsensitiveStr::Ascii("ced"),
        dictgen::InsensitiveStr::Ascii("ces"),
        dictgen::InsensitiveStr::Ascii("cing"),
        dictgen::InsensitiveStr::Ascii("ltion"),
        dictgen::InsensitiveStr::Ascii("ltions"),
        dictgen::InsensitiveStr::Ascii("rcd"),
        dictgen::InsensitiveStr::Ascii("rcde"),
        dictgen::InsensitiveStr::Ascii("rcees"),
        dictgen::InsensitiveStr::Ascii("rceype"),
        dictgen::InsensitiveStr::Ascii("rcs"),
        dictgen::InsensitiveStr::Ascii("rcse"),
        dictgen::InsensitiveStr::Ascii("rcsed"),
        dictgen::InsensitiveStr::Ascii("re"),
        dictgen::InsensitiveStr::Ascii("recs"),
        dictgen::InsensitiveStr::Ascii("red"),
        dictgen::InsensitiveStr::Ascii("res"),
        dictgen::InsensitiveStr::Ascii("rse"),
        dictgen::InsensitiveStr::Ascii("rses"),
        dictgen::InsensitiveStr::Ascii("tion"),
    ],
    values: &[
        &["resource"],
        &["resourced"],
        &["resources"],
        &["resourcing"],
        &["resolution"],
        &["resolutions"],
        &["resourced", "resource"],
        &["resourced", "resource"],
        &["resources"],
        &["resourcetype"],
        &["resources", "resource"],
        &["resources", "resource"],
        &["resourced", "resource"],
        &["resource"],
        &["resources"],
        &["resourced"],
        &["resources"],
        &["resources", "recourse", "resource"],
        &["resources"],
        &["resolution"],
    ],
    range: 2..=6,
};

static WORD_RESOT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RESOT_CHILDREN),
    value: None,
};

pub static WORD_RESOT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ration"),
        dictgen::InsensitiveStr::Ascii("rations"),
        dictgen::InsensitiveStr::Ascii("rative"),
        dictgen::InsensitiveStr::Ascii("re"),
        dictgen::InsensitiveStr::Ascii("red"),
        dictgen::InsensitiveStr::Ascii("rer"),
        dictgen::InsensitiveStr::Ascii("rers"),
        dictgen::InsensitiveStr::Ascii("res"),
        dictgen::InsensitiveStr::Ascii("ring"),
    ],
    values: &[
        &["restoration"],
        &["restorations"],
        &["restorative"],
        &["restore"],
        &["restored", "resorted"],
        &["restorer"],
        &["restorers"],
        &["restores"],
        &["restoring"],
    ],
    range: 2..=7,
};

static WORD_RESOR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RESOR_CHILDREN),
    value: None,
};

pub static WORD_RESOR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ce"),
        dictgen::InsensitiveStr::Ascii("ced"),
        dictgen::InsensitiveStr::Ascii("ces"),
        dictgen::InsensitiveStr::Ascii("cing"),
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("ece"),
        dictgen::InsensitiveStr::Ascii("eces"),
        dictgen::InsensitiveStr::Ascii("uce"),
        dictgen::InsensitiveStr::Ascii("uced"),
        dictgen::InsensitiveStr::Ascii("uces"),
        dictgen::InsensitiveStr::Ascii("ucing"),
    ],
    values: &[
        &["resource"],
        &["resourced"],
        &["resources"],
        &["resourcing"],
        &["restore"],
        &["resource"],
        &["resources"],
        &["resource"],
        &["resourced"],
        &["resources"],
        &["resourcing"],
    ],
    range: 1..=5,
};

static WORD_RESOP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RESOP_CHILDREN),
    value: None,
};

pub static WORD_RESOP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("nse"),
        dictgen::InsensitiveStr::Ascii("nses"),
    ],
    values: &[&["response"], &["responses"]],
    range: 3..=4,
};

static WORD_RESOO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RESOO_CHILDREN),
    value: None,
};

pub static WORD_RESOO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("urce"),
        dictgen::InsensitiveStr::Ascii("urced"),
        dictgen::InsensitiveStr::Ascii("urces"),
        dictgen::InsensitiveStr::Ascii("urcing"),
    ],
    values: &[
        &["resource"],
        &["resourced"],
        &["resources"],
        &["resourcing"],
    ],
    range: 4..=6,
};

static WORD_RESON_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RESON_CHILDREN),
    value: Some(&["reason"]),
};

pub static WORD_RESON_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("abelt"),
        dictgen::InsensitiveStr::Ascii("able"),
        dictgen::InsensitiveStr::Ascii("et"),
        dictgen::InsensitiveStr::Ascii("s"),
        dictgen::InsensitiveStr::Ascii("se"),
        dictgen::InsensitiveStr::Ascii("ses"),
    ],
    values: &[
        &["resonate"],
        &["reasonable"],
        &["resonate"],
        &["reasons"],
        &["response"],
        &["responses"],
    ],
    range: 1..=5,
};

static WORD_RESOL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RESOL_CHILDREN),
    value: None,
};

pub static WORD_RESOL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("tion"),
        dictgen::InsensitiveStr::Ascii("tuion"),
        dictgen::InsensitiveStr::Ascii("tuions"),
        dictgen::InsensitiveStr::Ascii("ucion"),
        dictgen::InsensitiveStr::Ascii("uitons"),
        dictgen::InsensitiveStr::Ascii("utin"),
        dictgen::InsensitiveStr::Ascii("utino"),
        dictgen::InsensitiveStr::Ascii("utinos"),
        dictgen::InsensitiveStr::Ascii("utins"),
        dictgen::InsensitiveStr::Ascii("utionary"),
        dictgen::InsensitiveStr::Ascii("utoin"),
        dictgen::InsensitiveStr::Ascii("uton"),
        dictgen::InsensitiveStr::Ascii("utons"),
        dictgen::InsensitiveStr::Ascii("vemos"),
        dictgen::InsensitiveStr::Ascii("vendo"),
        dictgen::InsensitiveStr::Ascii("veres"),
        dictgen::InsensitiveStr::Ascii("verse"),
        dictgen::InsensitiveStr::Ascii("vinf"),
        dictgen::InsensitiveStr::Ascii("viste"),
        dictgen::InsensitiveStr::Ascii("vs"),
    ],
    values: &[
        &["resolution"],
        &["resolutions", "resolution"],
        &["resolutions"],
        &["resolution"],
        &["resolutions"],
        &["resolutions", "resolution"],
        &["resolutions", "resolution"],
        &["resolutions"],
        &["resolutions"],
        &["revolutionary"],
        &["resolutions"],
        &["resolution"],
        &["resolutions"],
        &["resolves"],
        &["resolved"],
        &["resolves"],
        &["resolves"],
        &["resolving"],
        &["resolves"],
        &["resolves"],
    ],
    range: 2..=8,
};

static WORD_RESOI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RESOI_CHILDREN),
    value: None,
};

pub static WORD_RESOI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("urce"),
        dictgen::InsensitiveStr::Ascii("urced"),
        dictgen::InsensitiveStr::Ascii("urces"),
        dictgen::InsensitiveStr::Ascii("urcing"),
    ],
    values: &[
        &["resource"],
        &["resourced"],
        &["resources"],
        &["resourcing"],
    ],
    range: 4..=6,
};

static WORD_RESOE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RESOE_CHILDREN),
    value: None,
};

pub static WORD_RESOE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ct"),
        dictgen::InsensitiveStr::Ascii("ctive"),
    ],
    values: &[&["respect"], &["respective"]],
    range: 2..=5,
};

static WORD_RESM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RESM_CHILDREN),
    value: None,
};

pub static WORD_RESM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eble"),
        dictgen::InsensitiveStr::Ascii("ebles"),
    ],
    values: &[&["resemble"], &["resembles"]],
    range: 4..=5,
};

static WORD_RESL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RESL_CHILDREN),
    value: None,
};

pub static WORD_RESL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ection"),
        dictgen::InsensitiveStr::Ascii("ove"),
        dictgen::InsensitiveStr::Ascii("oved"),
        dictgen::InsensitiveStr::Ascii("oves"),
        dictgen::InsensitiveStr::Ascii("oving"),
        dictgen::InsensitiveStr::Ascii("ut"),
        dictgen::InsensitiveStr::Ascii("uts"),
    ],
    values: &[
        &["reselection"],
        &["resolve"],
        &["resolved"],
        &["resolves"],
        &["resolving"],
        &["result"],
        &["results"],
    ],
    range: 2..=6,
};

static WORD_RESI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RESI_CHILDREN),
    value: None,
};

pub static WORD_RESI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("dencial"),
        dictgen::InsensitiveStr::Ascii("dentail"),
        dictgen::InsensitiveStr::Ascii("dental"),
        dictgen::InsensitiveStr::Ascii("dentual"),
        dictgen::InsensitiveStr::Ascii("dude"),
        dictgen::InsensitiveStr::Ascii("dule"),
        dictgen::InsensitiveStr::Ascii("erfs"),
        dictgen::InsensitiveStr::Ascii("gnacion"),
        dictgen::InsensitiveStr::Ascii("gnating"),
        dictgen::InsensitiveStr::Ascii("gnement"),
        dictgen::InsensitiveStr::Ascii("gnition"),
        dictgen::InsensitiveStr::Ascii("lence"),
        dictgen::InsensitiveStr::Ascii("nged"),
        dictgen::InsensitiveStr::Ascii("ntall"),
        dictgen::InsensitiveStr::Ascii("ntalled"),
        dictgen::InsensitiveStr::Ascii("ntalling"),
        dictgen::InsensitiveStr::Ascii("stable"),
        dictgen::InsensitiveStr::Ascii("stancies"),
        dictgen::InsensitiveStr::Ascii("stane"),
        dictgen::InsensitiveStr::Ascii("stanes"),
        dictgen::InsensitiveStr::Ascii("stans"),
        dictgen::InsensitiveStr::Ascii("stanse"),
        dictgen::InsensitiveStr::Ascii("stansen"),
        dictgen::InsensitiveStr::Ascii("stanses"),
        dictgen::InsensitiveStr::Ascii("stas"),
        dictgen::InsensitiveStr::Ascii("sten"),
        dictgen::InsensitiveStr::Ascii("stence"),
        dictgen::InsensitiveStr::Ascii("stences"),
        dictgen::InsensitiveStr::Ascii("stencias"),
        dictgen::InsensitiveStr::Ascii("stend"),
        dictgen::InsensitiveStr::Ascii("stendo"),
        dictgen::InsensitiveStr::Ascii("stent"),
        dictgen::InsensitiveStr::Ascii("stered"),
        dictgen::InsensitiveStr::Ascii("stes"),
        dictgen::InsensitiveStr::Ascii("stnace"),
        dictgen::InsensitiveStr::Ascii("stnaces"),
        dictgen::InsensitiveStr::Ascii("stribution"),
        dictgen::InsensitiveStr::Ascii("tance"),
        dictgen::InsensitiveStr::Ascii("tances"),
        dictgen::InsensitiveStr::Ascii("tor"),
        dictgen::InsensitiveStr::Ascii("tors"),
        dictgen::InsensitiveStr::Ascii("tsance"),
        dictgen::InsensitiveStr::Ascii("vwar"),
        dictgen::InsensitiveStr::Ascii("zeble"),
    ],
    values: &[
        &["residential"],
        &["residential"],
        &["residential"],
        &["residential"],
        &["residue"],
        &["residue"],
        &["reiserfs"],
        &["resignation"],
        &["resignation"],
        &["resignment"],
        &["resignation"],
        &["resilience"],
        &["resigned"],
        &["reinstall"],
        &["reinstalled"],
        &["reinstalling"],
        &["resistible"],
        &["resistances"],
        &["resistances"],
        &["resistances"],
        &["resistances"],
        &["resistances"],
        &["resistances"],
        &["resistances"],
        &["resists"],
        &["resistance"],
        &["resistance"],
        &["resistances"],
        &["resistances"],
        &["resisted"],
        &["resisted"],
        &["resistant"],
        &["resisted"],
        &["resists"],
        &["resistances"],
        &["resistances"],
        &["redistribution"],
        &["resistance"],
        &["resistances"],
        &["resistor"],
        &["resistors"],
        &["resistances"],
        &["reservoir"],
        &["resizable", "resizeable"],
    ],
    range: 3..=10,
};

static WORD_RESG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RESG_CHILDREN),
    value: None,
};

pub static WORD_RESG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ination"),
        dictgen::InsensitiveStr::Ascii("ined"),
        dictgen::InsensitiveStr::Ascii("ister"),
        dictgen::InsensitiveStr::Ascii("isters"),
    ],
    values: &[
        &["resignation"],
        &["resigned"],
        &["register"],
        &["registers"],
    ],
    range: 4..=7,
};

static WORD_RESE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RESE_CHILDREN),
    value: None,
};

pub static WORD_RESE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ach"),
        dictgen::InsensitiveStr::Ascii("ached"),
        dictgen::InsensitiveStr::Ascii("arce"),
        dictgen::InsensitiveStr::Ascii("archs"),
        dictgen::InsensitiveStr::Ascii("arvation"),
        dictgen::InsensitiveStr::Ascii("arvations"),
        dictgen::InsensitiveStr::Ascii("arve"),
        dictgen::InsensitiveStr::Ascii("arved"),
        dictgen::InsensitiveStr::Ascii("arves"),
        dictgen::InsensitiveStr::Ascii("arving"),
        dictgen::InsensitiveStr::Ascii("lction"),
        dictgen::InsensitiveStr::Ascii("mbe"),
        dictgen::InsensitiveStr::Ascii("mbelance"),
        dictgen::InsensitiveStr::Ascii("mbels"),
        dictgen::InsensitiveStr::Ascii("mbes"),
        dictgen::InsensitiveStr::Ascii("mblace"),
        dictgen::InsensitiveStr::Ascii("mblence"),
        dictgen::InsensitiveStr::Ascii("mblense"),
        dictgen::InsensitiveStr::Ascii("ntly"),
        dictgen::InsensitiveStr::Ascii("pect"),
        dictgen::InsensitiveStr::Ascii("pected"),
        dictgen::InsensitiveStr::Ascii("pecting"),
        dictgen::InsensitiveStr::Ascii("pective"),
        dictgen::InsensitiveStr::Ascii("pectively"),
        dictgen::InsensitiveStr::Ascii("pects"),
        dictgen::InsensitiveStr::Ascii("ptionist"),
        dictgen::InsensitiveStr::Ascii("rach"),
        dictgen::InsensitiveStr::Ascii("rached"),
        dictgen::InsensitiveStr::Ascii("racher"),
        dictgen::InsensitiveStr::Ascii("rachers"),
        dictgen::InsensitiveStr::Ascii("raching"),
        dictgen::InsensitiveStr::Ascii("ration"),
        dictgen::InsensitiveStr::Ascii("rrection"),
        dictgen::InsensitiveStr::Ascii("rv"),
        dictgen::InsensitiveStr::Ascii("rverad"),
        dictgen::InsensitiveStr::Ascii("rverd"),
        dictgen::InsensitiveStr::Ascii("rvered"),
        dictgen::InsensitiveStr::Ascii("st"),
        dictgen::InsensitiveStr::Ascii("status"),
        dictgen::InsensitiveStr::Ascii("table"),
        dictgen::InsensitiveStr::Ascii("ted"),
        dictgen::InsensitiveStr::Ascii("ting"),
        dictgen::InsensitiveStr::Ascii("tted"),
        dictgen::InsensitiveStr::Ascii("ved"),
        dictgen::InsensitiveStr::Ascii("verd"),
        dictgen::InsensitiveStr::Ascii("vered"),
        dictgen::InsensitiveStr::Ascii("vering"),
        dictgen::InsensitiveStr::Ascii("voir"),
    ],
    values: &[
        &["research"],
        &["researched"],
        &["researcher"],
        &["researchers"],
        &["reservation"],
        &["reservations"],
        &["reserve"],
        &["reserved"],
        &["reserves"],
        &["reserving"],
        &["reselection"],
        &["resemble"],
        &["resemblance"],
        &["resembles"],
        &["resembles"],
        &["resemble"],
        &["resemblance"],
        &["resembles"],
        &["recently"],
        &["respect"],
        &["respected"],
        &["respecting"],
        &["respective"],
        &["respectively"],
        &["respects"],
        &["receptionist"],
        &["research"],
        &["researched"],
        &["researchers"],
        &["researchers"],
        &["researching"],
        &["reservation"],
        &["resurrection"],
        &["reserve"],
        &["reserved"],
        &["reserved"],
        &["reserved"],
        &["reset", "recessed"],
        &["resetstatus"],
        &["resettable"],
        &["reset"],
        &["resetting"],
        &["reset"],
        &["reserved"],
        &["reserved"],
        &["reserved"],
        &["reserving"],
        &["reservoir"],
    ],
    range: 2..=9,
};

static WORD_RESC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RESC_CHILDREN),
    value: None,
};

pub static WORD_RESC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aned"),
        dictgen::InsensitiveStr::Ascii("ource"),
        dictgen::InsensitiveStr::Ascii("ourced"),
        dictgen::InsensitiveStr::Ascii("ources"),
        dictgen::InsensitiveStr::Ascii("ourcing"),
        dictgen::InsensitiveStr::Ascii("rition"),
        dictgen::InsensitiveStr::Ascii("ritions"),
        dictgen::InsensitiveStr::Ascii("uecd"),
        dictgen::InsensitiveStr::Ascii("ueing"),
        dictgen::InsensitiveStr::Ascii("use"),
    ],
    values: &[
        &["rescanned"],
        &["resource"],
        &["resourced"],
        &["resources"],
        &["resourcing"],
        &["restriction"],
        &["restrictions"],
        &["rescued"],
        &["rescuing"],
        &["rescues"],
    ],
    range: 3..=7,
};

static WORD_RESA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RESA_CHILDREN),
    value: None,
};

pub static WORD_RESA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("pwn"),
        dictgen::InsensitiveStr::Ascii("rch"),
        dictgen::InsensitiveStr::Ascii("rt"),
        dictgen::InsensitiveStr::Ascii("rts"),
        dictgen::InsensitiveStr::Ascii("urant"),
        dictgen::InsensitiveStr::Ascii("urants"),
    ],
    values: &[
        &["respawn"],
        &["research"],
        &["restart"],
        &["restarts"],
        &["restaurant"],
        &["restaurants"],
    ],
    range: 2..=6,
};

static WORD_RER_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RER_CHILDREN),
    value: None,
};

pub static WORD_RER_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("egisteration"),
        dictgen::InsensitiveStr::Ascii("erences"),
        dictgen::InsensitiveStr::Ascii("ference"),
        dictgen::InsensitiveStr::Ascii("ferences"),
        dictgen::InsensitiveStr::Ascii("pesentation"),
        dictgen::InsensitiveStr::Ascii("tieve"),
        dictgen::InsensitiveStr::Ascii("tieved"),
        dictgen::InsensitiveStr::Ascii("tiever"),
        dictgen::InsensitiveStr::Ascii("tievers"),
        dictgen::InsensitiveStr::Ascii("tieves"),
        dictgen::InsensitiveStr::Ascii("uirement"),
        dictgen::InsensitiveStr::Ascii("uirements"),
        dictgen::InsensitiveStr::Ascii("uning"),
        dictgen::InsensitiveStr::Ascii("urn"),
        dictgen::InsensitiveStr::Ascii("wite"),
    ],
    values: &[
        &["reregistration"],
        &["references"],
        &["reference"],
        &["references"],
        &["representation"],
        &["retrieve"],
        &["retrieved"],
        &["retriever"],
        &["retrievers"],
        &["retrieves"],
        &["requirement"],
        &["requirements"],
        &["rerunning"],
        &["return", "rerun"],
        &["rewrite"],
    ],
    range: 3..=12,
};

static WORD_REQ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_REQ_CHILDREN),
    value: None,
};

static WORD_REQ_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    None,
    None,
    Some(&WORD_REQE_NODE),
    None,
    None,
    None,
    Some(&WORD_REQI_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_REQR_NODE),
    None,
    None,
    Some(&WORD_REQU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_REQU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_REQU_CHILDREN),
    value: None,
};

static WORD_REQU_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    None,
    None,
    Some(&WORD_REQUE_NODE),
    None,
    None,
    None,
    Some(&WORD_REQUI_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_REQUR_NODE),
    Some(&WORD_REQUS_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_REQUS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REQUS_CHILDREN),
    value: None,
};

pub static WORD_REQUS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ite"),
        dictgen::InsensitiveStr::Ascii("ites"),
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("ted"),
        dictgen::InsensitiveStr::Ascii("ting"),
        dictgen::InsensitiveStr::Ascii("ts"),
    ],
    values: &[
        &["requisite"],
        &["requisites"],
        &["request"],
        &["requested"],
        &["requesting"],
        &["requests"],
    ],
    range: 1..=4,
};

static WORD_REQUR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REQUR_CHILDREN),
    value: None,
};

pub static WORD_REQUR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("ement"),
        dictgen::InsensitiveStr::Ascii("ements"),
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("est"),
        dictgen::InsensitiveStr::Ascii("ested"),
        dictgen::InsensitiveStr::Ascii("esting"),
        dictgen::InsensitiveStr::Ascii("ests"),
        dictgen::InsensitiveStr::Ascii("ied"),
        dictgen::InsensitiveStr::Ascii("iement"),
        dictgen::InsensitiveStr::Ascii("iements"),
        dictgen::InsensitiveStr::Ascii("ies"),
        dictgen::InsensitiveStr::Ascii("iment"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("ired"),
        dictgen::InsensitiveStr::Ascii("irement"),
        dictgen::InsensitiveStr::Ascii("irements"),
        dictgen::InsensitiveStr::Ascii("is"),
    ],
    values: &[
        &["require"],
        &["required"],
        &["requirement"],
        &["requirements"],
        &["requires"],
        &["request"],
        &["requested"],
        &["requesting"],
        &["requests"],
        &["required"],
        &["requirement"],
        &["requirements"],
        &["requires"],
        &["requirement"],
        &["requiring"],
        &["required"],
        &["requirement"],
        &["requirements"],
        &["require"],
    ],
    range: 1..=8,
};

static WORD_REQUI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REQUI_CHILDREN),
    value: None,
};

pub static WORD_REQUI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("erd"),
        dictgen::InsensitiveStr::Ascii("ere"),
        dictgen::InsensitiveStr::Ascii("ered"),
        dictgen::InsensitiveStr::Ascii("erement"),
        dictgen::InsensitiveStr::Ascii("erements"),
        dictgen::InsensitiveStr::Ascii("eres"),
        dictgen::InsensitiveStr::Ascii("ering"),
        dictgen::InsensitiveStr::Ascii("erment"),
        dictgen::InsensitiveStr::Ascii("erments"),
        dictgen::InsensitiveStr::Ascii("ers"),
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("est"),
        dictgen::InsensitiveStr::Ascii("ested"),
        dictgen::InsensitiveStr::Ascii("esting"),
        dictgen::InsensitiveStr::Ascii("ests"),
        dictgen::InsensitiveStr::Ascii("eum"),
        dictgen::InsensitiveStr::Ascii("lme"),
        dictgen::InsensitiveStr::Ascii("me"),
        dictgen::InsensitiveStr::Ascii("rd"),
        dictgen::InsensitiveStr::Ascii("reing"),
        dictgen::InsensitiveStr::Ascii("remenet"),
        dictgen::InsensitiveStr::Ascii("remenets"),
        dictgen::InsensitiveStr::Ascii("remenht"),
        dictgen::InsensitiveStr::Ascii("remnt"),
        dictgen::InsensitiveStr::Ascii("rment"),
        dictgen::InsensitiveStr::Ascii("rmentes"),
        dictgen::InsensitiveStr::Ascii("rments"),
        dictgen::InsensitiveStr::Ascii("sit"),
        dictgen::InsensitiveStr::Ascii("sits"),
    ],
    values: &[
        &["required"],
        &["required"],
        &["require"],
        &["required"],
        &["requirement"],
        &["requirements"],
        &["requires"],
        &["requiring"],
        &["requirement"],
        &["requirements"],
        &["requires"],
        &["requires"],
        &["request"],
        &["requested"],
        &["requesting"],
        &["requests"],
        &["requiem"],
        &["requiem"],
        &["requiem"],
        &["required"],
        &["requiring"],
        &["requirement"],
        &["requirements"],
        &["requirement"],
        &["requirement"],
        &["requirement"],
        &["requirements"],
        &["requirements"],
        &["requisite"],
        &["requisites"],
    ],
    range: 2..=8,
};

static WORD_REQUE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REQUE_CHILDREN),
    value: None,
};

pub static WORD_REQUE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("d"),
        dictgen::InsensitiveStr::Ascii("im"),
        dictgen::InsensitiveStr::Ascii("ncies"),
        dictgen::InsensitiveStr::Ascii("ncy"),
        dictgen::InsensitiveStr::Ascii("nst"),
        dictgen::InsensitiveStr::Ascii("ried"),
        dictgen::InsensitiveStr::Ascii("riment"),
        dictgen::InsensitiveStr::Ascii("rimento"),
        dictgen::InsensitiveStr::Ascii("riments"),
        dictgen::InsensitiveStr::Ascii("s"),
        dictgen::InsensitiveStr::Ascii("set"),
        dictgen::InsensitiveStr::Ascii("sr"),
        dictgen::InsensitiveStr::Ascii("sst"),
        dictgen::InsensitiveStr::Ascii("std"),
        dictgen::InsensitiveStr::Ascii("stes"),
        dictgen::InsensitiveStr::Ascii("stesd"),
        dictgen::InsensitiveStr::Ascii("stested"),
        dictgen::InsensitiveStr::Ascii("stests"),
        dictgen::InsensitiveStr::Ascii("stied"),
        dictgen::InsensitiveStr::Ascii("stor"),
        dictgen::InsensitiveStr::Ascii("stors"),
        dictgen::InsensitiveStr::Ascii("stying"),
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("ted"),
        dictgen::InsensitiveStr::Ascii("ting"),
        dictgen::InsensitiveStr::Ascii("ts"),
        dictgen::InsensitiveStr::Ascii("um"),
    ],
    values: &[
        &["requeued"],
        &["requiem"],
        &["frequencies"],
        &["frequency"],
        &["request", "requests"],
        &["required"],
        &["requirement"],
        &["requirement"],
        &["requirements"],
        &["request"],
        &["request", "requisite"],
        &["request"],
        &["request"],
        &["requested"],
        &["requests", "requested"],
        &["requested"],
        &["requested"],
        &["requests", "requested"],
        &["requested"],
        &["requester"],
        &["requesters"],
        &["requesting"],
        &["request"],
        &["requested"],
        &["requesting"],
        &["request", "requests"],
        &["requiem"],
    ],
    range: 1..=7,
};

static WORD_REQR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REQR_CHILDREN),
    value: None,
};

pub static WORD_REQR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ite"),
        dictgen::InsensitiveStr::Ascii("ites"),
    ],
    values: &[&["rewrite"], &["rewrites"]],
    range: 3..=4,
};

static WORD_REQI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REQI_CHILDREN),
    value: None,
};

pub static WORD_REQI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("est"),
        dictgen::InsensitiveStr::Ascii("re"),
        dictgen::InsensitiveStr::Ascii("red"),
        dictgen::InsensitiveStr::Ascii("rement"),
        dictgen::InsensitiveStr::Ascii("rements"),
        dictgen::InsensitiveStr::Ascii("res"),
        dictgen::InsensitiveStr::Ascii("ring"),
        dictgen::InsensitiveStr::Ascii("ster"),
        dictgen::InsensitiveStr::Ascii("uem"),
        dictgen::InsensitiveStr::Ascii("ure"),
        dictgen::InsensitiveStr::Ascii("ured"),
    ],
    values: &[
        &["request"],
        &["require"],
        &["required"],
        &["requirement"],
        &["requirements"],
        &["requires"],
        &["requiring"],
        &["register"],
        &["requiem"],
        &["require"],
        &["required"],
    ],
    range: 2..=7,
};

static WORD_REQE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REQE_CHILDREN),
    value: None,
};

pub static WORD_REQE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("st"),
        dictgen::InsensitiveStr::Ascii("sted"),
        dictgen::InsensitiveStr::Ascii("sts"),
        dictgen::InsensitiveStr::Ascii("uest"),
        dictgen::InsensitiveStr::Ascii("ust"),
        dictgen::InsensitiveStr::Ascii("usted"),
        dictgen::InsensitiveStr::Ascii("usting"),
        dictgen::InsensitiveStr::Ascii("usts"),
    ],
    values: &[
        &["request"],
        &["requested"],
        &["requests"],
        &["request"],
        &["request"],
        &["requested"],
        &["requesting"],
        &["requests"],
    ],
    range: 2..=6,
};

static WORD_REP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_REP_CHILDREN),
    value: None,
};

static WORD_REP_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_REPA_NODE),
    Some(&WORD_REPB_NODE),
    None,
    None,
    Some(&WORD_REPE_NODE),
    None,
    None,
    Some(&WORD_REPH_NODE),
    Some(&WORD_REPI_NODE),
    None,
    None,
    Some(&WORD_REPL_NODE),
    None,
    None,
    Some(&WORD_REPO_NODE),
    Some(&WORD_REPP_NODE),
    None,
    Some(&WORD_REPR_NODE),
    Some(&WORD_REPS_NODE),
    Some(&WORD_REPT_NODE),
    Some(&WORD_REPU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_REPU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REPU_CHILDREN),
    value: None,
};

pub static WORD_REPU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("bic"),
        dictgen::InsensitiveStr::Ascii("bican"),
        dictgen::InsensitiveStr::Ascii("bicans"),
        dictgen::InsensitiveStr::Ascii("bics"),
        dictgen::InsensitiveStr::Ascii("blcian"),
        dictgen::InsensitiveStr::Ascii("blcians"),
        dictgen::InsensitiveStr::Ascii("bli"),
        dictgen::InsensitiveStr::Ascii("blian"),
        dictgen::InsensitiveStr::Ascii("blians"),
        dictgen::InsensitiveStr::Ascii("blicanas"),
        dictgen::InsensitiveStr::Ascii("blicanos"),
        dictgen::InsensitiveStr::Ascii("blicants"),
        dictgen::InsensitiveStr::Ascii("blician"),
        dictgen::InsensitiveStr::Ascii("blicians"),
        dictgen::InsensitiveStr::Ascii("blicon"),
        dictgen::InsensitiveStr::Ascii("blicons"),
        dictgen::InsensitiveStr::Ascii("blis"),
        dictgen::InsensitiveStr::Ascii("glican"),
        dictgen::InsensitiveStr::Ascii("glicans"),
        dictgen::InsensitiveStr::Ascii("lic"),
        dictgen::InsensitiveStr::Ascii("lican"),
        dictgen::InsensitiveStr::Ascii("licans"),
        dictgen::InsensitiveStr::Ascii("lics"),
        dictgen::InsensitiveStr::Ascii("lisve"),
        dictgen::InsensitiveStr::Ascii("lsie"),
        dictgen::InsensitiveStr::Ascii("slive"),
        dictgen::InsensitiveStr::Ascii("tacion"),
        dictgen::InsensitiveStr::Ascii("tpose"),
        dictgen::InsensitiveStr::Ascii("tposed"),
        dictgen::InsensitiveStr::Ascii("tposes"),
        dictgen::InsensitiveStr::Ascii("tposing"),
    ],
    values: &[
        &["republic"],
        &["republican"],
        &["republicans"],
        &["republics"],
        &["republican"],
        &["republicans"],
        &["republic"],
        &["republican"],
        &["republicans"],
        &["republicans"],
        &["republicans"],
        &["republicans"],
        &["republican"],
        &["republicans"],
        &["republican"],
        &["republicans"],
        &["republics"],
        &["republican"],
        &["republicans"],
        &["republic"],
        &["republican"],
        &["republicans"],
        &["republics"],
        &["repulsive"],
        &["repulsive"],
        &["repulsive"],
        &["reputation"],
        &["repurpose"],
        &["repurposed"],
        &["repurposes"],
        &["repurposing"],
    ],
    range: 3..=8,
};

static WORD_REPT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REPT_CHILDREN),
    value: None,
};

pub static WORD_REPT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("iel"),
        dictgen::InsensitiveStr::Ascii("ils"),
        dictgen::InsensitiveStr::Ascii("ition"),
        dictgen::InsensitiveStr::Ascii("uable"),
        dictgen::InsensitiveStr::Ascii("uation"),
    ],
    values: &[
        &["reptile"],
        &["reptiles"],
        &["repetition"],
        &["reputable"],
        &["reputation"],
    ],
    range: 3..=6,
};

static WORD_REPS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REPS_CHILDREN),
    value: None,
};

pub static WORD_REPS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("awn"),
        dictgen::InsensitiveStr::Ascii("ectable"),
        dictgen::InsensitiveStr::Ascii("ectful"),
        dictgen::InsensitiveStr::Ascii("ectfully"),
        dictgen::InsensitiveStr::Ascii("ecting"),
        dictgen::InsensitiveStr::Ascii("ective"),
        dictgen::InsensitiveStr::Ascii("ectively"),
        dictgen::InsensitiveStr::Ascii("ects"),
        dictgen::InsensitiveStr::Ascii("ented"),
        dictgen::InsensitiveStr::Ascii("ond"),
        dictgen::InsensitiveStr::Ascii("onded"),
        dictgen::InsensitiveStr::Ascii("onding"),
        dictgen::InsensitiveStr::Ascii("onds"),
        dictgen::InsensitiveStr::Ascii("onse"),
        dictgen::InsensitiveStr::Ascii("onses"),
        dictgen::InsensitiveStr::Ascii("onsibilities"),
        dictgen::InsensitiveStr::Ascii("onsibility"),
        dictgen::InsensitiveStr::Ascii("onsible"),
        dictgen::InsensitiveStr::Ascii("onsibly"),
        dictgen::InsensitiveStr::Ascii("onsive"),
        dictgen::InsensitiveStr::Ascii("oted"),
        dictgen::InsensitiveStr::Ascii("ots"),
        dictgen::InsensitiveStr::Ascii("pectively"),
        dictgen::InsensitiveStr::Ascii("resents"),
    ],
    values: &[
        &["respawn"],
        &["respectable"],
        &["respectful"],
        &["respectfully"],
        &["respecting"],
        &["respective"],
        &["respectively"],
        &["respects"],
        &["repented", "represented"],
        &["respond"],
        &["responded"],
        &["responding"],
        &["responds"],
        &["response"],
        &["responses"],
        &["responsibilities"],
        &["responsibility"],
        &["responsible"],
        &["responsibly"],
        &["responsive"],
        &["reposted"],
        &["reposts"],
        &["respectively"],
        &["represents"],
    ],
    range: 3..=12,
};

static WORD_REPR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_REPR_CHILDREN),
    value: None,
};

static WORD_REPR_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_REPRA_NODE),
    None,
    None,
    None,
    Some(&WORD_REPRE_NODE),
    None,
    None,
    Some(&WORD_REPRH_NODE),
    Some(&WORD_REPRI_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_REPRO_NODE),
    None,
    None,
    None,
    Some(&WORD_REPRS_NODE),
    Some(&WORD_REPRT_NODE),
    Some(&WORD_REPRU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_REPRU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REPRU_CHILDREN),
    value: None,
};

pub static WORD_REPRU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("cible")],
    values: &[&["reproducible"]],
    range: 5..=5,
};

static WORD_REPRT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REPRT_CHILDREN),
    value: None,
};

pub static WORD_REPRT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("oire")],
    values: &[&["repertoire"]],
    range: 4..=4,
};

static WORD_REPRS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REPRS_CHILDREN),
    value: None,
};

pub static WORD_REPRS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ent"),
        dictgen::InsensitiveStr::Ascii("entation"),
        dictgen::InsensitiveStr::Ascii("entations"),
        dictgen::InsensitiveStr::Ascii("ented"),
        dictgen::InsensitiveStr::Ascii("enting"),
        dictgen::InsensitiveStr::Ascii("ents"),
    ],
    values: &[
        &["represent"],
        &["representation"],
        &["representations"],
        &["represented"],
        &["representing"],
        &["represents"],
    ],
    range: 3..=9,
};

static WORD_REPRO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REPRO_CHILDREN),
    value: None,
};

pub static WORD_REPRO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ciblbe"),
        dictgen::InsensitiveStr::Ascii("cible"),
        dictgen::InsensitiveStr::Ascii("cuce"),
        dictgen::InsensitiveStr::Ascii("cuced"),
        dictgen::InsensitiveStr::Ascii("cuces"),
        dictgen::InsensitiveStr::Ascii("cucing"),
        dictgen::InsensitiveStr::Ascii("dice"),
        dictgen::InsensitiveStr::Ascii("diced"),
        dictgen::InsensitiveStr::Ascii("dicibility"),
        dictgen::InsensitiveStr::Ascii("dicible"),
        dictgen::InsensitiveStr::Ascii("dicibly"),
        dictgen::InsensitiveStr::Ascii("dicing"),
        dictgen::InsensitiveStr::Ascii("diction"),
        dictgen::InsensitiveStr::Ascii("ducabely"),
        dictgen::InsensitiveStr::Ascii("ducability"),
        dictgen::InsensitiveStr::Ascii("ducable"),
        dictgen::InsensitiveStr::Ascii("ducablitity"),
        dictgen::InsensitiveStr::Ascii("ducably"),
        dictgen::InsensitiveStr::Ascii("duccion"),
        dictgen::InsensitiveStr::Ascii("duciability"),
        dictgen::InsensitiveStr::Ascii("duciable"),
        dictgen::InsensitiveStr::Ascii("duciblity"),
        dictgen::InsensitiveStr::Ascii("ducion"),
        dictgen::InsensitiveStr::Ascii("duciton"),
        dictgen::InsensitiveStr::Ascii("ducive"),
        dictgen::InsensitiveStr::Ascii("ductible"),
        dictgen::InsensitiveStr::Ascii("ducting"),
        dictgen::InsensitiveStr::Ascii("ductivo"),
        dictgen::InsensitiveStr::Ascii("duktion"),
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("ts"),
    ],
    values: &[
        &["reproducible"],
        &["reproducible"],
        &["reproduce", "reprocure"],
        &["reproduced", "reprocured"],
        &["reproduces", "reprocures"],
        &["reproducing", "reprocuring"],
        &["reproduce"],
        &["reproduced"],
        &["reproducibility"],
        &["reproducible"],
        &["reproducibly"],
        &["reproducing"],
        &["reproduction"],
        &["reproducibly"],
        &["reproducibility"],
        &["reproducible"],
        &["reproducibility"],
        &["reproducibly"],
        &["reproduction"],
        &["reproduceability"],
        &["reproduceable"],
        &["reproducibility"],
        &["reproduction"],
        &["reproduction"],
        &["reproductive"],
        &["reproducible"],
        &["reproduction"],
        &["reproduction"],
        &["reproduction"],
        &["report"],
        &["reports"],
    ],
    range: 1..=11,
};

static WORD_REPRI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REPRI_CHILDREN),
    value: None,
};

pub static WORD_REPRI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cussions"),
        dictgen::InsensitiveStr::Ascii("hensible"),
    ],
    values: &[&["repercussions"], &["reprehensible"]],
    range: 8..=8,
};

static WORD_REPRH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REPRH_CHILDREN),
    value: None,
};

pub static WORD_REPRH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ase")],
    values: &[&["rephrase"]],
    range: 3..=3,
};

static WORD_REPRE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_REPRE_CHILDREN),
    value: None,
};

static WORD_REPRE_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    Some(&WORD_REPREC_NODE),
    None,
    Some(&WORD_REPREE_NODE),
    None,
    None,
    Some(&WORD_REPREH_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_REPREN_NODE),
    None,
    Some(&WORD_REPREP_NODE),
    None,
    None,
    Some(&WORD_REPRES_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_REPREZ_NODE),
];

static WORD_REPREZ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REPREZ_CHILDREN),
    value: None,
};

pub static WORD_REPREZ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("entative")],
    values: &[&["representative"]],
    range: 8..=8,
};

static WORD_REPRES_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_REPRES_CHILDREN),
    value: None,
};

static WORD_REPRES_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_REPRESA_NODE),
    None,
    None,
    None,
    Some(&WORD_REPRESE_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_REPRESN_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_REPRESS_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_REPRESS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REPRESS_CHILDREN),
    value: None,
};

pub static WORD_REPRESS_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("ent"),
            dictgen::InsensitiveStr::Ascii("entation"),
            dictgen::InsensitiveStr::Ascii("enting"),
            dictgen::InsensitiveStr::Ascii("ents"),
            dictgen::InsensitiveStr::Ascii("in"),
            dictgen::InsensitiveStr::Ascii("ivo"),
            dictgen::InsensitiveStr::Ascii("o"),
            dictgen::InsensitiveStr::Ascii("sion"),
        ],
        values: &[
            &["represents", "represent"],
            &["representation"],
            &["representing"],
            &["represents"],
            &["repression"],
            &["repression"],
            &["repression"],
            &["repression"],
        ],
        range: 1..=8,
    };

static WORD_REPRESN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REPRESN_CHILDREN),
    value: None,
};

pub static WORD_REPRESN_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("et"),
            dictgen::InsensitiveStr::Ascii("etated"),
            dictgen::InsensitiveStr::Ascii("etation"),
            dictgen::InsensitiveStr::Ascii("etations"),
            dictgen::InsensitiveStr::Ascii("eted"),
            dictgen::InsensitiveStr::Ascii("eting"),
            dictgen::InsensitiveStr::Ascii("ets"),
            dictgen::InsensitiveStr::Ascii("t"),
            dictgen::InsensitiveStr::Ascii("tation"),
            dictgen::InsensitiveStr::Ascii("tative"),
            dictgen::InsensitiveStr::Ascii("ted"),
            dictgen::InsensitiveStr::Ascii("ting"),
            dictgen::InsensitiveStr::Ascii("ts"),
        ],
        values: &[
            &["represent"],
            &["represented"],
            &["representations", "representation"],
            &["representations"],
            &["represented"],
            &["representing"],
            &["represents"],
            &["represent"],
            &["representation"],
            &["representative"],
            &["represented"],
            &["representing"],
            &["represents"],
        ],
        range: 1..=8,
    };

static WORD_REPRESE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REPRESE_CHILDREN),
    value: None,
};

pub static WORD_REPRESE_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("natation"),
            dictgen::InsensitiveStr::Ascii("natational"),
            dictgen::InsensitiveStr::Ascii("natations"),
            dictgen::InsensitiveStr::Ascii("nation"),
            dictgen::InsensitiveStr::Ascii("national"),
            dictgen::InsensitiveStr::Ascii("nations"),
            dictgen::InsensitiveStr::Ascii("nd"),
            dictgen::InsensitiveStr::Ascii("nsible"),
            dictgen::InsensitiveStr::Ascii("ntacion"),
            dictgen::InsensitiveStr::Ascii("ntaciones"),
            dictgen::InsensitiveStr::Ascii("ntaion"),
            dictgen::InsensitiveStr::Ascii("ntaional"),
            dictgen::InsensitiveStr::Ascii("ntaions"),
            dictgen::InsensitiveStr::Ascii("ntaiton"),
            dictgen::InsensitiveStr::Ascii("ntas"),
            dictgen::InsensitiveStr::Ascii("ntate"),
            dictgen::InsensitiveStr::Ascii("ntated"),
            dictgen::InsensitiveStr::Ascii("ntatie"),
            dictgen::InsensitiveStr::Ascii("ntatief"),
            dictgen::InsensitiveStr::Ascii("ntatieve"),
            dictgen::InsensitiveStr::Ascii("ntatin"),
            dictgen::InsensitiveStr::Ascii("ntating"),
            dictgen::InsensitiveStr::Ascii("ntationen"),
            dictgen::InsensitiveStr::Ascii("ntationer"),
            dictgen::InsensitiveStr::Ascii("ntativas"),
            dictgen::InsensitiveStr::Ascii("ntativo"),
            dictgen::InsensitiveStr::Ascii("ntd"),
            dictgen::InsensitiveStr::Ascii("nte"),
            dictgen::InsensitiveStr::Ascii("nterad"),
            dictgen::InsensitiveStr::Ascii("ntes"),
            dictgen::InsensitiveStr::Ascii("ntetive"),
            dictgen::InsensitiveStr::Ascii("ntetives"),
            dictgen::InsensitiveStr::Ascii("ntiative"),
            dictgen::InsensitiveStr::Ascii("ntion"),
            dictgen::InsensitiveStr::Ascii("ntions"),
            dictgen::InsensitiveStr::Ascii("ntitive"),
            dictgen::InsensitiveStr::Ascii("ntitives"),
            dictgen::InsensitiveStr::Ascii("ntitve"),
            dictgen::InsensitiveStr::Ascii("ntive"),
            dictgen::InsensitiveStr::Ascii("ntives"),
            dictgen::InsensitiveStr::Ascii("ntn"),
            dictgen::InsensitiveStr::Ascii("ntstion"),
            dictgen::InsensitiveStr::Ascii("ntstive"),
            dictgen::InsensitiveStr::Ascii("t"),
            dictgen::InsensitiveStr::Ascii("tation"),
            dictgen::InsensitiveStr::Ascii("ted"),
            dictgen::InsensitiveStr::Ascii("ting"),
            dictgen::InsensitiveStr::Ascii("tnation"),
            dictgen::InsensitiveStr::Ascii("tning"),
            dictgen::InsensitiveStr::Ascii("ts"),
        ],
        values: &[
            &["representation"],
            &["representational"],
            &["representations"],
            &["representation"],
            &["representational"],
            &["representations"],
            &["represented", "represent"],
            &["reprehensible"],
            &["representation"],
            &["representations"],
            &["representation"],
            &["representational"],
            &["representations"],
            &["representations", "representation"],
            &["represents"],
            &["representative"],
            &["represented"],
            &["representatives"],
            &["representative"],
            &["representative"],
            &["representations"],
            &["representation", "representing"],
            &["representations"],
            &["representations"],
            &["representatives"],
            &["representation"],
            &["represented"],
            &["represents", "represented"],
            &["represented"],
            &["represents", "represented"],
            &["representative"],
            &["representatives"],
            &["representative"],
            &["representing", "representation"],
            &["representations"],
            &["representative"],
            &["representatives"],
            &["representative"],
            &["representative"],
            &["representatives"],
            &["representing"],
            &["representations"],
            &["representatives"],
            &["represents", "represent"],
            &["representation"],
            &["represented"],
            &["representing"],
            &["representations"],
            &["representing"],
            &["represents"],
        ],
        range: 1..=10,
    };

static WORD_REPRESA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REPRESA_CHILDREN),
    value: None,
};

pub static WORD_REPRESA_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("ntation"),
            dictgen::InsensitiveStr::Ascii("ntational"),
            dictgen::InsensitiveStr::Ascii("ntations"),
            dictgen::InsensitiveStr::Ascii("ntative"),
            dictgen::InsensitiveStr::Ascii("ntatives"),
        ],
        values: &[
            &["representation"],
            &["representational"],
            &["representations"],
            &["representative"],
            &["representatives"],
        ],
        range: 7..=9,
    };

static WORD_REPREP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REPREP_CHILDREN),
    value: None,
};

pub static WORD_REPREP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("resents")],
    values: &[&["represents"]],
    range: 7..=7,
};

static WORD_REPREN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REPREN_CHILDREN),
    value: None,
};

pub static WORD_REPREN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("sent"),
        dictgen::InsensitiveStr::Ascii("sentation"),
        dictgen::InsensitiveStr::Ascii("sentational"),
        dictgen::InsensitiveStr::Ascii("sentations"),
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("ted"),
        dictgen::InsensitiveStr::Ascii("ting"),
        dictgen::InsensitiveStr::Ascii("ts"),
    ],
    values: &[
        &["represent"],
        &["representation"],
        &["representational"],
        &["representations"],
        &["repent", "represent", "reprint"],
        &["repented", "represented", "reprinted"],
        &["repenting", "representing"],
        &["repents", "represents", "reprints"],
    ],
    range: 1..=11,
};

static WORD_REPREH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REPREH_CHILDREN),
    value: None,
};

pub static WORD_REPREH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("enisble"),
        dictgen::InsensitiveStr::Ascii("ensable"),
        dictgen::InsensitiveStr::Ascii("insible"),
    ],
    values: &[&["reprehensible"], &["reprehensible"], &["reprehensible"]],
    range: 7..=7,
};

static WORD_REPREE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REPREE_CHILDREN),
    value: None,
};

pub static WORD_REPREE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("snt"),
        dictgen::InsensitiveStr::Ascii("snted"),
        dictgen::InsensitiveStr::Ascii("snts"),
    ],
    values: &[&["represent"], &["represented"], &["represents"]],
    range: 3..=5,
};

static WORD_REPREC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REPREC_CHILDREN),
    value: None,
};

pub static WORD_REPREC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ussion"),
        dictgen::InsensitiveStr::Ascii("ussions"),
    ],
    values: &[&["repercussions", "repercussion"], &["repercussions"]],
    range: 6..=7,
};

static WORD_REPRA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REPRA_CHILDREN),
    value: None,
};

pub static WORD_REPRA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("esentation"),
        dictgen::InsensitiveStr::Ascii("esentational"),
        dictgen::InsensitiveStr::Ascii("esentations"),
    ],
    values: &[
        &["representation"],
        &["representational"],
        &["representations"],
    ],
    range: 10..=12,
};

static WORD_REPP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REPP_CHILDREN),
    value: None,
};

pub static WORD_REPP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ort"),
        dictgen::InsensitiveStr::Ascii("ository"),
    ],
    values: &[&["report"], &["repository"]],
    range: 3..=7,
};

static WORD_REPO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REPO_CHILDREN),
    value: None,
};

pub static WORD_REPO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("istory"),
        dictgen::InsensitiveStr::Ascii("nd"),
        dictgen::InsensitiveStr::Ascii("nding"),
        dictgen::InsensitiveStr::Ascii("nse"),
        dictgen::InsensitiveStr::Ascii("nses"),
        dictgen::InsensitiveStr::Ascii("nsibilities"),
        dictgen::InsensitiveStr::Ascii("nsibility"),
        dictgen::InsensitiveStr::Ascii("nsible"),
        dictgen::InsensitiveStr::Ascii("rduction"),
        dictgen::InsensitiveStr::Ascii("rductive"),
        dictgen::InsensitiveStr::Ascii("re"),
        dictgen::InsensitiveStr::Ascii("reted"),
        dictgen::InsensitiveStr::Ascii("ring"),
        dictgen::InsensitiveStr::Ascii("ritory"),
        dictgen::InsensitiveStr::Ascii("rtadly"),
        dictgen::InsensitiveStr::Ascii("rtedy"),
        dictgen::InsensitiveStr::Ascii("rteros"),
        dictgen::InsensitiveStr::Ascii("rtes"),
        dictgen::InsensitiveStr::Ascii("rtidly"),
        dictgen::InsensitiveStr::Ascii("rtign"),
        dictgen::InsensitiveStr::Ascii("rtresouces"),
        dictgen::InsensitiveStr::Ascii("siotory"),
        dictgen::InsensitiveStr::Ascii("siotry"),
        dictgen::InsensitiveStr::Ascii("siry"),
        dictgen::InsensitiveStr::Ascii("sitary"),
        dictgen::InsensitiveStr::Ascii("sitiories"),
        dictgen::InsensitiveStr::Ascii("sitiory"),
        dictgen::InsensitiveStr::Ascii("sitiroes"),
        dictgen::InsensitiveStr::Ascii("sititioning"),
        dictgen::InsensitiveStr::Ascii("sitor"),
        dictgen::InsensitiveStr::Ascii("sitorry"),
        dictgen::InsensitiveStr::Ascii("sitotries"),
        dictgen::InsensitiveStr::Ascii("sitotry"),
        dictgen::InsensitiveStr::Ascii("sitry"),
        dictgen::InsensitiveStr::Ascii("sity"),
        dictgen::InsensitiveStr::Ascii("soitory"),
        dictgen::InsensitiveStr::Ascii("sond"),
        dictgen::InsensitiveStr::Ascii("sonder"),
        dictgen::InsensitiveStr::Ascii("sonders"),
        dictgen::InsensitiveStr::Ascii("sonding"),
        dictgen::InsensitiveStr::Ascii("sonse"),
        dictgen::InsensitiveStr::Ascii("sonses"),
        dictgen::InsensitiveStr::Ascii("sotory"),
        dictgen::InsensitiveStr::Ascii("stas"),
        dictgen::InsensitiveStr::Ascii("std"),
        dictgen::InsensitiveStr::Ascii("stes"),
        dictgen::InsensitiveStr::Ascii("stig"),
        dictgen::InsensitiveStr::Ascii("stiories"),
        dictgen::InsensitiveStr::Ascii("stiory"),
        dictgen::InsensitiveStr::Ascii("stories"),
        dictgen::InsensitiveStr::Ascii("story"),
        dictgen::InsensitiveStr::Ascii("stus"),
        dictgen::InsensitiveStr::Ascii("te"),
    ],
    values: &[
        &["repository"],
        &["respond"],
        &["responding"],
        &["response"],
        &["responses"],
        &["responsibilities"],
        &["responsibility"],
        &["responsible"],
        &["reproduction"],
        &["reproductive"],
        &["rapport", "report", "repose"],
        &["reported"],
        &["reporting"],
        &["repository"],
        &["reportedly"],
        &["reportedly"],
        &["reporters"],
        &["reporters"],
        &["reportedly"],
        &["reporting"],
        &["reportresources"],
        &["repository"],
        &["repository"],
        &["repository"],
        &["repository"],
        &["repositories"],
        &["repository"],
        &["repositories"],
        &["repositioning"],
        &["repository"],
        &["repository"],
        &["repositories"],
        &["repository"],
        &["repository"],
        &["repository"],
        &["repository"],
        &["respond"],
        &["responder"],
        &["responders"],
        &["responding"],
        &["response"],
        &["responses"],
        &["repository"],
        &["reposts"],
        &["reposted"],
        &["reposts", "ripostes"],
        &["reposting"],
        &["repositories"],
        &["repository"],
        &["repositories"],
        &["repository"],
        &["reposts"],
        &["report", "remote"],
    ],
    range: 2..=11,
};

static WORD_REPL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_REPL_CHILDREN),
    value: None,
};

static WORD_REPL_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_REPLA_NODE),
    None,
    Some(&WORD_REPLC_NODE),
    None,
    Some(&WORD_REPLE_NODE),
    None,
    None,
    None,
    Some(&WORD_REPLI_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_REPLU_NODE),
    None,
    None,
    None,
    Some(&WORD_REPLY_NODE),
    None,
];

static WORD_REPLY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REPLY_CHILDREN),
    value: None,
};

pub static WORD_REPLY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("s")],
    values: &[&["replies"]],
    range: 1..=1,
};

static WORD_REPLU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REPLU_CHILDREN),
    value: None,
};

pub static WORD_REPLU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("bic"),
        dictgen::InsensitiveStr::Ascii("sive"),
    ],
    values: &[&["republic"], &["repulsive"]],
    range: 3..=4,
};

static WORD_REPLI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REPLI_CHILDREN),
    value: None,
};

pub static WORD_REPLI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cae"),
        dictgen::InsensitiveStr::Ascii("caes"),
        dictgen::InsensitiveStr::Ascii("caiing"),
        dictgen::InsensitiveStr::Ascii("caion"),
        dictgen::InsensitiveStr::Ascii("caions"),
        dictgen::InsensitiveStr::Ascii("caite"),
        dictgen::InsensitiveStr::Ascii("caites"),
        dictgen::InsensitiveStr::Ascii("caiting"),
        dictgen::InsensitiveStr::Ascii("caition"),
        dictgen::InsensitiveStr::Ascii("caitions"),
        dictgen::InsensitiveStr::Ascii("caiton"),
        dictgen::InsensitiveStr::Ascii("caitons"),
        dictgen::InsensitiveStr::Ascii("ng"),
    ],
    values: &[
        &["replicated", "replicate"],
        &["replicates"],
        &["replicating"],
        &["replication"],
        &["replications"],
        &["replicate"],
        &["replicates"],
        &["replicating"],
        &["replication"],
        &["replications"],
        &["replication"],
        &["replications"],
        &["replying"],
    ],
    range: 2..=8,
};

static WORD_REPLE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REPLE_CHILDREN),
    value: None,
};

pub static WORD_REPLE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("acable"),
        dictgen::InsensitiveStr::Ascii("cated"),
        dictgen::InsensitiveStr::Ascii("ntish"),
        dictgen::InsensitiveStr::Ascii("ntished"),
        dictgen::InsensitiveStr::Ascii("ntishes"),
        dictgen::InsensitiveStr::Ascii("ntishing"),
        dictgen::InsensitiveStr::Ascii("ntishs"),
    ],
    values: &[
        &["replaceable"],
        &["replicated"],
        &["replenish"],
        &["replenished"],
        &["replenishes"],
        &["replenishing"],
        &["replenishes"],
    ],
    range: 5..=8,
};

static WORD_REPLC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REPLC_CHILDREN),
    value: None,
};

pub static WORD_REPLC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ace"),
        dictgen::InsensitiveStr::Ascii("aced"),
        dictgen::InsensitiveStr::Ascii("aof"),
    ],
    values: &[&["replace"], &["replaced"], &["replicaof"]],
    range: 3..=4,
};

static WORD_REPLA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REPLA_CHILDREN),
    value: None,
};

pub static WORD_REPLA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ca"),
        dictgen::InsensitiveStr::Ascii("cability"),
        dictgen::InsensitiveStr::Ascii("cable"),
        dictgen::InsensitiveStr::Ascii("cables"),
        dictgen::InsensitiveStr::Ascii("cacing"),
        dictgen::InsensitiveStr::Ascii("caiblity"),
        dictgen::InsensitiveStr::Ascii("calbe"),
        dictgen::InsensitiveStr::Ascii("calbes"),
        dictgen::InsensitiveStr::Ascii("cament"),
        dictgen::InsensitiveStr::Ascii("caments"),
        dictgen::InsensitiveStr::Ascii("cas"),
        dictgen::InsensitiveStr::Ascii("cate"),
        dictgen::InsensitiveStr::Ascii("cated"),
        dictgen::InsensitiveStr::Ascii("cates"),
        dictgen::InsensitiveStr::Ascii("cating"),
        dictgen::InsensitiveStr::Ascii("cation"),
        dictgen::InsensitiveStr::Ascii("cd"),
        dictgen::InsensitiveStr::Ascii("ceble"),
        dictgen::InsensitiveStr::Ascii("ceemnt"),
        dictgen::InsensitiveStr::Ascii("ceemnts"),
        dictgen::InsensitiveStr::Ascii("cememt"),
        dictgen::InsensitiveStr::Ascii("cemenet"),
        dictgen::InsensitiveStr::Ascii("cemet"),
        dictgen::InsensitiveStr::Ascii("cemnet"),
        dictgen::InsensitiveStr::Ascii("cemnt"),
        dictgen::InsensitiveStr::Ascii("cemnts"),
        dictgen::InsensitiveStr::Ascii("cemtn"),
        dictgen::InsensitiveStr::Ascii("cmenet"),
        dictgen::InsensitiveStr::Ascii("cment"),
        dictgen::InsensitiveStr::Ascii("cments"),
        dictgen::InsensitiveStr::Ascii("cong"),
        dictgen::InsensitiveStr::Ascii("cte"),
        dictgen::InsensitiveStr::Ascii("cted"),
        dictgen::InsensitiveStr::Ascii("ctes"),
        dictgen::InsensitiveStr::Ascii("cting"),
        dictgen::InsensitiveStr::Ascii("int"),
        dictgen::InsensitiveStr::Ascii("se"),
        dictgen::InsensitiveStr::Ascii("sed"),
        dictgen::InsensitiveStr::Ascii("sement"),
        dictgen::InsensitiveStr::Ascii("sements"),
        dictgen::InsensitiveStr::Ascii("ses"),
        dictgen::InsensitiveStr::Ascii("sing"),
        dictgen::InsensitiveStr::Ascii("yd"),
        dictgen::InsensitiveStr::Ascii("yes"),
    ],
    values: &[
        &["replica", "replace"],
        &["replaceability"],
        &["replicable", "replaceable"],
        &["replaceables"],
        &["replacing"],
        &["replaceability", "replicability"],
        &["replaceable"],
        &["replaceables"],
        &["replacement"],
        &["replacements"],
        &["replicas", "replaces"],
        &["replicate"],
        &["replicated"],
        &["replicates"],
        &["replicating"],
        &["replication"],
        &["replaced"],
        &["replaceable"],
        &["replacement"],
        &["replacements"],
        &["replacement"],
        &["replacement"],
        &["replacements"],
        &["replacements"],
        &["replacement"],
        &["replacements"],
        &["replacements"],
        &["replacement"],
        &["replacement"],
        &["replacements"],
        &["replacing"],
        &["replace", "replicate"],
        &["replaced", "replicated"],
        &["replaces", "replicates"],
        &["replacing", "replicating"],
        &["repaint"],
        &["replaces", "replace", "relapse", "rephase"],
        &["relapsed", "replaced", "rephased"],
        &["replacement"],
        &["replacements"],
        &["replaces", "relapses", "rephases"],
        &["replacing", "relapsing", "rephasing"],
        &["replayed"],
        &["replays"],
    ],
    range: 2..=8,
};

static WORD_REPI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REPI_CHILDREN),
    value: None,
};

pub static WORD_REPI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("d"),
        dictgen::InsensitiveStr::Ascii("tion"),
        dictgen::InsensitiveStr::Ascii("tions"),
        dictgen::InsensitiveStr::Ascii("tition"),
        dictgen::InsensitiveStr::Ascii("titions"),
        dictgen::InsensitiveStr::Ascii("tle"),
        dictgen::InsensitiveStr::Ascii("tles"),
    ],
    values: &[
        &["rapid"],
        &["repetition"],
        &["repetitions"],
        &["repetition"],
        &["repetitions"],
        &["reptile"],
        &["reptiles"],
    ],
    range: 1..=7,
};

static WORD_REPH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REPH_CHILDREN),
    value: None,
};

pub static WORD_REPH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("arse"),
        dictgen::InsensitiveStr::Ascii("rasse"),
    ],
    values: &[&["rephrase"], &["rephrase"]],
    range: 4..=5,
};

static WORD_REPE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_REPE_CHILDREN),
    value: None,
};

static WORD_REPE_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_REPEA_NODE),
    None,
    Some(&WORD_REPEC_NODE),
    Some(&WORD_REPED_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_REPEI_NODE),
    None,
    None,
    Some(&WORD_REPEL_NODE),
    None,
    Some(&WORD_REPEN_NODE),
    None,
    None,
    None,
    Some(&WORD_REPER_NODE),
    Some(&WORD_REPES_NODE),
    Some(&WORD_REPET_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_REPET_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REPET_CHILDREN),
    value: Some(&["repeat"]),
};

pub static WORD_REPET_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ation"),
        dictgen::InsensitiveStr::Ascii("ative"),
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("eadly"),
        dictgen::InsensitiveStr::Ascii("etion"),
        dictgen::InsensitiveStr::Ascii("etions"),
        dictgen::InsensitiveStr::Ascii("etive"),
        dictgen::InsensitiveStr::Ascii("icion"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("ion"),
        dictgen::InsensitiveStr::Ascii("ions"),
        dictgen::InsensitiveStr::Ascii("itivo"),
        dictgen::InsensitiveStr::Ascii("ive"),
        dictgen::InsensitiveStr::Ascii("oire"),
        dictgen::InsensitiveStr::Ascii("oires"),
    ],
    values: &[
        &["repetition"],
        &["repetitive"],
        &["repeat"],
        &["repeatedly"],
        &["repetition"],
        &["repetitions"],
        &["repetitive"],
        &["repetition"],
        &["repeating"],
        &["repetition"],
        &["repetitions"],
        &["repetition"],
        &["repetitive"],
        &["repertoire"],
        &["repertoires"],
    ],
    range: 1..=6,
};

static WORD_REPES_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REPES_CHILDREN),
    value: None,
};

pub static WORD_REPES_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ent"),
        dictgen::InsensitiveStr::Ascii("entation"),
        dictgen::InsensitiveStr::Ascii("entational"),
        dictgen::InsensitiveStr::Ascii("ented"),
        dictgen::InsensitiveStr::Ascii("enting"),
        dictgen::InsensitiveStr::Ascii("ents"),
    ],
    values: &[
        &["represent"],
        &["representation"],
        &["representational"],
        &["represented"],
        &["representing"],
        &["represents"],
    ],
    range: 3..=10,
};

static WORD_REPER_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REPER_CHILDREN),
    value: None,
};

pub static WORD_REPER_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("esent"),
        dictgen::InsensitiveStr::Ascii("esentation"),
        dictgen::InsensitiveStr::Ascii("esentational"),
        dictgen::InsensitiveStr::Ascii("esentations"),
        dictgen::InsensitiveStr::Ascii("esented"),
        dictgen::InsensitiveStr::Ascii("esenting"),
        dictgen::InsensitiveStr::Ascii("esents"),
        dictgen::InsensitiveStr::Ascii("sentation"),
        dictgen::InsensitiveStr::Ascii("sentations"),
        dictgen::InsensitiveStr::Ascii("sented"),
        dictgen::InsensitiveStr::Ascii("senting"),
        dictgen::InsensitiveStr::Ascii("sents"),
        dictgen::InsensitiveStr::Ascii("toir"),
        dictgen::InsensitiveStr::Ascii("twar"),
        dictgen::InsensitiveStr::Ascii("twares"),
        dictgen::InsensitiveStr::Ascii("twars"),
    ],
    values: &[
        &["represent"],
        &["representation"],
        &["representational"],
        &["representations"],
        &["represented"],
        &["representing"],
        &["represents"],
        &["representation"],
        &["representations"],
        &["represented"],
        &["representing"],
        &["represents"],
        &["repertoire"],
        &["repertoire"],
        &["repertoires"],
        &["repertoires"],
    ],
    range: 4..=12,
};

static WORD_REPEN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REPEN_CHILDREN),
    value: None,
};

pub static WORD_REPEN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("table"),
        dictgen::InsensitiveStr::Ascii("tence"),
        dictgen::InsensitiveStr::Ascii("tent"),
    ],
    values: &[&["repeatable"], &["repentance"], &["repentant"]],
    range: 4..=5,
};

static WORD_REPEL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REPEL_CHILDREN),
    value: None,
};

pub static WORD_REPEL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("er"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("l"),
        dictgen::InsensitiveStr::Ascii("ls"),
    ],
    values: &[
        &["repelled"],
        &["repeller"],
        &["repelling"],
        &["repel"],
        &["repels"],
    ],
    range: 1..=3,
};

static WORD_REPEI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REPEI_CHILDREN),
    value: None,
};

pub static WORD_REPEI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("tion")],
    values: &[&["repetition"]],
    range: 4..=4,
};

static WORD_REPED_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REPED_CHILDREN),
    value: None,
};

pub static WORD_REPED_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ability"),
        dictgen::InsensitiveStr::Ascii("able"),
    ],
    values: &[&["repeatability"], &["repeatable"]],
    range: 4..=7,
};

static WORD_REPEC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REPEC_CHILDREN),
    value: None,
};

pub static WORD_REPEC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("table"),
        dictgen::InsensitiveStr::Ascii("ted"),
        dictgen::InsensitiveStr::Ascii("ting"),
        dictgen::InsensitiveStr::Ascii("tive"),
        dictgen::InsensitiveStr::Ascii("tively"),
        dictgen::InsensitiveStr::Ascii("ts"),
    ],
    values: &[
        &["respect"],
        &["repeatable", "respectable"],
        &["respected"],
        &["respecting"],
        &["receptive", "respective"],
        &["respectively"],
        &["respects"],
    ],
    range: 1..=6,
};

static WORD_REPEA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REPEA_CHILDREN),
    value: None,
};

pub static WORD_REPEA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("dedly"),
        dictgen::InsensitiveStr::Ascii("detly"),
        dictgen::InsensitiveStr::Ascii("rable"),
        dictgen::InsensitiveStr::Ascii("redly"),
        dictgen::InsensitiveStr::Ascii("st"),
        dictgen::InsensitiveStr::Ascii("tadly"),
        dictgen::InsensitiveStr::Ascii("tae"),
        dictgen::InsensitiveStr::Ascii("teadly"),
        dictgen::InsensitiveStr::Ascii("tedlt"),
        dictgen::InsensitiveStr::Ascii("tedy"),
        dictgen::InsensitiveStr::Ascii("tes"),
        dictgen::InsensitiveStr::Ascii("tetly"),
        dictgen::InsensitiveStr::Ascii("tible"),
        dictgen::InsensitiveStr::Ascii("tidly"),
        dictgen::InsensitiveStr::Ascii("tly"),
    ],
    values: &[
        &["repeatedly"],
        &["repeatedly"],
        &["repeatable"],
        &["repealed"],
        &["repeats"],
        &["repeatedly"],
        &["repeatable"],
        &["repeatedly"],
        &["repealed"],
        &["repeatedly"],
        &["repeats"],
        &["repeatedly"],
        &["repeatable"],
        &["repeatedly"],
        &["repeatedly"],
    ],
    range: 2..=6,
};

static WORD_REPB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REPB_CHILDREN),
    value: None,
};

pub static WORD_REPB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("lic"),
        dictgen::InsensitiveStr::Ascii("lican"),
        dictgen::InsensitiveStr::Ascii("licans"),
        dictgen::InsensitiveStr::Ascii("lics"),
        dictgen::InsensitiveStr::Ascii("ulic"),
        dictgen::InsensitiveStr::Ascii("ulican"),
        dictgen::InsensitiveStr::Ascii("ulicans"),
    ],
    values: &[
        &["republic"],
        &["republican"],
        &["republicans"],
        &["republics"],
        &["republic"],
        &["republican"],
        &["republicans"],
    ],
    range: 3..=7,
};

static WORD_REPA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REPA_CHILDREN),
    value: None,
};

pub static WORD_REPA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ce"),
        dictgen::InsensitiveStr::Ascii("ced"),
        dictgen::InsensitiveStr::Ascii("cement"),
        dictgen::InsensitiveStr::Ascii("cements"),
        dictgen::InsensitiveStr::Ascii("ces"),
        dictgen::InsensitiveStr::Ascii("cing"),
        dictgen::InsensitiveStr::Ascii("ckge"),
        dictgen::InsensitiveStr::Ascii("ckged"),
        dictgen::InsensitiveStr::Ascii("ird"),
        dictgen::InsensitiveStr::Ascii("ires"),
        dictgen::InsensitiveStr::Ascii("itnt"),
        dictgen::InsensitiveStr::Ascii("lcement"),
        dictgen::InsensitiveStr::Ascii("lcements"),
        dictgen::InsensitiveStr::Ascii("lces"),
        dictgen::InsensitiveStr::Ascii("lying"),
        dictgen::InsensitiveStr::Ascii("lys"),
        dictgen::InsensitiveStr::Ascii("nt"),
        dictgen::InsensitiveStr::Ascii("nts"),
        dictgen::InsensitiveStr::Ascii("ramterisation"),
        dictgen::InsensitiveStr::Ascii("ramterise"),
        dictgen::InsensitiveStr::Ascii("ramterised"),
        dictgen::InsensitiveStr::Ascii("ramterises"),
        dictgen::InsensitiveStr::Ascii("ramterising"),
        dictgen::InsensitiveStr::Ascii("ramterization"),
        dictgen::InsensitiveStr::Ascii("ramterize"),
        dictgen::InsensitiveStr::Ascii("ramterized"),
        dictgen::InsensitiveStr::Ascii("ramterizes"),
        dictgen::InsensitiveStr::Ascii("ramterizing"),
        dictgen::InsensitiveStr::Ascii("ried"),
        dictgen::InsensitiveStr::Ascii("tition"),
        dictgen::InsensitiveStr::Ascii("twar"),
        dictgen::InsensitiveStr::Ascii("twars"),
    ],
    values: &[
        &["replace"],
        &["replaced"],
        &["replacement"],
        &["replacements"],
        &["replaces"],
        &["replacing"],
        &["repackage"],
        &["repackaged"],
        &["repaired"],
        &["repairs"],
        &["repaint"],
        &["replacement"],
        &["replacements"],
        &["replaces"],
        &["replaying"],
        &["replays"],
        &["repaint", "repent"],
        &["repaints", "repents"],
        &["reparameterisation"],
        &["reparameterise"],
        &["reparameterised"],
        &["reparameterises"],
        &["reparameterising"],
        &["reparameterization"],
        &["reparameterize"],
        &["reparameterized"],
        &["reparameterizes"],
        &["reparameterizing"],
        &["repaired"],
        &["repetition", "repartition"],
        &["repertoire"],
        &["repertoires"],
    ],
    range: 2..=13,
};

static WORD_REO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REO_CHILDREN),
    value: None,
};

pub static WORD_REO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("admap"),
        dictgen::InsensitiveStr::Ascii("ccurrence"),
        dictgen::InsensitiveStr::Ascii("cmpression"),
        dictgen::InsensitiveStr::Ascii("curring"),
        dictgen::InsensitiveStr::Ascii("der"),
        dictgen::InsensitiveStr::Ascii("mvable"),
        dictgen::InsensitiveStr::Ascii("mve"),
        dictgen::InsensitiveStr::Ascii("mved"),
        dictgen::InsensitiveStr::Ascii("mves"),
        dictgen::InsensitiveStr::Ascii("mving"),
        dictgen::InsensitiveStr::Ascii("pended"),
        dictgen::InsensitiveStr::Ascii("port"),
        dictgen::InsensitiveStr::Ascii("psitory"),
        dictgen::InsensitiveStr::Ascii("rd"),
        dictgen::InsensitiveStr::Ascii("rded"),
        dictgen::InsensitiveStr::Ascii("rer"),
        dictgen::InsensitiveStr::Ascii("rganision"),
        dictgen::InsensitiveStr::Ascii("rginised"),
        dictgen::InsensitiveStr::Ascii("rginized"),
        dictgen::InsensitiveStr::Ascii("snable"),
        dictgen::InsensitiveStr::Ascii("sne"),
        dictgen::InsensitiveStr::Ascii("surce"),
        dictgen::InsensitiveStr::Ascii("surced"),
        dictgen::InsensitiveStr::Ascii("surces"),
        dictgen::InsensitiveStr::Ascii("surcing"),
        dictgen::InsensitiveStr::Ascii("unded"),
        dictgen::InsensitiveStr::Ascii("urce"),
        dictgen::InsensitiveStr::Ascii("uted"),
        dictgen::InsensitiveStr::Ascii("utes"),
        dictgen::InsensitiveStr::Ascii("ve"),
        dictgen::InsensitiveStr::Ascii("wrked"),
    ],
    values: &[
        &["roadmap"],
        &["recurrence"],
        &["recompression"],
        &["reoccurring", "recurring"],
        &["reorder"],
        &["removable"],
        &["remove"],
        &["removed"],
        &["removes"],
        &["removing"],
        &["reopened"],
        &["report"],
        &["repository"],
        &["record"],
        &["reorder"],
        &["reorder"],
        &["reorganisation"],
        &["reorganised"],
        &["reorganized"],
        &["reasonable"],
        &["reason"],
        &["resource"],
        &["resourced"],
        &["resources"],
        &["resourcing"],
        &["rounded"],
        &["resource"],
        &["routed", "rerouted"],
        &["routes"],
        &["remove"],
        &["reworked"],
    ],
    range: 2..=10,
};

static WORD_REN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_REN_CHILDREN),
    value: None,
};

static WORD_REN_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_RENA_NODE),
    None,
    None,
    Some(&WORD_REND_NODE),
    Some(&WORD_RENE_NODE),
    Some(&WORD_RENF_NODE),
    None,
    None,
    Some(&WORD_RENI_NODE),
    None,
    Some(&WORD_RENK_NODE),
    None,
    Some(&WORD_RENM_NODE),
    Some(&WORD_RENN_NODE),
    Some(&WORD_RENO_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_RENT_NODE),
    Some(&WORD_RENU_NODE),
    None,
    Some(&WORD_RENW_NODE),
    None,
    Some(&WORD_RENY_NODE),
    None,
];

static WORD_RENY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RENY_CHILDREN),
    value: None,
};

pub static WORD_RENY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("olds")],
    values: &[&["reynolds"]],
    range: 4..=4,
};

static WORD_RENW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RENW_CHILDREN),
    value: None,
};

pub static WORD_RENW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("eables")],
    values: &[&["renewables"]],
    range: 6..=6,
};

static WORD_RENU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RENU_CHILDREN),
    value: None,
};

pub static WORD_RENU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ion")],
    values: &[&["reunion"]],
    range: 3..=3,
};

static WORD_RENT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RENT_CHILDREN),
    value: None,
};

pub static WORD_RENT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eris"),
        dictgen::InsensitiveStr::Ascii("ime"),
        dictgen::InsensitiveStr::Ascii("ors"),
        dictgen::InsensitiveStr::Ascii("res"),
    ],
    values: &[&["renters"], &["runtime"], &["renters"], &["renters"]],
    range: 3..=4,
};

static WORD_RENO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RENO_CHILDREN),
    value: None,
};

pub static WORD_RENO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("sance"),
        dictgen::InsensitiveStr::Ascii("un"),
        dictgen::InsensitiveStr::Ascii("uned"),
        dictgen::InsensitiveStr::Ascii("ylds"),
    ],
    values: &[
        &["renaissance", "resonance"],
        &["renown"],
        &["renounced", "renowned"],
        &["reynolds"],
    ],
    range: 2..=5,
};

static WORD_RENN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RENN_CHILDREN),
    value: None,
};

pub static WORD_RENN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aisance"),
        dictgen::InsensitiveStr::Ascii("ovate"),
        dictgen::InsensitiveStr::Ascii("ovated"),
        dictgen::InsensitiveStr::Ascii("ovating"),
        dictgen::InsensitiveStr::Ascii("ovation"),
    ],
    values: &[
        &["renaissance"],
        &["renovate"],
        &["renovated"],
        &["renovating"],
        &["renovation"],
    ],
    range: 5..=7,
};

static WORD_RENM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RENM_CHILDREN),
    value: None,
};

pub static WORD_RENM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ant"),
        dictgen::InsensitiveStr::Ascii("ants"),
    ],
    values: &[&["remnant"], &["remnants"]],
    range: 3..=4,
};

static WORD_RENK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RENK_CHILDREN),
    value: None,
};

pub static WORD_RENK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("eton")],
    values: &[&["renekton"]],
    range: 4..=4,
};

static WORD_RENI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RENI_CHILDREN),
    value: None,
};

pub static WORD_RENI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("assance"),
        dictgen::InsensitiveStr::Ascii("forcements"),
        dictgen::InsensitiveStr::Ascii("g"),
        dictgen::InsensitiveStr::Ascii("ged"),
        dictgen::InsensitiveStr::Ascii("ger"),
        dictgen::InsensitiveStr::Ascii("ging"),
    ],
    values: &[
        &["renaissance"],
        &["reinforcements"],
        &["renege"],
        &["reneged"],
        &["reneger"],
        &["reneging"],
    ],
    range: 1..=10,
};

static WORD_RENF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RENF_CHILDREN),
    value: None,
};

pub static WORD_RENF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("orce"),
        dictgen::InsensitiveStr::Ascii("orced"),
        dictgen::InsensitiveStr::Ascii("orcement"),
        dictgen::InsensitiveStr::Ascii("orcements"),
        dictgen::InsensitiveStr::Ascii("orces"),
    ],
    values: &[
        &["reinforce"],
        &["reinforced"],
        &["reinforcement"],
        &["reinforcements"],
        &["reinforces"],
    ],
    range: 4..=9,
};

static WORD_RENE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_RENE_CHILDREN),
    value: None,
};

static WORD_RENE_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_RENEA_NODE),
    None,
    None,
    Some(&WORD_RENED_NODE),
    None,
    None,
    Some(&WORD_RENEG_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_RENET_NODE),
    None,
    None,
    Some(&WORD_RENEW_NODE),
    None,
    None,
    None,
];

static WORD_RENEW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RENEW_CHILDREN),
    value: None,
};

pub static WORD_RENEW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("abe"),
        dictgen::InsensitiveStr::Ascii("abels"),
        dictgen::InsensitiveStr::Ascii("eal"),
        dictgen::InsensitiveStr::Ascii("ebles"),
        dictgen::InsensitiveStr::Ascii("l"),
    ],
    values: &[
        &["renewables"],
        &["renewables"],
        &["renewal"],
        &["renewables"],
        &["renewal"],
    ],
    range: 1..=5,
};

static WORD_RENET_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RENET_CHILDREN),
    value: None,
};

pub static WORD_RENET_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("kon")],
    values: &[&["renekton"]],
    range: 3..=3,
};

static WORD_RENEG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_RENEG_CHILDREN),
    value: None,
};

static WORD_RENEG_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_RENEGA_NODE),
    None,
    None,
    None,
    Some(&WORD_RENEGE_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_RENEGO_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_RENEGO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_RENEGO_CHILDREN),
    value: None,
};

static WORD_RENEGO_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_RENEGOA_NODE),
    None,
    Some(&WORD_RENEGOC_NODE),
    None,
    None,
    None,
    Some(&WORD_RENEGOG_NODE),
    None,
    Some(&WORD_RENEGOI_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_RENEGOP_NODE),
    None,
    None,
    Some(&WORD_RENEGOS_NODE),
    Some(&WORD_RENEGOT_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_RENEGOZ_NODE),
];

static WORD_RENEGOZ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RENEGOZ_CHILDREN),
    value: None,
};

pub static WORD_RENEGOZ_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("iable"),
            dictgen::InsensitiveStr::Ascii("iate"),
            dictgen::InsensitiveStr::Ascii("iated"),
            dictgen::InsensitiveStr::Ascii("iates"),
            dictgen::InsensitiveStr::Ascii("iating"),
            dictgen::InsensitiveStr::Ascii("iation"),
            dictgen::InsensitiveStr::Ascii("iations"),
            dictgen::InsensitiveStr::Ascii("iator"),
            dictgen::InsensitiveStr::Ascii("iators"),
        ],
        values: &[
            &["renegotiable"],
            &["renegotiate"],
            &["renegotiated"],
            &["renegotiates"],
            &["renegotiating"],
            &["renegotiation"],
            &["renegotiations"],
            &["renegotiator"],
            &["renegotiators"],
        ],
        range: 4..=7,
    };

static WORD_RENEGOT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_RENEGOT_CHILDREN),
    value: None,
};

static WORD_RENEGOT_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_RENEGOTA_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_RENEGOTH_NODE),
    Some(&WORD_RENEGOTI_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_RENEGOTI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_RENEGOTI_CHILDREN),
    value: None,
};

static WORD_RENEGOTI_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    Some(&WORD_RENEGOTIB_NODE),
    Some(&WORD_RENEGOTIC_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_RENEGOTIO_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_RENEGOTIT_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_RENEGOTIT_NODE: dictgen::DictTrieNode<&'static [&'static str]> =
    dictgen::DictTrieNode {
        children: dictgen::DictTrieChild::Flat(&WORD_RENEGOTIT_CHILDREN),
        value: None,
    };

pub static WORD_RENEGOTIT_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("able"),
            dictgen::InsensitiveStr::Ascii("ae"),
            dictgen::InsensitiveStr::Ascii("aed"),
            dictgen::InsensitiveStr::Ascii("aes"),
            dictgen::InsensitiveStr::Ascii("aing"),
            dictgen::InsensitiveStr::Ascii("aion"),
            dictgen::InsensitiveStr::Ascii("aions"),
            dictgen::InsensitiveStr::Ascii("aor"),
            dictgen::InsensitiveStr::Ascii("aors"),
            dictgen::InsensitiveStr::Ascii("ate"),
            dictgen::InsensitiveStr::Ascii("ated"),
            dictgen::InsensitiveStr::Ascii("ates"),
            dictgen::InsensitiveStr::Ascii("ating"),
            dictgen::InsensitiveStr::Ascii("ation"),
            dictgen::InsensitiveStr::Ascii("ations"),
            dictgen::InsensitiveStr::Ascii("ator"),
            dictgen::InsensitiveStr::Ascii("ators"),
            dictgen::InsensitiveStr::Ascii("e"),
            dictgen::InsensitiveStr::Ascii("ed"),
            dictgen::InsensitiveStr::Ascii("es"),
            dictgen::InsensitiveStr::Ascii("ing"),
            dictgen::InsensitiveStr::Ascii("ion"),
            dictgen::InsensitiveStr::Ascii("ions"),
            dictgen::InsensitiveStr::Ascii("or"),
            dictgen::InsensitiveStr::Ascii("ors"),
        ],
        values: &[
            &["renegotiable"],
            &["renegotiate"],
            &["renegotiated"],
            &["renegotiates"],
            &["renegotiating"],
            &["renegotiation"],
            &["renegotiations"],
            &["renegotiator"],
            &["renegotiators"],
            &["renegotiate"],
            &["renegotiated"],
            &["renegotiates"],
            &["renegotiating"],
            &["renegotiation"],
            &["renegotiations"],
            &["renegotiator"],
            &["renegotiators"],
            &["renegotiate"],
            &["renegotiated"],
            &["renegotiates"],
            &["renegotiating"],
            &["renegotiation"],
            &["renegotiations"],
            &["renegotiator"],
            &["renegotiators"],
        ],
        range: 1..=6,
    };

static WORD_RENEGOTIO_NODE: dictgen::DictTrieNode<&'static [&'static str]> =
    dictgen::DictTrieNode {
        children: dictgen::DictTrieChild::Flat(&WORD_RENEGOTIO_CHILDREN),
        value: None,
    };

pub static WORD_RENEGOTIO_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("able"),
            dictgen::InsensitiveStr::Ascii("ate"),
            dictgen::InsensitiveStr::Ascii("ated"),
            dictgen::InsensitiveStr::Ascii("ates"),
            dictgen::InsensitiveStr::Ascii("ating"),
            dictgen::InsensitiveStr::Ascii("ation"),
            dictgen::InsensitiveStr::Ascii("ations"),
            dictgen::InsensitiveStr::Ascii("ator"),
            dictgen::InsensitiveStr::Ascii("ators"),
            dictgen::InsensitiveStr::Ascii("ble"),
            dictgen::InsensitiveStr::Ascii("n"),
            dictgen::InsensitiveStr::Ascii("nable"),
            dictgen::InsensitiveStr::Ascii("nate"),
            dictgen::InsensitiveStr::Ascii("nated"),
            dictgen::InsensitiveStr::Ascii("nates"),
            dictgen::InsensitiveStr::Ascii("nating"),
            dictgen::InsensitiveStr::Ascii("nation"),
            dictgen::InsensitiveStr::Ascii("nations"),
            dictgen::InsensitiveStr::Ascii("nator"),
            dictgen::InsensitiveStr::Ascii("nators"),
            dictgen::InsensitiveStr::Ascii("ns"),
            dictgen::InsensitiveStr::Ascii("table"),
            dictgen::InsensitiveStr::Ascii("tate"),
            dictgen::InsensitiveStr::Ascii("tated"),
            dictgen::InsensitiveStr::Ascii("tates"),
            dictgen::InsensitiveStr::Ascii("tating"),
            dictgen::InsensitiveStr::Ascii("tation"),
            dictgen::InsensitiveStr::Ascii("tations"),
            dictgen::InsensitiveStr::Ascii("tator"),
            dictgen::InsensitiveStr::Ascii("tators"),
            dictgen::InsensitiveStr::Ascii("te"),
            dictgen::InsensitiveStr::Ascii("ted"),
            dictgen::InsensitiveStr::Ascii("tes"),
            dictgen::InsensitiveStr::Ascii("ting"),
            dictgen::InsensitiveStr::Ascii("tion"),
            dictgen::InsensitiveStr::Ascii("tions"),
            dictgen::InsensitiveStr::Ascii("tor"),
            dictgen::InsensitiveStr::Ascii("tors"),
        ],
        values: &[
            &["renegotiable"],
            &["renegotiate"],
            &["renegotiated"],
            &["renegotiates"],
            &["renegotiating"],
            &["renegotiation"],
            &["renegotiations"],
            &["renegotiator"],
            &["renegotiators"],
            &["renegotiable"],
            &["renegotiation"],
            &["renegotiable"],
            &["renegotiate"],
            &["renegotiated"],
            &["renegotiates"],
            &["renegotiating"],
            &["renegotiation"],
            &["renegotiations"],
            &["renegotiator"],
            &["renegotiators"],
            &["renegotiations"],
            &["renegotiable"],
            &["renegotiate"],
            &["renegotiated"],
            &["renegotiates"],
            &["renegotiating"],
            &["renegotiation"],
            &["renegotiations"],
            &["renegotiator"],
            &["renegotiators"],
            &["renegotiate"],
            &["renegotiated"],
            &["renegotiates"],
            &["renegotiating"],
            &["renegotiation"],
            &["renegotiations"],
            &["renegotiator"],
            &["renegotiators"],
        ],
        range: 1..=7,
    };

static WORD_RENEGOTIC_NODE: dictgen::DictTrieNode<&'static [&'static str]> =
    dictgen::DictTrieNode {
        children: dictgen::DictTrieChild::Flat(&WORD_RENEGOTIC_CHILDREN),
        value: None,
    };

pub static WORD_RENEGOTIC_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("able"),
            dictgen::InsensitiveStr::Ascii("ate"),
            dictgen::InsensitiveStr::Ascii("ated"),
            dictgen::InsensitiveStr::Ascii("ates"),
            dictgen::InsensitiveStr::Ascii("ating"),
            dictgen::InsensitiveStr::Ascii("ation"),
            dictgen::InsensitiveStr::Ascii("ations"),
            dictgen::InsensitiveStr::Ascii("ator"),
            dictgen::InsensitiveStr::Ascii("ators"),
        ],
        values: &[
            &["renegotiable"],
            &["renegotiate"],
            &["renegotiated"],
            &["renegotiates"],
            &["renegotiating"],
            &["renegotiation"],
            &["renegotiations"],
            &["renegotiator"],
            &["renegotiators"],
        ],
        range: 3..=6,
    };

static WORD_RENEGOTIB_NODE: dictgen::DictTrieNode<&'static [&'static str]> =
    dictgen::DictTrieNode {
        children: dictgen::DictTrieChild::Flat(&WORD_RENEGOTIB_CHILDREN),
        value: None,
    };

pub static WORD_RENEGOTIB_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[dictgen::InsensitiveStr::Ascii("le")],
        values: &[&["renegotiable"]],
        range: 2..=2,
    };

static WORD_RENEGOTH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RENEGOTH_CHILDREN),
    value: None,
};

pub static WORD_RENEGOTH_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("iable"),
            dictgen::InsensitiveStr::Ascii("iate"),
            dictgen::InsensitiveStr::Ascii("iated"),
            dictgen::InsensitiveStr::Ascii("iates"),
            dictgen::InsensitiveStr::Ascii("iating"),
            dictgen::InsensitiveStr::Ascii("iation"),
            dictgen::InsensitiveStr::Ascii("iations"),
            dictgen::InsensitiveStr::Ascii("iator"),
            dictgen::InsensitiveStr::Ascii("iators"),
        ],
        values: &[
            &["renegotiable"],
            &["renegotiate"],
            &["renegotiated"],
            &["renegotiates"],
            &["renegotiating"],
            &["renegotiation"],
            &["renegotiations"],
            &["renegotiator"],
            &["renegotiators"],
        ],
        range: 4..=7,
    };

static WORD_RENEGOTA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RENEGOTA_CHILDREN),
    value: None,
};

pub static WORD_RENEGOTA_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("ble"),
            dictgen::InsensitiveStr::Ascii("iable"),
            dictgen::InsensitiveStr::Ascii("iate"),
            dictgen::InsensitiveStr::Ascii("iated"),
            dictgen::InsensitiveStr::Ascii("iates"),
            dictgen::InsensitiveStr::Ascii("iating"),
            dictgen::InsensitiveStr::Ascii("iation"),
            dictgen::InsensitiveStr::Ascii("iations"),
            dictgen::InsensitiveStr::Ascii("iator"),
            dictgen::InsensitiveStr::Ascii("iators"),
            dictgen::InsensitiveStr::Ascii("ible"),
            dictgen::InsensitiveStr::Ascii("ite"),
            dictgen::InsensitiveStr::Ascii("ited"),
            dictgen::InsensitiveStr::Ascii("ites"),
            dictgen::InsensitiveStr::Ascii("iting"),
            dictgen::InsensitiveStr::Ascii("ition"),
            dictgen::InsensitiveStr::Ascii("itions"),
            dictgen::InsensitiveStr::Ascii("itor"),
            dictgen::InsensitiveStr::Ascii("itors"),
            dictgen::InsensitiveStr::Ascii("te"),
            dictgen::InsensitiveStr::Ascii("ted"),
            dictgen::InsensitiveStr::Ascii("tes"),
            dictgen::InsensitiveStr::Ascii("tiable"),
            dictgen::InsensitiveStr::Ascii("tiate"),
            dictgen::InsensitiveStr::Ascii("tiated"),
            dictgen::InsensitiveStr::Ascii("tiates"),
            dictgen::InsensitiveStr::Ascii("tiating"),
            dictgen::InsensitiveStr::Ascii("tiation"),
            dictgen::InsensitiveStr::Ascii("tiations"),
            dictgen::InsensitiveStr::Ascii("tiator"),
            dictgen::InsensitiveStr::Ascii("tiators"),
            dictgen::InsensitiveStr::Ascii("tible"),
            dictgen::InsensitiveStr::Ascii("tie"),
            dictgen::InsensitiveStr::Ascii("tied"),
            dictgen::InsensitiveStr::Ascii("ties"),
            dictgen::InsensitiveStr::Ascii("ting"),
            dictgen::InsensitiveStr::Ascii("tion"),
            dictgen::InsensitiveStr::Ascii("tions"),
            dictgen::InsensitiveStr::Ascii("tior"),
            dictgen::InsensitiveStr::Ascii("tiors"),
            dictgen::InsensitiveStr::Ascii("tor"),
            dictgen::InsensitiveStr::Ascii("tors"),
        ],
        values: &[
            &["renegotiable"],
            &["renegotiable"],
            &["renegotiate"],
            &["renegotiated"],
            &["renegotiates"],
            &["renegotiating"],
            &["renegotiation"],
            &["renegotiations"],
            &["renegotiator"],
            &["renegotiators"],
            &["renegotiable"],
            &["renegotiate"],
            &["renegotiated"],
            &["renegotiates"],
            &["renegotiating"],
            &["renegotiation"],
            &["renegotiations"],
            &["renegotiator"],
            &["renegotiators"],
            &["renegotiate"],
            &["renegotiated"],
            &["renegotiates"],
            &["renegotiable"],
            &["renegotiate"],
            &["renegotiated"],
            &["renegotiates"],
            &["renegotiating"],
            &["renegotiation"],
            &["renegotiations"],
            &["renegotiator"],
            &["renegotiators"],
            &["renegotiable"],
            &["renegotiate"],
            &["renegotiated"],
            &["renegotiates"],
            &["renegotiating"],
            &["renegotiation"],
            &["renegotiations"],
            &["renegotiator"],
            &["renegotiators"],
            &["renegotiator"],
            &["renegotiators"],
        ],
        range: 2..=8,
    };

static WORD_RENEGOS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RENEGOS_CHILDREN),
    value: None,
};

pub static WORD_RENEGOS_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("iable"),
            dictgen::InsensitiveStr::Ascii("iate"),
            dictgen::InsensitiveStr::Ascii("iated"),
            dictgen::InsensitiveStr::Ascii("iates"),
            dictgen::InsensitiveStr::Ascii("iating"),
            dictgen::InsensitiveStr::Ascii("iation"),
            dictgen::InsensitiveStr::Ascii("iations"),
            dictgen::InsensitiveStr::Ascii("iator"),
            dictgen::InsensitiveStr::Ascii("iators"),
        ],
        values: &[
            &["renegotiable"],
            &["renegotiate"],
            &["renegotiated"],
            &["renegotiates"],
            &["renegotiating"],
            &["renegotiation"],
            &["renegotiations"],
            &["renegotiator"],
            &["renegotiators"],
        ],
        range: 4..=7,
    };

static WORD_RENEGOP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RENEGOP_CHILDREN),
    value: None,
};

pub static WORD_RENEGOP_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("tionsotiable"),
            dictgen::InsensitiveStr::Ascii("tionsotiate"),
            dictgen::InsensitiveStr::Ascii("tionsotiated"),
            dictgen::InsensitiveStr::Ascii("tionsotiates"),
            dictgen::InsensitiveStr::Ascii("tionsotiating"),
            dictgen::InsensitiveStr::Ascii("tionsotiation"),
            dictgen::InsensitiveStr::Ascii("tionsotiations"),
            dictgen::InsensitiveStr::Ascii("tionsotiator"),
            dictgen::InsensitiveStr::Ascii("tionsotiators"),
        ],
        values: &[
            &["renegotiable"],
            &["renegotiate"],
            &["renegotiated"],
            &["renegotiates"],
            &["renegotiating"],
            &["renegotiation"],
            &["renegotiations"],
            &["renegotiator"],
            &["renegotiators"],
        ],
        range: 11..=14,
    };

static WORD_RENEGOI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RENEGOI_CHILDREN),
    value: None,
};

pub static WORD_RENEGOI_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("table"),
            dictgen::InsensitiveStr::Ascii("tate"),
            dictgen::InsensitiveStr::Ascii("tated"),
            dictgen::InsensitiveStr::Ascii("tates"),
            dictgen::InsensitiveStr::Ascii("tating"),
            dictgen::InsensitiveStr::Ascii("tation"),
            dictgen::InsensitiveStr::Ascii("tations"),
            dictgen::InsensitiveStr::Ascii("tator"),
            dictgen::InsensitiveStr::Ascii("tators"),
        ],
        values: &[
            &["renegotiable"],
            &["renegotiate"],
            &["renegotiated"],
            &["renegotiates"],
            &["renegotiating"],
            &["renegotiation"],
            &["renegotiations"],
            &["renegotiator"],
            &["renegotiators"],
        ],
        range: 4..=7,
    };

static WORD_RENEGOG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RENEGOG_CHILDREN),
    value: None,
};

pub static WORD_RENEGOG_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("tiable"),
            dictgen::InsensitiveStr::Ascii("tiate"),
            dictgen::InsensitiveStr::Ascii("tiated"),
            dictgen::InsensitiveStr::Ascii("tiates"),
            dictgen::InsensitiveStr::Ascii("tiating"),
            dictgen::InsensitiveStr::Ascii("tiation"),
            dictgen::InsensitiveStr::Ascii("tiations"),
            dictgen::InsensitiveStr::Ascii("tiator"),
            dictgen::InsensitiveStr::Ascii("tiators"),
        ],
        values: &[
            &["renegotiable"],
            &["renegotiate"],
            &["renegotiated"],
            &["renegotiates"],
            &["renegotiating"],
            &["renegotiation"],
            &["renegotiations"],
            &["renegotiator"],
            &["renegotiators"],
        ],
        range: 5..=8,
    };

static WORD_RENEGOC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RENEGOC_CHILDREN),
    value: None,
};

pub static WORD_RENEGOC_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("iable"),
            dictgen::InsensitiveStr::Ascii("iate"),
            dictgen::InsensitiveStr::Ascii("iated"),
            dictgen::InsensitiveStr::Ascii("iates"),
            dictgen::InsensitiveStr::Ascii("iating"),
            dictgen::InsensitiveStr::Ascii("iation"),
            dictgen::InsensitiveStr::Ascii("iations"),
            dictgen::InsensitiveStr::Ascii("iator"),
            dictgen::InsensitiveStr::Ascii("iators"),
        ],
        values: &[
            &["renegotiable"],
            &["renegotiate"],
            &["renegotiated"],
            &["renegotiates"],
            &["renegotiating"],
            &["renegotiation"],
            &["renegotiations"],
            &["renegotiator"],
            &["renegotiators"],
        ],
        range: 4..=7,
    };

static WORD_RENEGOA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RENEGOA_CHILDREN),
    value: None,
};

pub static WORD_RENEGOA_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("ble"),
            dictgen::InsensitiveStr::Ascii("te"),
            dictgen::InsensitiveStr::Ascii("ted"),
            dictgen::InsensitiveStr::Ascii("tes"),
            dictgen::InsensitiveStr::Ascii("tiable"),
            dictgen::InsensitiveStr::Ascii("tiate"),
            dictgen::InsensitiveStr::Ascii("tiated"),
            dictgen::InsensitiveStr::Ascii("tiates"),
            dictgen::InsensitiveStr::Ascii("tiating"),
            dictgen::InsensitiveStr::Ascii("tiation"),
            dictgen::InsensitiveStr::Ascii("tiations"),
            dictgen::InsensitiveStr::Ascii("tiator"),
            dictgen::InsensitiveStr::Ascii("tiators"),
            dictgen::InsensitiveStr::Ascii("ting"),
            dictgen::InsensitiveStr::Ascii("tion"),
            dictgen::InsensitiveStr::Ascii("tions"),
            dictgen::InsensitiveStr::Ascii("tor"),
            dictgen::InsensitiveStr::Ascii("tors"),
        ],
        values: &[
            &["renegotiable"],
            &["renegotiate"],
            &["renegotiated"],
            &["renegotiates"],
            &["renegotiable"],
            &["renegotiate"],
            &["renegotiated"],
            &["renegotiates"],
            &["renegotiating"],
            &["renegotiation"],
            &["renegotiations"],
            &["renegotiator"],
            &["renegotiators"],
            &["renegotiating"],
            &["renegotiation"],
            &["renegotiations"],
            &["renegotiator"],
            &["renegotiators"],
        ],
        range: 2..=8,
    };

static WORD_RENEGE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RENEGE_CHILDREN),
    value: None,
};

pub static WORD_RENEGE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("rate"),
        dictgen::InsensitiveStr::Ascii("ration"),
    ],
    values: &[&["regenerate"], &["regeneration"]],
    range: 4..=6,
};

static WORD_RENEGA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RENEGA_CHILDREN),
    value: None,
};

pub static WORD_RENEGA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("ted"),
        dictgen::InsensitiveStr::Ascii("tiotiable"),
        dictgen::InsensitiveStr::Ascii("tiotiate"),
        dictgen::InsensitiveStr::Ascii("tiotiated"),
        dictgen::InsensitiveStr::Ascii("tiotiates"),
        dictgen::InsensitiveStr::Ascii("tiotiating"),
        dictgen::InsensitiveStr::Ascii("tiotiation"),
        dictgen::InsensitiveStr::Ascii("tiotiations"),
        dictgen::InsensitiveStr::Ascii("tiotiator"),
        dictgen::InsensitiveStr::Ascii("tiotiators"),
    ],
    values: &[
        &["renegade"],
        &["renegade"],
        &["renegotiable"],
        &["renegotiate"],
        &["renegotiated"],
        &["renegotiates"],
        &["renegotiating"],
        &["renegotiation"],
        &["renegotiations"],
        &["renegotiator"],
        &["renegotiators"],
    ],
    range: 1..=11,
};

static WORD_RENED_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RENED_CHILDREN),
    value: None,
};

pub static WORD_RENED_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ered")],
    values: &[&["rende", "rendered"]],
    range: 4..=4,
};

static WORD_RENEA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RENEA_CHILDREN),
    value: None,
};

pub static WORD_RENEA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("gde")],
    values: &[&["renegade"]],
    range: 3..=3,
};

static WORD_REND_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REND_CHILDREN),
    value: None,
};

pub static WORD_REND_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ayvoo"),
        dictgen::InsensitiveStr::Ascii("ayvooed"),
        dictgen::InsensitiveStr::Ascii("ayvou"),
        dictgen::InsensitiveStr::Ascii("ayvoued"),
        dictgen::InsensitiveStr::Ascii("azyvoo"),
        dictgen::InsensitiveStr::Ascii("azyvooed"),
        dictgen::InsensitiveStr::Ascii("azyvou"),
        dictgen::InsensitiveStr::Ascii("azyvoued"),
        dictgen::InsensitiveStr::Ascii("eradble"),
        dictgen::InsensitiveStr::Ascii("erd"),
        dictgen::InsensitiveStr::Ascii("ereds"),
        dictgen::InsensitiveStr::Ascii("ereing"),
        dictgen::InsensitiveStr::Ascii("ererd"),
        dictgen::InsensitiveStr::Ascii("erered"),
        dictgen::InsensitiveStr::Ascii("ererers"),
        dictgen::InsensitiveStr::Ascii("erering"),
        dictgen::InsensitiveStr::Ascii("eres"),
        dictgen::InsensitiveStr::Ascii("erning"),
        dictgen::InsensitiveStr::Ascii("err"),
        dictgen::InsensitiveStr::Ascii("erring"),
        dictgen::InsensitiveStr::Ascii("evous"),
        dictgen::InsensitiveStr::Ascii("ezous"),
        dictgen::InsensitiveStr::Ascii("ired"),
        dictgen::InsensitiveStr::Ascii("irer"),
        dictgen::InsensitiveStr::Ascii("irers"),
        dictgen::InsensitiveStr::Ascii("iring"),
        dictgen::InsensitiveStr::Ascii("itioon"),
        dictgen::InsensitiveStr::Ascii("ring"),
        dictgen::InsensitiveStr::Ascii("tion"),
    ],
    values: &[
        &["rendezvous"],
        &["rendezvoused"],
        &["rendezvous"],
        &["rendezvoused"],
        &["rendezvous"],
        &["rendezvoused"],
        &["rendezvous"],
        &["rendezvoused"],
        &["renderable"],
        &["rendered"],
        &["rendered", "renders"],
        &["rendering"],
        &["rendered"],
        &["rendered"],
        &["renderers"],
        &["rendering"],
        &["renders", "renderers"],
        &["rendering"],
        &["render"],
        &["rendering"],
        &["rendezvous"],
        &["rendezvous"],
        &["rendered"],
        &["renderer"],
        &["renderers"],
        &["rendering"],
        &["rendition"],
        &["rendering"],
        &["rendition"],
    ],
    range: 3..=8,
};

static WORD_RENA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RENA_CHILDREN),
    value: None,
};

pub static WORD_RENA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("iisance"),
        dictgen::InsensitiveStr::Ascii("iscance"),
        dictgen::InsensitiveStr::Ascii("issace"),
        dictgen::InsensitiveStr::Ascii("issaince"),
        dictgen::InsensitiveStr::Ascii("issanse"),
        dictgen::InsensitiveStr::Ascii("issence"),
        dictgen::InsensitiveStr::Ascii("ssaince"),
        dictgen::InsensitiveStr::Ascii("ssiance"),
    ],
    values: &[
        &["renaissance"],
        &["renaissance"],
        &["renaissance"],
        &["renaissance"],
        &["renaissance"],
        &["renaissance"],
        &["renaissance"],
        &["renaissance"],
    ],
    range: 6..=8,
};

static WORD_REM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_REM_CHILDREN),
    value: None,
};

static WORD_REM_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_REMA_NODE),
    Some(&WORD_REMB_NODE),
    None,
    None,
    Some(&WORD_REME_NODE),
    None,
    None,
    None,
    Some(&WORD_REMI_NODE),
    None,
    None,
    None,
    Some(&WORD_REMM_NODE),
    Some(&WORD_REMN_NODE),
    Some(&WORD_REMO_NODE),
    Some(&WORD_REMP_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_REMV_NODE),
    None,
    None,
    None,
    None,
];

static WORD_REMV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REMV_CHILDREN),
    value: None,
};

pub static WORD_REMV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("oe"),
        dictgen::InsensitiveStr::Ascii("oed"),
        dictgen::InsensitiveStr::Ascii("oes"),
        dictgen::InsensitiveStr::Ascii("ove"),
        dictgen::InsensitiveStr::Ascii("oved"),
        dictgen::InsensitiveStr::Ascii("oves"),
        dictgen::InsensitiveStr::Ascii("s"),
    ],
    values: &[
        &["remove"],
        &["removed"],
        &["removes"],
        &["remove"],
        &["removed"],
        &["removes"],
        &["remove"],
        &["removed"],
        &["removes"],
        &["removes"],
    ],
    range: 1..=4,
};

static WORD_REMP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REMP_CHILDREN),
    value: None,
};

pub static WORD_REMP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("lacement")],
    values: &[&["replacement"]],
    range: 8..=8,
};

static WORD_REMO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REMO_CHILDREN),
    value: None,
};

pub static WORD_REMO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ce"),
        dictgen::InsensitiveStr::Ascii("ive"),
        dictgen::InsensitiveStr::Ascii("ived"),
        dictgen::InsensitiveStr::Ascii("ives"),
        dictgen::InsensitiveStr::Ascii("iving"),
        dictgen::InsensitiveStr::Ascii("ntly"),
        dictgen::InsensitiveStr::Ascii("ote"),
        dictgen::InsensitiveStr::Ascii("re"),
        dictgen::InsensitiveStr::Ascii("rted"),
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("telly"),
        dictgen::InsensitiveStr::Ascii("tley"),
        dictgen::InsensitiveStr::Ascii("vce"),
        dictgen::InsensitiveStr::Ascii("veable"),
        dictgen::InsensitiveStr::Ascii("vefromat"),
        dictgen::InsensitiveStr::Ascii("veing"),
        dictgen::InsensitiveStr::Ascii("verd"),
    ],
    values: &[
        &["remove"],
        &["remove"],
        &["removed"],
        &["removes"],
        &["removing"],
        &["remotely"],
        &["remote"],
        &["remote"],
        &["reported"],
        &["remote"],
        &["remotely"],
        &["remotely"],
        &["remove"],
        &["removable"],
        &["removeformat"],
        &["removing"],
        &["removed"],
    ],
    range: 1..=8,
};

static WORD_REMN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REMN_CHILDREN),
    value: None,
};

pub static WORD_REMN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ans")],
    values: &[&["remnants"]],
    range: 3..=3,
};

static WORD_REMM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REMM_CHILDREN),
    value: None,
};

pub static WORD_REMM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eber"),
        dictgen::InsensitiveStr::Ascii("ebered"),
        dictgen::InsensitiveStr::Ascii("ebering"),
        dictgen::InsensitiveStr::Ascii("ebers"),
        dictgen::InsensitiveStr::Ascii("ove"),
        dictgen::InsensitiveStr::Ascii("ve"),
    ],
    values: &[
        &["remember"],
        &["remembered"],
        &["remembering"],
        &["remembers"],
        &["remove"],
        &["remove"],
    ],
    range: 2..=7,
};

static WORD_REMI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REMI_CHILDREN),
    value: None,
};

pub static WORD_REMI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("an"),
        dictgen::InsensitiveStr::Ascii("ander"),
        dictgen::InsensitiveStr::Ascii("aned"),
        dictgen::InsensitiveStr::Ascii("aning"),
        dictgen::InsensitiveStr::Ascii("ans"),
        dictgen::InsensitiveStr::Ascii("fications"),
        dictgen::InsensitiveStr::Ascii("gnton"),
        dictgen::InsensitiveStr::Ascii("nent"),
        dictgen::InsensitiveStr::Ascii("nescent"),
        dictgen::InsensitiveStr::Ascii("ngotn"),
        dictgen::InsensitiveStr::Ascii("nicient"),
        dictgen::InsensitiveStr::Ascii("ning"),
        dictgen::InsensitiveStr::Ascii("nis"),
        dictgen::InsensitiveStr::Ascii("niscant"),
        dictgen::InsensitiveStr::Ascii("niscense"),
        dictgen::InsensitiveStr::Ascii("niscient"),
        dictgen::InsensitiveStr::Ascii("niscint"),
        dictgen::InsensitiveStr::Ascii("nise"),
        dictgen::InsensitiveStr::Ascii("nised"),
        dictgen::InsensitiveStr::Ascii("nisent"),
        dictgen::InsensitiveStr::Ascii("nisentky"),
        dictgen::InsensitiveStr::Ascii("niser"),
        dictgen::InsensitiveStr::Ascii("nises"),
        dictgen::InsensitiveStr::Ascii("nising"),
        dictgen::InsensitiveStr::Ascii("nsce"),
        dictgen::InsensitiveStr::Ascii("nsced"),
        dictgen::InsensitiveStr::Ascii("nscence"),
        dictgen::InsensitiveStr::Ascii("nscent"),
        dictgen::InsensitiveStr::Ascii("nscently"),
        dictgen::InsensitiveStr::Ascii("nscer"),
        dictgen::InsensitiveStr::Ascii("nsces"),
        dictgen::InsensitiveStr::Ascii("nscient"),
        dictgen::InsensitiveStr::Ascii("nscing"),
        dictgen::InsensitiveStr::Ascii("nsicent"),
        dictgen::InsensitiveStr::Ascii("nsicently"),
    ],
    values: &[
        &["remain"],
        &["remainder", "reminder"],
        &["remained"],
        &["remaining"],
        &["remains"],
        &["ramifications"],
        &["remington"],
        &["remnant"],
        &["reminiscent"],
        &["remington"],
        &["reminiscent"],
        &["remaining"],
        &["reminisce"],
        &["reminiscent"],
        &["reminiscence"],
        &["reminiscent"],
        &["reminiscent"],
        &["reminisce"],
        &["reminisced"],
        &["reminiscent"],
        &["reminiscently"],
        &["reminiscer"],
        &["reminisces"],
        &["reminiscing"],
        &["reminisce"],
        &["reminisced"],
        &["reminiscence"],
        &["reminiscent"],
        &["reminiscently"],
        &["reminiscer"],
        &["reminisces"],
        &["reminiscent"],
        &["reminiscing"],
        &["reminiscent"],
        &["reminiscently"],
    ],
    range: 2..=9,
};

static WORD_REME_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REME_CHILDREN),
    value: None,
};

pub static WORD_REME_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ber"),
        dictgen::InsensitiveStr::Ascii("bered"),
        dictgen::InsensitiveStr::Ascii("bering"),
        dictgen::InsensitiveStr::Ascii("bers"),
        dictgen::InsensitiveStr::Ascii("mbed"),
        dictgen::InsensitiveStr::Ascii("mbee"),
        dictgen::InsensitiveStr::Ascii("mberable"),
        dictgen::InsensitiveStr::Ascii("mberance"),
        dictgen::InsensitiveStr::Ascii("mberd"),
        dictgen::InsensitiveStr::Ascii("mberes"),
        dictgen::InsensitiveStr::Ascii("mbrence"),
        dictgen::InsensitiveStr::Ascii("meber"),
        dictgen::InsensitiveStr::Ascii("mebered"),
        dictgen::InsensitiveStr::Ascii("mebering"),
        dictgen::InsensitiveStr::Ascii("mebers"),
        dictgen::InsensitiveStr::Ascii("mebr"),
        dictgen::InsensitiveStr::Ascii("mebred"),
        dictgen::InsensitiveStr::Ascii("mebrs"),
        dictgen::InsensitiveStr::Ascii("member"),
        dictgen::InsensitiveStr::Ascii("membered"),
        dictgen::InsensitiveStr::Ascii("members"),
        dictgen::InsensitiveStr::Ascii("mer"),
        dictgen::InsensitiveStr::Ascii("mered"),
        dictgen::InsensitiveStr::Ascii("mers"),
        dictgen::InsensitiveStr::Ascii("mor"),
        dictgen::InsensitiveStr::Ascii("mored"),
        dictgen::InsensitiveStr::Ascii("moring"),
        dictgen::InsensitiveStr::Ascii("mors"),
        dictgen::InsensitiveStr::Ascii("mver"),
        dictgen::InsensitiveStr::Ascii("nant"),
        dictgen::InsensitiveStr::Ascii("nber"),
        dictgen::InsensitiveStr::Ascii("nicent"),
        dictgen::InsensitiveStr::Ascii("niss"),
        dictgen::InsensitiveStr::Ascii("nissed"),
        dictgen::InsensitiveStr::Ascii("nissence"),
        dictgen::InsensitiveStr::Ascii("nissense"),
        dictgen::InsensitiveStr::Ascii("nissent"),
        dictgen::InsensitiveStr::Ascii("nissently"),
        dictgen::InsensitiveStr::Ascii("nisser"),
        dictgen::InsensitiveStr::Ascii("nisses"),
        dictgen::InsensitiveStr::Ascii("nissing"),
    ],
    values: &[
        &["remember"],
        &["remembered"],
        &["remembering"],
        &["remembers"],
        &["remembered"],
        &["remembered"],
        &["memorable"],
        &["remembrance"],
        &["remembered"],
        &["remembers"],
        &["remembrance"],
        &["remember"],
        &["remembered"],
        &["remembering"],
        &["remembers"],
        &["remember"],
        &["remembered"],
        &["remembers"],
        &["remember"],
        &["remembered"],
        &["remembers"],
        &["remember"],
        &["remembered"],
        &["remembers"],
        &["remember"],
        &["remembered"],
        &["remembering"],
        &["remembers"],
        &["remember"],
        &["remnant"],
        &["remember"],
        &["reminiscent"],
        &["reminisce"],
        &["reminisced"],
        &["reminiscence"],
        &["reminiscence"],
        &["reminiscent"],
        &["reminiscently"],
        &["reminiscer"],
        &["reminisces"],
        &["reminiscing"],
    ],
    range: 3..=9,
};

static WORD_REMB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REMB_CHILDREN),
    value: None,
};

pub static WORD_REMB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ember"),
        dictgen::InsensitiveStr::Ascii("embered"),
        dictgen::InsensitiveStr::Ascii("embering"),
        dictgen::InsensitiveStr::Ascii("embers"),
        dictgen::InsensitiveStr::Ascii("er"),
    ],
    values: &[
        &["remember"],
        &["remembered"],
        &["remembering"],
        &["remembers"],
        &["remember"],
    ],
    range: 2..=8,
};

static WORD_REMA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REMA_CHILDREN),
    value: None,
};

pub static WORD_REMA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ind"),
        dictgen::InsensitiveStr::Ascii("inds"),
        dictgen::InsensitiveStr::Ascii("iner"),
        dictgen::InsensitiveStr::Ascii("ines"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("inging"),
        dictgen::InsensitiveStr::Ascii("inig"),
        dictgen::InsensitiveStr::Ascii("inst"),
        dictgen::InsensitiveStr::Ascii("krs"),
        dictgen::InsensitiveStr::Ascii("nder"),
        dictgen::InsensitiveStr::Ascii("ne"),
        dictgen::InsensitiveStr::Ascii("ned"),
        dictgen::InsensitiveStr::Ascii("ner"),
        dictgen::InsensitiveStr::Ascii("nes"),
        dictgen::InsensitiveStr::Ascii("nin"),
        dictgen::InsensitiveStr::Ascii("ning"),
        dictgen::InsensitiveStr::Ascii("nnt"),
        dictgen::InsensitiveStr::Ascii("nnts"),
        dictgen::InsensitiveStr::Ascii("ped"),
        dictgen::InsensitiveStr::Ascii("ping"),
        dictgen::InsensitiveStr::Ascii("rcably"),
        dictgen::InsensitiveStr::Ascii("rkablely"),
        dictgen::InsensitiveStr::Ascii("rkabley"),
        dictgen::InsensitiveStr::Ascii("rkablly"),
        dictgen::InsensitiveStr::Ascii("rkes"),
        dictgen::InsensitiveStr::Ascii("rkibly"),
        dictgen::InsensitiveStr::Ascii("sterd"),
        dictgen::InsensitiveStr::Ascii("sterred"),
    ],
    values: &[
        &["remained", "remind"],
        &["remains"],
        &["remainder"],
        &["remains", "remained"],
        &["remaining"],
        &["remaining"],
        &["remaining"],
        &["remains"],
        &["remarks"],
        &["remainder"],
        &["remain", "remake", "rename"],
        &["remained"],
        &["remainder"],
        &["remains"],
        &["remain", "remaining"],
        &["remaining"],
        &["remnant"],
        &["remnants"],
        &["remapped"],
        &["remapping"],
        &["remarkably"],
        &["remarkably"],
        &["remarkably"],
        &["remarkably"],
        &["remarks"],
        &["remarkably"],
        &["remastered"],
        &["remastered"],
    ],
    range: 2..=8,
};

static WORD_REL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_REL_CHILDREN),
    value: None,
};

static WORD_REL_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_RELA_NODE),
    None,
    Some(&WORD_RELC_NODE),
    None,
    Some(&WORD_RELE_NODE),
    Some(&WORD_RELF_NODE),
    None,
    None,
    Some(&WORD_RELI_NODE),
    None,
    None,
    Some(&WORD_RELL_NODE),
    Some(&WORD_RELM_NODE),
    None,
    Some(&WORD_RELO_NODE),
    Some(&WORD_RELP_NODE),
    None,
    None,
    None,
    Some(&WORD_RELT_NODE),
    Some(&WORD_RELU_NODE),
    None,
    None,
    None,
    Some(&WORD_RELY_NODE),
    None,
];

static WORD_RELY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RELY_CHILDREN),
    value: None,
};

pub static WORD_RELY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("able"),
        dictgen::InsensitiveStr::Ascii("ably"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("s"),
    ],
    values: &[
        &["reliable"],
        &["reliably"],
        &["relied"],
        &["relies", "realize", "realise"],
        &["relies"],
    ],
    range: 1..=4,
};

static WORD_RELU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RELU_CHILDREN),
    value: None,
};

pub static WORD_RELU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ctanct"),
        dictgen::InsensitiveStr::Ascii("ctanctly"),
        dictgen::InsensitiveStr::Ascii("ctanly"),
        dictgen::InsensitiveStr::Ascii("ctanty"),
        dictgen::InsensitiveStr::Ascii("ctently"),
    ],
    values: &[
        &["reluctant"],
        &["reluctantly"],
        &["reluctantly"],
        &["reluctantly"],
        &["reluctantly"],
    ],
    range: 6..=8,
};

static WORD_RELT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RELT_CHILDREN),
    value: None,
};

pub static WORD_RELT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ive")],
    values: &[&["relative"]],
    range: 3..=3,
};

static WORD_RELP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RELP_CHILDREN),
    value: None,
};

pub static WORD_RELP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("acement"),
        dictgen::InsensitiveStr::Ascii("ase"),
        dictgen::InsensitiveStr::Ascii("ased"),
        dictgen::InsensitiveStr::Ascii("y"),
    ],
    values: &[&["replacement"], &["relapse"], &["relapsed"], &["reply"]],
    range: 1..=7,
};

static WORD_RELO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RELO_CHILDREN),
    value: None,
};

pub static WORD_RELO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ade"),
        dictgen::InsensitiveStr::Ascii("cae"),
        dictgen::InsensitiveStr::Ascii("caes"),
        dictgen::InsensitiveStr::Ascii("caiing"),
        dictgen::InsensitiveStr::Ascii("caing"),
        dictgen::InsensitiveStr::Ascii("caion"),
        dictgen::InsensitiveStr::Ascii("caions"),
        dictgen::InsensitiveStr::Ascii("caite"),
        dictgen::InsensitiveStr::Ascii("caites"),
        dictgen::InsensitiveStr::Ascii("caiting"),
        dictgen::InsensitiveStr::Ascii("caition"),
        dictgen::InsensitiveStr::Ascii("caitions"),
        dictgen::InsensitiveStr::Ascii("caiton"),
        dictgen::InsensitiveStr::Ascii("caitons"),
        dictgen::InsensitiveStr::Ascii("cateable"),
        dictgen::InsensitiveStr::Ascii("ccate"),
        dictgen::InsensitiveStr::Ascii("ccated"),
        dictgen::InsensitiveStr::Ascii("ccates"),
    ],
    values: &[
        &["reload"],
        &["relocate"],
        &["relocates"],
        &["relocating"],
        &["relocating"],
        &["relocation"],
        &["relocations"],
        &["relocate"],
        &["relocates"],
        &["relocating"],
        &["relocation"],
        &["relocations"],
        &["relocation"],
        &["relocations"],
        &["relocatable"],
        &["relocate"],
        &["relocated"],
        &["relocates"],
    ],
    range: 3..=8,
};

static WORD_RELM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RELM_CHILDREN),
    value: Some(&["elm", "helm", "realm", "ream", "rem"]),
};

pub static WORD_RELM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("s")],
    values: &[&["elms", "helms", "realms", "reams"]],
    range: 1..=1,
};

static WORD_RELL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RELL_CHILDREN),
    value: None,
};

pub static WORD_RELL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ocates"),
        dictgen::InsensitiveStr::Ascii("y"),
    ],
    values: &[&["reallocates", "relocates"], &["really"]],
    range: 1..=6,
};

static WORD_RELI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RELI_CHILDREN),
    value: None,
};

pub static WORD_RELI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("abe"),
        dictgen::InsensitiveStr::Ascii("abillity"),
        dictgen::InsensitiveStr::Ascii("abilty"),
        dictgen::InsensitiveStr::Ascii("abily"),
        dictgen::InsensitiveStr::Ascii("ablely"),
        dictgen::InsensitiveStr::Ascii("abley"),
        dictgen::InsensitiveStr::Ascii("ablity"),
        dictgen::InsensitiveStr::Ascii("ased"),
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("efed"),
        dictgen::InsensitiveStr::Ascii("efes"),
        dictgen::InsensitiveStr::Ascii("efing"),
        dictgen::InsensitiveStr::Ascii("ent"),
        dictgen::InsensitiveStr::Ascii("geon"),
        dictgen::InsensitiveStr::Ascii("geons"),
        dictgen::InsensitiveStr::Ascii("geous"),
        dictgen::InsensitiveStr::Ascii("geously"),
        dictgen::InsensitiveStr::Ascii("gionens"),
        dictgen::InsensitiveStr::Ascii("gioners"),
        dictgen::InsensitiveStr::Ascii("giones"),
        dictgen::InsensitiveStr::Ascii("giosly"),
        dictgen::InsensitiveStr::Ascii("giousy"),
        dictgen::InsensitiveStr::Ascii("gous"),
        dictgen::InsensitiveStr::Ascii("gously"),
        dictgen::InsensitiveStr::Ascii("nguish"),
        dictgen::InsensitiveStr::Ascii("nguishing"),
        dictgen::InsensitiveStr::Ascii("nqushment"),
        dictgen::InsensitiveStr::Ascii("ntquish"),
        dictgen::InsensitiveStr::Ascii("tavely"),
        dictgen::InsensitiveStr::Ascii("zed"),
    ],
    values: &[
        &["reliable"],
        &["reliability"],
        &["reliability"],
        &["reliability", "reliably"],
        &["reliably"],
        &["reliably"],
        &["reliability"],
        &["realised"],
        &["rely", "relies", "really", "relief"],
        &["relieved"],
        &["relieves"],
        &["relieving"],
        &["reliant"],
        &["religion"],
        &["religions"],
        &["religious"],
        &["religiously"],
        &["religions"],
        &["religions"],
        &["religions"],
        &["religiously"],
        &["religiously"],
        &["religious"],
        &["religiously"],
        &["relinquish"],
        &["relinquishing"],
        &["relinquishment"],
        &["relinquish"],
        &["relatively"],
        &["realized"],
    ],
    range: 1..=9,
};

static WORD_RELF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RELF_CHILDREN),
    value: None,
};

pub static WORD_RELF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ect"),
        dictgen::InsensitiveStr::Ascii("ected"),
        dictgen::InsensitiveStr::Ascii("ecting"),
        dictgen::InsensitiveStr::Ascii("ection"),
        dictgen::InsensitiveStr::Ascii("ections"),
        dictgen::InsensitiveStr::Ascii("ective"),
        dictgen::InsensitiveStr::Ascii("ects"),
        dictgen::InsensitiveStr::Ascii("exes"),
    ],
    values: &[
        &["reflect"],
        &["reflected"],
        &["reflecting"],
        &["reflection"],
        &["reflections"],
        &["reflective"],
        &["reflects"],
        &["reflexes"],
    ],
    range: 3..=7,
};

static WORD_RELE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_RELE_CHILDREN),
    value: None,
};

static WORD_RELE_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_RELEA_NODE),
    None,
    Some(&WORD_RELEC_NODE),
    None,
    None,
    None,
    Some(&WORD_RELEG_NODE),
    None,
    Some(&WORD_RELEI_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_RELEN_NODE),
    Some(&WORD_RELEO_NODE),
    None,
    None,
    None,
    Some(&WORD_RELES_NODE),
    Some(&WORD_RELET_NODE),
    None,
    Some(&WORD_RELEV_NODE),
    None,
    Some(&WORD_RELEX_NODE),
    None,
    None,
];

static WORD_RELEX_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RELEX_CHILDREN),
    value: None,
};

pub static WORD_RELEX_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ation")],
    values: &[&["relegation"]],
    range: 5..=5,
};

static WORD_RELEV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RELEV_CHILDREN),
    value: None,
};

pub static WORD_RELEV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("abt"),
        dictgen::InsensitiveStr::Ascii("ane"),
        dictgen::InsensitiveStr::Ascii("ation"),
        dictgen::InsensitiveStr::Ascii("ations"),
        dictgen::InsensitiveStr::Ascii("eant"),
        dictgen::InsensitiveStr::Ascii("ence"),
        dictgen::InsensitiveStr::Ascii("ent"),
    ],
    values: &[
        &["relevant"],
        &["relevant"],
        &["revelation"],
        &["revelations"],
        &["relevant"],
        &["relevance"],
        &["relevant"],
    ],
    range: 3..=6,
};

static WORD_RELET_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RELET_CHILDREN),
    value: None,
};

pub static WORD_RELET_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("ive"),
        dictgen::InsensitiveStr::Ascii("ively"),
        dictgen::InsensitiveStr::Ascii("nless"),
    ],
    values: &[
        &["delete", "relate"],
        &["deleted", "related"],
        &["deletes", "relates"],
        &["deleting", "relating"],
        &["relative"],
        &["relatively"],
        &["relentless"],
    ],
    range: 1..=5,
};

static WORD_RELES_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RELES_CHILDREN),
    value: None,
};

pub static WORD_RELES_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ae"),
        dictgen::InsensitiveStr::Ascii("aed"),
        dictgen::InsensitiveStr::Ascii("aes"),
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("es"),
    ],
    values: &[
        &["release"],
        &["released"],
        &["releases"],
        &["release"],
        &["released"],
        &["releases"],
    ],
    range: 1..=3,
};

static WORD_RELEO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RELEO_CHILDREN),
    value: None,
};

pub static WORD_RELEO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ad")],
    values: &[&["reload"]],
    range: 2..=2,
};

static WORD_RELEN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RELEN_CHILDREN),
    value: None,
};

pub static WORD_RELEN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("tlesly"),
        dictgen::InsensitiveStr::Ascii("tlessely"),
        dictgen::InsensitiveStr::Ascii("tlessley"),
        dictgen::InsensitiveStr::Ascii("tlessy"),
        dictgen::InsensitiveStr::Ascii("tness"),
    ],
    values: &[
        &["relentlessly"],
        &["relentlessly"],
        &["relentlessly"],
        &["relentlessly"],
        &["relentless"],
    ],
    range: 5..=8,
};

static WORD_RELEI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RELEI_CHILDREN),
    value: None,
};

pub static WORD_RELEI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("f"),
        dictgen::InsensitiveStr::Ascii("fe"),
        dictgen::InsensitiveStr::Ascii("fed"),
        dictgen::InsensitiveStr::Ascii("fes"),
        dictgen::InsensitiveStr::Ascii("fing"),
        dictgen::InsensitiveStr::Ascii("ve"),
        dictgen::InsensitiveStr::Ascii("ved"),
        dictgen::InsensitiveStr::Ascii("ver"),
        dictgen::InsensitiveStr::Ascii("ves"),
        dictgen::InsensitiveStr::Ascii("ving"),
    ],
    values: &[
        &["relief"],
        &["relief"],
        &["relieved"],
        &["relieves"],
        &["relieving"],
        &["relieve"],
        &["relieved"],
        &["reliever"],
        &["relieves"],
        &["relieving"],
    ],
    range: 1..=4,
};

static WORD_RELEG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RELEG_CHILDREN),
    value: None,
};

pub static WORD_RELEG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ato"),
        dictgen::InsensitiveStr::Ascii("etion"),
    ],
    values: &[&["relegation"], &["relegation"]],
    range: 3..=5,
};

static WORD_RELEC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RELEC_CHILDREN),
    value: None,
};

pub static WORD_RELEC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ant"),
        dictgen::InsensitiveStr::Ascii("ted"),
    ],
    values: &[&["relevant"], &["reelected", "reflected"]],
    range: 3..=3,
};

static WORD_RELEA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RELEA_CHILDREN),
    value: None,
};

pub static WORD_RELEA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ase"),
        dictgen::InsensitiveStr::Ascii("ased"),
        dictgen::InsensitiveStr::Ascii("d"),
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("eing"),
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("f"),
        dictgen::InsensitiveStr::Ascii("fed"),
        dictgen::InsensitiveStr::Ascii("fes"),
        dictgen::InsensitiveStr::Ascii("fing"),
        dictgen::InsensitiveStr::Ascii("fs"),
        dictgen::InsensitiveStr::Ascii("gtion"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("nt"),
        dictgen::InsensitiveStr::Ascii("s"),
        dictgen::InsensitiveStr::Ascii("sead"),
        dictgen::InsensitiveStr::Ascii("sse"),
        dictgen::InsensitiveStr::Ascii("ted"),
        dictgen::InsensitiveStr::Ascii("ting"),
        dictgen::InsensitiveStr::Ascii("tion"),
        dictgen::InsensitiveStr::Ascii("tions"),
        dictgen::InsensitiveStr::Ascii("tionship"),
        dictgen::InsensitiveStr::Ascii("tionships"),
        dictgen::InsensitiveStr::Ascii("tive"),
        dictgen::InsensitiveStr::Ascii("vant"),
        dictgen::InsensitiveStr::Ascii("ve"),
        dictgen::InsensitiveStr::Ascii("ved"),
        dictgen::InsensitiveStr::Ascii("ves"),
        dictgen::InsensitiveStr::Ascii("ving"),
    ],
    values: &[
        &["release"],
        &["released"],
        &["reload"],
        &["release"],
        &["released"],
        &["releasing"],
        &["release", "releases"],
        &["relief"],
        &["relieved"],
        &["relieves"],
        &["relieving"],
        &["relieves"],
        &["relegation"],
        &["releasing"],
        &["relevant", "relent"],
        &["release"],
        &["released"],
        &["release"],
        &["related"],
        &["relating"],
        &["relation"],
        &["relations"],
        &["relationship"],
        &["relationships"],
        &["relative"],
        &["relevant"],
        &["relieve"],
        &["relieved"],
        &["relieves"],
        &["relieving"],
    ],
    range: 1..=9,
};

static WORD_RELC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RELC_CHILDREN),
    value: None,
};

pub static WORD_RELC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aim"),
        dictgen::InsensitiveStr::Ascii("utant"),
        dictgen::InsensitiveStr::Ascii("utantly"),
    ],
    values: &[&["reclaim"], &["reluctant"], &["reluctantly"]],
    range: 3..=7,
};

static WORD_RELA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_RELA_CHILDREN),
    value: Some(&["real"]),
};

static WORD_RELA_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_RELAA_NODE),
    None,
    Some(&WORD_RELAC_NODE),
    Some(&WORD_RELAD_NODE),
    Some(&WORD_RELAE_NODE),
    None,
    Some(&WORD_RELAG_NODE),
    None,
    Some(&WORD_RELAI_NODE),
    None,
    None,
    Some(&WORD_RELAL_NODE),
    None,
    None,
    Some(&WORD_RELAO_NODE),
    Some(&WORD_RELAP_NODE),
    None,
    None,
    Some(&WORD_RELAS_NODE),
    Some(&WORD_RELAT_NODE),
    None,
    Some(&WORD_RELAV_NODE),
    None,
    Some(&WORD_RELAX_NODE),
    None,
    Some(&WORD_RELAZ_NODE),
];

static WORD_RELAZ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RELAZ_CHILDREN),
    value: None,
};

pub static WORD_RELAZ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ation")],
    values: &[&["relaxation"]],
    range: 5..=5,
};

static WORD_RELAX_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RELAX_CHILDREN),
    value: None,
};

pub static WORD_RELAX_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ating")],
    values: &[&["relaxation"]],
    range: 5..=5,
};

static WORD_RELAV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RELAV_CHILDREN),
    value: None,
};

pub static WORD_RELAV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ant"),
        dictgen::InsensitiveStr::Ascii("ation"),
        dictgen::InsensitiveStr::Ascii("ence"),
        dictgen::InsensitiveStr::Ascii("ent"),
    ],
    values: &[
        &["relevant"],
        &["relaxation"],
        &["relevance"],
        &["relevant"],
    ],
    range: 3..=5,
};

static WORD_RELAT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RELAT_CHILDREN),
    value: None,
};

pub static WORD_RELAT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("abe"),
        dictgen::InsensitiveStr::Ascii("aive"),
        dictgen::InsensitiveStr::Ascii("ated"),
        dictgen::InsensitiveStr::Ascii("ation"),
        dictgen::InsensitiveStr::Ascii("ative"),
        dictgen::InsensitiveStr::Ascii("d"),
        dictgen::InsensitiveStr::Ascii("dness"),
        dictgen::InsensitiveStr::Ascii("eds"),
        dictgen::InsensitiveStr::Ascii("iate"),
        dictgen::InsensitiveStr::Ascii("iation"),
        dictgen::InsensitiveStr::Ascii("ib"),
        dictgen::InsensitiveStr::Ascii("ibe"),
        dictgen::InsensitiveStr::Ascii("ibely"),
        dictgen::InsensitiveStr::Ascii("ie"),
        dictgen::InsensitiveStr::Ascii("ievly"),
        dictgen::InsensitiveStr::Ascii("in"),
        dictgen::InsensitiveStr::Ascii("inoship"),
        dictgen::InsensitiveStr::Ascii("ionshits"),
        dictgen::InsensitiveStr::Ascii("ionshp"),
        dictgen::InsensitiveStr::Ascii("ionsship"),
        dictgen::InsensitiveStr::Ascii("iopnship"),
        dictgen::InsensitiveStr::Ascii("iv"),
        dictgen::InsensitiveStr::Ascii("ivated"),
        dictgen::InsensitiveStr::Ascii("ivety"),
        dictgen::InsensitiveStr::Ascii("ivily"),
        dictgen::InsensitiveStr::Ascii("iviser"),
        dictgen::InsensitiveStr::Ascii("ivisme"),
        dictgen::InsensitiveStr::Ascii("ivitiy"),
        dictgen::InsensitiveStr::Ascii("ivitly"),
        dictgen::InsensitiveStr::Ascii("iviy"),
        dictgen::InsensitiveStr::Ascii("ivley"),
        dictgen::InsensitiveStr::Ascii("ivly"),
        dictgen::InsensitiveStr::Ascii("ivno"),
        dictgen::InsensitiveStr::Ascii("ivy"),
    ],
    values: &[
        &["relatable"],
        &["relative"],
        &["related"],
        &["relaxation"],
        &["relative"],
        &["related"],
        &["relatedness"],
        &["relates"],
        &["retaliate"],
        &["retaliation"],
        &["relative", "relatable"],
        &["relative"],
        &["relatively"],
        &["relative"],
        &["relatively"],
        &["relation"],
        &["relationships"],
        &["relationships"],
        &["relationships"],
        &["relationships"],
        &["relationship"],
        &["relative"],
        &["relative", "relatively"],
        &["relativity"],
        &["relativity"],
        &["relatives"],
        &["relatives"],
        &["relativity"],
        &["relativity"],
        &["relativity"],
        &["relatively"],
        &["relatively"],
        &["relation"],
        &["relativity"],
    ],
    range: 1..=8,
};

static WORD_RELAS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RELAS_CHILDREN),
    value: None,
};

pub static WORD_RELAS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("er"),
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("hionship"),
        dictgen::InsensitiveStr::Ascii("hionships"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("pe"),
        dictgen::InsensitiveStr::Ascii("ped"),
    ],
    values: &[
        &["release"],
        &["released"],
        &["releaser"],
        &["releases"],
        &["relationship"],
        &["relationships"],
        &["releasing"],
        &["relapse"],
        &["relapsed"],
    ],
    range: 1..=9,
};

static WORD_RELAP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RELAP_CHILDREN),
    value: None,
};

pub static WORD_RELAP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("es")],
    values: &[&["relapse"]],
    range: 2..=2,
};

static WORD_RELAO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RELAO_CHILDREN),
    value: None,
};

pub static WORD_RELAO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("d"),
        dictgen::InsensitiveStr::Ascii("ded"),
        dictgen::InsensitiveStr::Ascii("ding"),
        dictgen::InsensitiveStr::Ascii("ds"),
    ],
    values: &[&["reload"], &["reloaded"], &["reloading"], &["reloads"]],
    range: 1..=4,
};

static WORD_RELAL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RELAL_CHILDREN),
    value: None,
};

pub static WORD_RELAL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("y")],
    values: &[&["really"]],
    range: 1..=1,
};

static WORD_RELAI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RELAI_CHILDREN),
    value: None,
};

pub static WORD_RELAI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("bility"),
        dictgen::InsensitiveStr::Ascii("ble"),
        dictgen::InsensitiveStr::Ascii("bly"),
        dictgen::InsensitiveStr::Ascii("med"),
        dictgen::InsensitiveStr::Ascii("on"),
        dictgen::InsensitiveStr::Ascii("se"),
        dictgen::InsensitiveStr::Ascii("sed"),
        dictgen::InsensitiveStr::Ascii("tonship"),
        dictgen::InsensitiveStr::Ascii("ve"),
    ],
    values: &[
        &["reliability"],
        &["reliable"],
        &["reliably"],
        &["reclaimed"],
        &["relation"],
        &["realise"],
        &["realised"],
        &["relationships"],
        &["relative"],
    ],
    range: 2..=7,
};

static WORD_RELAG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RELAG_CHILDREN),
    value: None,
};

pub static WORD_RELAG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ation"),
        dictgen::InsensitiveStr::Ascii("ed"),
    ],
    values: &[&["relaxation"], &["related"]],
    range: 2..=5,
};

static WORD_RELAE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RELAE_CHILDREN),
    value: None,
};

pub static WORD_RELAE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ase"),
        dictgen::InsensitiveStr::Ascii("se"),
        dictgen::InsensitiveStr::Ascii("sed"),
        dictgen::InsensitiveStr::Ascii("ses"),
        dictgen::InsensitiveStr::Ascii("sing"),
    ],
    values: &[
        &["release"],
        &["release"],
        &["released"],
        &["releases"],
        &["releasing"],
    ],
    range: 2..=4,
};

static WORD_RELAD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RELAD_CHILDREN),
    value: None,
};

pub static WORD_RELAD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("y")],
    values: &[&["ready"]],
    range: 1..=1,
};

static WORD_RELAC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RELAC_CHILDREN),
    value: None,
};

pub static WORD_RELAC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("e")],
    values: &[&["replace"]],
    range: 1..=1,
};

static WORD_RELAA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RELAA_CHILDREN),
    value: None,
};

pub static WORD_RELAA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("tive")],
    values: &[&["relative"]],
    range: 4..=4,
};

static WORD_REK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REK_CHILDREN),
    value: None,
};

pub static WORD_REK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("enton"),
        dictgen::InsensitiveStr::Ascii("nown"),
        dictgen::InsensitiveStr::Ascii("nowned"),
        dictgen::InsensitiveStr::Ascii("ommendation"),
        dictgen::InsensitiveStr::Ascii("tifications"),
        dictgen::InsensitiveStr::Ascii("ursed"),
        dictgen::InsensitiveStr::Ascii("ursion"),
        dictgen::InsensitiveStr::Ascii("ursive"),
    ],
    values: &[
        &["renekton"],
        &["renown"],
        &["renowned"],
        &["recommendation"],
        &["certifications"],
        &["recursed"],
        &["recursion"],
        &["recursive"],
    ],
    range: 4..=11,
};

static WORD_REJ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REJ_CHILDREN),
    value: None,
};

pub static WORD_REJ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("place")],
    values: &[&["replace"]],
    range: 5..=5,
};

static WORD_REI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_REI_CHILDREN),
    value: None,
};

static WORD_REI_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    Some(&WORD_REIC_NODE),
    None,
    None,
    None,
    Some(&WORD_REIG_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_REIM_NODE),
    Some(&WORD_REIN_NODE),
    None,
    Some(&WORD_REIP_NODE),
    None,
    None,
    Some(&WORD_REIS_NODE),
    Some(&WORD_REIT_NODE),
    None,
    Some(&WORD_REIV_NODE),
    None,
    None,
    None,
    None,
];

static WORD_REIV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REIV_CHILDREN),
    value: None,
};

pub static WORD_REIV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ews"),
        dictgen::InsensitiveStr::Ascii("ison"),
    ],
    values: &[&["reviews"], &["revision"]],
    range: 3..=4,
};

static WORD_REIT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REIT_CHILDREN),
    value: None,
};

pub static WORD_REIT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("rement"),
        dictgen::InsensitiveStr::Ascii("res"),
        dictgen::InsensitiveStr::Ascii("terate"),
        dictgen::InsensitiveStr::Ascii("terated"),
        dictgen::InsensitiveStr::Ascii("terates"),
    ],
    values: &[
        &["retirement"],
        &["retires"],
        &["reiterate"],
        &["reiterated"],
        &["reiterates"],
    ],
    range: 3..=7,
};

static WORD_REIS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REIS_CHILDREN),
    value: None,
};

pub static WORD_REIS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ntall"),
        dictgen::InsensitiveStr::Ascii("ntalled"),
        dictgen::InsensitiveStr::Ascii("ntalling"),
        dictgen::InsensitiveStr::Ascii("ter"),
    ],
    values: &[
        &["reinstall"],
        &["reinstalled"],
        &["reinstalling"],
        &["register"],
    ],
    range: 3..=8,
};

static WORD_REIP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REIP_CHILDREN),
    value: None,
};

pub static WORD_REIP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ient"),
        dictgen::InsensitiveStr::Ascii("ients"),
    ],
    values: &[&["recipient"], &["recipients"]],
    range: 4..=5,
};

static WORD_REIN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REIN_CHILDREN),
    value: None,
};

pub static WORD_REIN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("assance"),
        dictgen::InsensitiveStr::Ascii("carantion"),
        dictgen::InsensitiveStr::Ascii("catnation"),
        dictgen::InsensitiveStr::Ascii("foce"),
        dictgen::InsensitiveStr::Ascii("foced"),
        dictgen::InsensitiveStr::Ascii("focement"),
        dictgen::InsensitiveStr::Ascii("focements"),
        dictgen::InsensitiveStr::Ascii("foces"),
        dictgen::InsensitiveStr::Ascii("focing"),
        dictgen::InsensitiveStr::Ascii("forcemens"),
        dictgen::InsensitiveStr::Ascii("forcemnets"),
        dictgen::InsensitiveStr::Ascii("forcemnt"),
        dictgen::InsensitiveStr::Ascii("forcemnts"),
        dictgen::InsensitiveStr::Ascii("forcemt"),
        dictgen::InsensitiveStr::Ascii("fornced"),
        dictgen::InsensitiveStr::Ascii("itailise"),
        dictgen::InsensitiveStr::Ascii("itailised"),
        dictgen::InsensitiveStr::Ascii("itailize"),
        dictgen::InsensitiveStr::Ascii("italise"),
        dictgen::InsensitiveStr::Ascii("italised"),
        dictgen::InsensitiveStr::Ascii("italises"),
        dictgen::InsensitiveStr::Ascii("italising"),
        dictgen::InsensitiveStr::Ascii("italization"),
        dictgen::InsensitiveStr::Ascii("italizations"),
        dictgen::InsensitiveStr::Ascii("italize"),
        dictgen::InsensitiveStr::Ascii("italized"),
        dictgen::InsensitiveStr::Ascii("italizes"),
        dictgen::InsensitiveStr::Ascii("italizing"),
        dictgen::InsensitiveStr::Ascii("itilize"),
        dictgen::InsensitiveStr::Ascii("itilized"),
        dictgen::InsensitiveStr::Ascii("karnation"),
        dictgen::InsensitiveStr::Ascii("stale"),
        dictgen::InsensitiveStr::Ascii("staled"),
        dictgen::InsensitiveStr::Ascii("staling"),
        dictgen::InsensitiveStr::Ascii("stallled"),
        dictgen::InsensitiveStr::Ascii("stallling"),
        dictgen::InsensitiveStr::Ascii("stallng"),
        dictgen::InsensitiveStr::Ascii("statiate"),
        dictgen::InsensitiveStr::Ascii("statiated"),
        dictgen::InsensitiveStr::Ascii("statiates"),
        dictgen::InsensitiveStr::Ascii("statiation"),
        dictgen::InsensitiveStr::Ascii("tantiate"),
        dictgen::InsensitiveStr::Ascii("tantiating"),
        dictgen::InsensitiveStr::Ascii("tarnation"),
        dictgen::InsensitiveStr::Ascii("tepret"),
        dictgen::InsensitiveStr::Ascii("tepreted"),
    ],
    values: &[
        &["renaissance"],
        &["reincarnation"],
        &["reincarnation"],
        &["reinforce"],
        &["reinforced"],
        &["reinforcement"],
        &["reinforcements"],
        &["reinforces"],
        &["reinforcing"],
        &["reinforcements"],
        &["reinforcements"],
        &["reinforcement"],
        &["reinforcements"],
        &["reinforcement"],
        &["reinforced"],
        &["reinitialise"],
        &["reinitialised"],
        &["reinitialize"],
        &["reinitialise"],
        &["reinitialised"],
        &["reinitialises"],
        &["reinitialising"],
        &["reinitialization"],
        &["reinitializations"],
        &["reinitialize"],
        &["reinitialized"],
        &["reinitializes"],
        &["reinitializing"],
        &["reinitialize"],
        &["reinitialized"],
        &["reincarnation"],
        &["reinstalled"],
        &["reinstalled"],
        &["reinstalling"],
        &["reinstalled"],
        &["reinstalling"],
        &["reinstalling"],
        &["reinstantiate"],
        &["reinstantiated"],
        &["reinstantiates"],
        &["reinstantiation"],
        &["reinstantiate"],
        &["reinstantiating"],
        &["reincarnation"],
        &["reinterpret"],
        &["reinterpreted"],
    ],
    range: 4..=12,
};

static WORD_REIM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REIM_CHILDREN),
    value: None,
};

pub static WORD_REIM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("plemenet"),
        dictgen::InsensitiveStr::Ascii("plementaion"),
        dictgen::InsensitiveStr::Ascii("plementaions"),
        dictgen::InsensitiveStr::Ascii("plemention"),
        dictgen::InsensitiveStr::Ascii("plementions"),
        dictgen::InsensitiveStr::Ascii("plented"),
        dictgen::InsensitiveStr::Ascii("plents"),
        dictgen::InsensitiveStr::Ascii("pliment"),
        dictgen::InsensitiveStr::Ascii("plimenting"),
        dictgen::InsensitiveStr::Ascii("plmenet"),
        dictgen::InsensitiveStr::Ascii("plment"),
        dictgen::InsensitiveStr::Ascii("plmentation"),
        dictgen::InsensitiveStr::Ascii("plmented"),
        dictgen::InsensitiveStr::Ascii("plmenting"),
        dictgen::InsensitiveStr::Ascii("plments"),
        dictgen::InsensitiveStr::Ascii("pplement"),
        dictgen::InsensitiveStr::Ascii("pplementating"),
        dictgen::InsensitiveStr::Ascii("pplementation"),
        dictgen::InsensitiveStr::Ascii("pplemented"),
        dictgen::InsensitiveStr::Ascii("premented"),
    ],
    values: &[
        &["reimplement"],
        &["reimplementation"],
        &["reimplementations"],
        &["reimplementation"],
        &["reimplementations"],
        &["reimplemented"],
        &["reimplements"],
        &["reimplement"],
        &["reimplementing"],
        &["reimplement"],
        &["reimplement"],
        &["reimplementation"],
        &["reimplemented"],
        &["reimplementing"],
        &["reimplements"],
        &["reimplement"],
        &["reimplementing"],
        &["reimplementation"],
        &["reimplemented"],
        &["reimplemented"],
    ],
    range: 6..=13,
};

static WORD_REIG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REIG_CHILDREN),
    value: None,
};

pub static WORD_REIG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ht"),
        dictgen::InsensitiveStr::Ascii("ining"),
        dictgen::InsensitiveStr::Ascii("ment"),
        dictgen::InsensitiveStr::Ascii("mes"),
        dictgen::InsensitiveStr::Ascii("on"),
        dictgen::InsensitiveStr::Ascii("onal"),
        dictgen::InsensitiveStr::Ascii("ons"),
        dictgen::InsensitiveStr::Ascii("ster"),
        dictgen::InsensitiveStr::Ascii("stered"),
        dictgen::InsensitiveStr::Ascii("stering"),
        dictgen::InsensitiveStr::Ascii("sters"),
        dictgen::InsensitiveStr::Ascii("stration"),
    ],
    values: &[
        &["eight", "freight", "right"],
        &["reigning"],
        &["regiment"],
        &["regimes"],
        &["region", "reign"],
        &["regional"],
        &["regions", "reigns"],
        &["register"],
        &["registered"],
        &["registering"],
        &["registers"],
        &["registration"],
    ],
    range: 2..=8,
};

static WORD_REIC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REIC_CHILDREN),
    value: None,
};

pub static WORD_REIC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("arnation"),
        dictgen::InsensitiveStr::Ascii("eved"),
    ],
    values: &[&["reincarnation"], &["received"]],
    range: 4..=8,
};

static WORD_REH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REH_CHILDREN),
    value: None,
};

pub static WORD_REH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("abilitacion"),
        dictgen::InsensitiveStr::Ascii("abilitaion"),
        dictgen::InsensitiveStr::Ascii("abilitaiton"),
        dictgen::InsensitiveStr::Ascii("abilitatin"),
        dictgen::InsensitiveStr::Ascii("abilitaton"),
        dictgen::InsensitiveStr::Ascii("ersal"),
        dictgen::InsensitiveStr::Ascii("ersing"),
        dictgen::InsensitiveStr::Ascii("toric"),
        dictgen::InsensitiveStr::Ascii("torical"),
    ],
    values: &[
        &["rehabilitation"],
        &["rehabilitation"],
        &["rehabilitation"],
        &["rehabilitation"],
        &["rehabilitation"],
        &["rehearsal"],
        &["rehearsing"],
        &["rhetoric"],
        &["rhetorical"],
    ],
    range: 5..=11,
};

static WORD_REG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_REG_CHILDREN),
    value: None,
};

static WORD_REG_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_REGA_NODE),
    None,
    Some(&WORD_REGC_NODE),
    None,
    Some(&WORD_REGE_NODE),
    None,
    None,
    None,
    Some(&WORD_REGI_NODE),
    None,
    None,
    Some(&WORD_REGL_NODE),
    None,
    None,
    Some(&WORD_REGO_NODE),
    None,
    None,
    Some(&WORD_REGR_NODE),
    Some(&WORD_REGS_NODE),
    None,
    Some(&WORD_REGU_NODE),
    None,
    None,
    None,
    Some(&WORD_REGY_NODE),
    None,
];

static WORD_REGY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REGY_CHILDREN),
    value: None,
};

pub static WORD_REGY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("lar")],
    values: &[&["regular"]],
    range: 3..=3,
};

static WORD_REGU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_REGU_CHILDREN),
    value: None,
};

static WORD_REGU_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_REGUA_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_REGUI_NODE),
    None,
    None,
    Some(&WORD_REGUL_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_REGUR_NODE),
    Some(&WORD_REGUS_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_REGUS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REGUS_CHILDREN),
    value: None,
};

pub static WORD_REGUS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ter")],
    values: &[&["register"]],
    range: 3..=3,
};

static WORD_REGUR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REGUR_CHILDREN),
    value: None,
};

pub static WORD_REGUR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("al"),
        dictgen::InsensitiveStr::Ascii("ally"),
        dictgen::InsensitiveStr::Ascii("larly"),
    ],
    values: &[&["regular"], &["regularly"], &["regularly"]],
    range: 2..=5,
};

static WORD_REGUL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REGUL_CHILDREN),
    value: None,
};

pub static WORD_REGUL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("acion"),
        dictgen::InsensitiveStr::Ascii("ae"),
        dictgen::InsensitiveStr::Ascii("aer"),
        dictgen::InsensitiveStr::Ascii("aion"),
        dictgen::InsensitiveStr::Ascii("alry"),
        dictgen::InsensitiveStr::Ascii("ament"),
        dictgen::InsensitiveStr::Ascii("amentation"),
        dictgen::InsensitiveStr::Ascii("amentations"),
        dictgen::InsensitiveStr::Ascii("aotrs"),
        dictgen::InsensitiveStr::Ascii("aotry"),
        dictgen::InsensitiveStr::Ascii("ares"),
        dictgen::InsensitiveStr::Ascii("arily"),
        dictgen::InsensitiveStr::Ascii("aring"),
        dictgen::InsensitiveStr::Ascii("ariry"),
        dictgen::InsensitiveStr::Ascii("aris"),
        dictgen::InsensitiveStr::Ascii("arlas"),
        dictgen::InsensitiveStr::Ascii("arlisation"),
        dictgen::InsensitiveStr::Ascii("arlise"),
        dictgen::InsensitiveStr::Ascii("arlised"),
        dictgen::InsensitiveStr::Ascii("arliser"),
        dictgen::InsensitiveStr::Ascii("arlises"),
        dictgen::InsensitiveStr::Ascii("arlising"),
        dictgen::InsensitiveStr::Ascii("arlization"),
        dictgen::InsensitiveStr::Ascii("arlize"),
        dictgen::InsensitiveStr::Ascii("arlized"),
        dictgen::InsensitiveStr::Ascii("arlizer"),
        dictgen::InsensitiveStr::Ascii("arlizes"),
        dictgen::InsensitiveStr::Ascii("arlizing"),
        dictgen::InsensitiveStr::Ascii("arlly"),
        dictgen::InsensitiveStr::Ascii("arlos"),
        dictgen::InsensitiveStr::Ascii("ary"),
        dictgen::InsensitiveStr::Ascii("as"),
        dictgen::InsensitiveStr::Ascii("aters"),
        dictgen::InsensitiveStr::Ascii("atin"),
        dictgen::InsensitiveStr::Ascii("ationg"),
        dictgen::InsensitiveStr::Ascii("atiors"),
        dictgen::InsensitiveStr::Ascii("atios"),
        dictgen::InsensitiveStr::Ascii("atons"),
        dictgen::InsensitiveStr::Ascii("atorias"),
        dictgen::InsensitiveStr::Ascii("atories"),
        dictgen::InsensitiveStr::Ascii("atorios"),
        dictgen::InsensitiveStr::Ascii("atr"),
        dictgen::InsensitiveStr::Ascii("ats"),
        dictgen::InsensitiveStr::Ascii("ax"),
        dictgen::InsensitiveStr::Ascii("er"),
        dictgen::InsensitiveStr::Ascii("r"),
        dictgen::InsensitiveStr::Ascii("sr"),
        dictgen::InsensitiveStr::Ascii("tor"),
        dictgen::InsensitiveStr::Ascii("tors"),
        dictgen::InsensitiveStr::Ascii("tory"),
    ],
    values: &[
        &["regulation"],
        &["regulate"],
        &["regular"],
        &["regulation"],
        &["regularly"],
        &["regulate"],
        &["regulation"],
        &["regulations"],
        &["regulators"],
        &["regulatory"],
        &["regulars"],
        &["regularly"],
        &["regulating"],
        &["regularly"],
        &["regulars"],
        &["regulars"],
        &["regularisation"],
        &["regularise"],
        &["regularised"],
        &["regulariser"],
        &["regularises"],
        &["regularising"],
        &["regularization"],
        &["regularize"],
        &["regularized"],
        &["regularizer"],
        &["regularizes"],
        &["regularizing"],
        &["regularly"],
        &["regulars"],
        &["regularly", "regular"],
        &["regulars"],
        &["regulators"],
        &["regulations"],
        &["regulating"],
        &["regulators"],
        &["regulators"],
        &["regulations"],
        &["regulators"],
        &["regulators"],
        &["regulators"],
        &["regulator"],
        &["regulators"],
        &["regular"],
        &["regular"],
        &["regular"],
        &["regulars"],
        &["regulator"],
        &["regulators"],
        &["regulatory"],
    ],
    range: 1..=11,
};

static WORD_REGUI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REGUI_CHILDREN),
    value: None,
};

pub static WORD_REGUI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("re"),
        dictgen::InsensitiveStr::Ascii("red"),
        dictgen::InsensitiveStr::Ascii("rement"),
        dictgen::InsensitiveStr::Ascii("rements"),
        dictgen::InsensitiveStr::Ascii("res"),
        dictgen::InsensitiveStr::Ascii("ring"),
    ],
    values: &[
        &["require"],
        &["required"],
        &["requirement"],
        &["requirements"],
        &["requires"],
        &["requiring"],
    ],
    range: 2..=7,
};

static WORD_REGUA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REGUA_CHILDREN),
    value: None,
};

pub static WORD_REGUA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("lar"),
        dictgen::InsensitiveStr::Ascii("larly"),
        dictgen::InsensitiveStr::Ascii("lator"),
        dictgen::InsensitiveStr::Ascii("lr"),
        dictgen::InsensitiveStr::Ascii("lrly"),
        dictgen::InsensitiveStr::Ascii("lrs"),
        dictgen::InsensitiveStr::Ascii("lte"),
        dictgen::InsensitiveStr::Ascii("lting"),
        dictgen::InsensitiveStr::Ascii("ltion"),
        dictgen::InsensitiveStr::Ascii("ltions"),
        dictgen::InsensitiveStr::Ascii("ltor"),
        dictgen::InsensitiveStr::Ascii("ltors"),
        dictgen::InsensitiveStr::Ascii("rdless"),
        dictgen::InsensitiveStr::Ascii("rldess"),
        dictgen::InsensitiveStr::Ascii("rlise"),
        dictgen::InsensitiveStr::Ascii("rliser"),
        dictgen::InsensitiveStr::Ascii("rlize"),
        dictgen::InsensitiveStr::Ascii("rlizer"),
        dictgen::InsensitiveStr::Ascii("rly"),
        dictgen::InsensitiveStr::Ascii("tor"),
    ],
    values: &[
        &["regular"],
        &["regularly"],
        &["regulator"],
        &["regular"],
        &["regularly"],
        &["regulars"],
        &["regulate"],
        &["regulating"],
        &["regulations"],
        &["regulations"],
        &["regulator"],
        &["regulators"],
        &["regardless"],
        &["regardless"],
        &["regularise"],
        &["regulariser"],
        &["regularize"],
        &["regularizer"],
        &["regularly"],
        &["regulator"],
    ],
    range: 2..=6,
};

static WORD_REGS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REGS_CHILDREN),
    value: None,
};

pub static WORD_REGS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ion"),
        dictgen::InsensitiveStr::Ascii("ions"),
        dictgen::InsensitiveStr::Ascii("iter"),
        dictgen::InsensitiveStr::Ascii("itered"),
        dictgen::InsensitiveStr::Ascii("itering"),
        dictgen::InsensitiveStr::Ascii("iters"),
        dictgen::InsensitiveStr::Ascii("itration"),
        dictgen::InsensitiveStr::Ascii("itry"),
        dictgen::InsensitiveStr::Ascii("ter"),
        dictgen::InsensitiveStr::Ascii("tered"),
        dictgen::InsensitiveStr::Ascii("tering"),
        dictgen::InsensitiveStr::Ascii("ters"),
        dictgen::InsensitiveStr::Ascii("try"),
    ],
    values: &[
        &["region"],
        &["regions"],
        &["register"],
        &["registered"],
        &["registering"],
        &["registers"],
        &["registration"],
        &["registry"],
        &["register"],
        &["registered"],
        &["registering"],
        &["registers"],
        &["registry"],
    ],
    range: 3..=8,
};

static WORD_REGR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REGR_CHILDREN),
    value: None,
};

pub static WORD_REGR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("esas"),
        dictgen::InsensitiveStr::Ascii("eses"),
        dictgen::InsensitiveStr::Ascii("esion"),
        dictgen::InsensitiveStr::Ascii("esison"),
        dictgen::InsensitiveStr::Ascii("esives"),
        dictgen::InsensitiveStr::Ascii("esos"),
        dictgen::InsensitiveStr::Ascii("esse"),
        dictgen::InsensitiveStr::Ascii("essivo"),
        dictgen::InsensitiveStr::Ascii("esso"),
        dictgen::InsensitiveStr::Ascii("esssion"),
        dictgen::InsensitiveStr::Ascii("esssive"),
        dictgen::InsensitiveStr::Ascii("est"),
        dictgen::InsensitiveStr::Ascii("ests"),
        dictgen::InsensitiveStr::Ascii("etts"),
        dictgen::InsensitiveStr::Ascii("igerator"),
    ],
    values: &[
        &["regress"],
        &["regress"],
        &["regression"],
        &["regression"],
        &["regressive"],
        &["regress"],
        &["regressive"],
        &["regression"],
        &["regression"],
        &["regression"],
        &["regressive"],
        &["regrets"],
        &["regress"],
        &["regrets"],
        &["refrigerator"],
    ],
    range: 3..=8,
};

static WORD_REGO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REGO_CHILDREN),
    value: None,
};

pub static WORD_REGO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cnition"),
        dictgen::InsensitiveStr::Ascii("n"),
        dictgen::InsensitiveStr::Ascii("ns"),
        dictgen::InsensitiveStr::Ascii("rded"),
    ],
    values: &[&["recognition"], &["region"], &["regions"], &["recorded"]],
    range: 1..=7,
};

static WORD_REGL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REGL_CHILDREN),
    value: None,
};

pub static WORD_REGL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("uar")],
    values: &[&["regular"]],
    range: 3..=3,
};

static WORD_REGI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REGI_CHILDREN),
    value: None,
};

pub static WORD_REGI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("dstered"),
        dictgen::InsensitiveStr::Ascii("ems"),
        dictgen::InsensitiveStr::Ascii("met"),
        dictgen::InsensitiveStr::Ascii("o"),
        dictgen::InsensitiveStr::Ascii("onaal"),
        dictgen::InsensitiveStr::Ascii("ones"),
        dictgen::InsensitiveStr::Ascii("ser"),
        dictgen::InsensitiveStr::Ascii("sration"),
        dictgen::InsensitiveStr::Ascii("srty"),
        dictgen::InsensitiveStr::Ascii("st"),
        dictgen::InsensitiveStr::Ascii("startion"),
        dictgen::InsensitiveStr::Ascii("station"),
        dictgen::InsensitiveStr::Ascii("ste"),
        dictgen::InsensitiveStr::Ascii("sted"),
        dictgen::InsensitiveStr::Ascii("steing"),
        dictgen::InsensitiveStr::Ascii("steration"),
        dictgen::InsensitiveStr::Ascii("sterd"),
        dictgen::InsensitiveStr::Ascii("sterdns"),
        dictgen::InsensitiveStr::Ascii("sterered"),
        dictgen::InsensitiveStr::Ascii("steres"),
        dictgen::InsensitiveStr::Ascii("steresd"),
        dictgen::InsensitiveStr::Ascii("steries"),
        dictgen::InsensitiveStr::Ascii("sterred"),
        dictgen::InsensitiveStr::Ascii("sterss"),
        dictgen::InsensitiveStr::Ascii("stert"),
        dictgen::InsensitiveStr::Ascii("stery"),
        dictgen::InsensitiveStr::Ascii("stes"),
        dictgen::InsensitiveStr::Ascii("sting"),
        dictgen::InsensitiveStr::Ascii("stors"),
        dictgen::InsensitiveStr::Ascii("strain"),
        dictgen::InsensitiveStr::Ascii("straion"),
        dictgen::InsensitiveStr::Ascii("straions"),
        dictgen::InsensitiveStr::Ascii("straration"),
        dictgen::InsensitiveStr::Ascii("strated"),
        dictgen::InsensitiveStr::Ascii("strating"),
        dictgen::InsensitiveStr::Ascii("strato"),
        dictgen::InsensitiveStr::Ascii("stred"),
        dictgen::InsensitiveStr::Ascii("strer"),
        dictgen::InsensitiveStr::Ascii("strers"),
        dictgen::InsensitiveStr::Ascii("stres"),
        dictgen::InsensitiveStr::Ascii("string"),
        dictgen::InsensitiveStr::Ascii("strs"),
        dictgen::InsensitiveStr::Ascii("stser"),
        dictgen::InsensitiveStr::Ascii("stsers"),
        dictgen::InsensitiveStr::Ascii("sty"),
        dictgen::InsensitiveStr::Ascii("ter"),
        dictgen::InsensitiveStr::Ascii("tered"),
        dictgen::InsensitiveStr::Ascii("tering"),
        dictgen::InsensitiveStr::Ascii("ters"),
    ],
    values: &[
        &["registered"],
        &["regimes"],
        &["regiment"],
        &["region"],
        &["regional"],
        &["regions"],
        &["register"],
        &["registration"],
        &["registry"],
        &["register"],
        &["registration"],
        &["registration"],
        &["register"],
        &["registered"],
        &["registering"],
        &["registration"],
        &["registered", "registers"],
        &["registers"],
        &["registered"],
        &["registers"],
        &["registered"],
        &["registers"],
        &["registered"],
        &["registers"],
        &["registered"],
        &["registry"],
        &["registers"],
        &["registering"],
        &["registers"],
        &["registration"],
        &["registration"],
        &["registrations"],
        &["registration"],
        &["registered"],
        &["registration"],
        &["registration"],
        &["registered"],
        &["register"],
        &["registers"],
        &["registries", "registers"],
        &["registering"],
        &["registers"],
        &["register"],
        &["registers"],
        &["registry"],
        &["register"],
        &["registered"],
        &["registering"],
        &["registers"],
    ],
    range: 1..=10,
};

static WORD_REGE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REGE_CHILDREN),
    value: None,
};

pub static WORD_REGE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ister"),
        dictgen::InsensitiveStr::Ascii("istered"),
        dictgen::InsensitiveStr::Ascii("istration"),
        dictgen::InsensitiveStr::Ascii("nade"),
        dictgen::InsensitiveStr::Ascii("narate"),
        dictgen::InsensitiveStr::Ascii("narated"),
        dictgen::InsensitiveStr::Ascii("naration"),
        dictgen::InsensitiveStr::Ascii("neracion"),
        dictgen::InsensitiveStr::Ascii("neratin"),
        dictgen::InsensitiveStr::Ascii("neraton"),
        dictgen::InsensitiveStr::Ascii("nere"),
        dictgen::InsensitiveStr::Ascii("nrated"),
        dictgen::InsensitiveStr::Ascii("nratet"),
        dictgen::InsensitiveStr::Ascii("nrating"),
        dictgen::InsensitiveStr::Ascii("nration"),
        dictgen::InsensitiveStr::Ascii("nrative"),
        dictgen::InsensitiveStr::Ascii("rts"),
        dictgen::InsensitiveStr::Ascii("ssion"),
        dictgen::InsensitiveStr::Ascii("ster"),
        dictgen::InsensitiveStr::Ascii("stered"),
        dictgen::InsensitiveStr::Ascii("sters"),
        dictgen::InsensitiveStr::Ascii("stration"),
    ],
    values: &[
        &["register"],
        &["registered"],
        &["registration"],
        &["renegade"],
        &["regenerate"],
        &["regenerated"],
        &["regeneration"],
        &["regeneration"],
        &["regeneration"],
        &["regeneration"],
        &["regenerate"],
        &["regenerated"],
        &["regenerated"],
        &["regenerating"],
        &["regeneration"],
        &["regenerative"],
        &["regrets"],
        &["regression"],
        &["register"],
        &["registered"],
        &["registers"],
        &["registration"],
    ],
    range: 3..=9,
};

static WORD_REGC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REGC_CHILDREN),
    value: None,
};

pub static WORD_REGC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("onized")],
    values: &[&["recognized"]],
    range: 6..=6,
};

static WORD_REGA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REGA_CHILDREN),
    value: None,
};

pub static WORD_REGA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("lar"),
        dictgen::InsensitiveStr::Ascii("lars"),
        dictgen::InsensitiveStr::Ascii("rdes"),
        dictgen::InsensitiveStr::Ascii("rdles"),
        dictgen::InsensitiveStr::Ascii("rdlesss"),
        dictgen::InsensitiveStr::Ascii("rgless"),
        dictgen::InsensitiveStr::Ascii("ring"),
        dictgen::InsensitiveStr::Ascii("rldess"),
        dictgen::InsensitiveStr::Ascii("rless"),
        dictgen::InsensitiveStr::Ascii("rt"),
        dictgen::InsensitiveStr::Ascii("rted"),
        dictgen::InsensitiveStr::Ascii("rting"),
        dictgen::InsensitiveStr::Ascii("rtless"),
    ],
    values: &[
        &["regular"],
        &["regulars"],
        &["regards"],
        &["regardless"],
        &["regardless"],
        &["regardless"],
        &["regarding"],
        &["regardless"],
        &["regardless"],
        &["regard"],
        &["regarded"],
        &["regarding"],
        &["regardless"],
    ],
    range: 2..=7,
};

static WORD_REF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_REF_CHILDREN),
    value: None,
};

static WORD_REF_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_REFA_NODE),
    None,
    Some(&WORD_REFC_NODE),
    None,
    Some(&WORD_REFE_NODE),
    Some(&WORD_REFF_NODE),
    None,
    None,
    Some(&WORD_REFI_NODE),
    None,
    None,
    Some(&WORD_REFL_NODE),
    None,
    None,
    Some(&WORD_REFO_NODE),
    None,
    None,
    Some(&WORD_REFR_NODE),
    None,
    None,
    Some(&WORD_REFU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_REFU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REFU_CHILDREN),
    value: None,
};

pub static WORD_REFU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("brished"),
        dictgen::InsensitiveStr::Ascii("rbised"),
        dictgen::InsensitiveStr::Ascii("rbushed"),
        dictgen::InsensitiveStr::Ascii("re"),
        dictgen::InsensitiveStr::Ascii("res"),
        dictgen::InsensitiveStr::Ascii("sla"),
    ],
    values: &[
        &["refurbished"],
        &["refurbished"],
        &["refurbished"],
        &["refuse"],
        &["refuses"],
        &["refusal"],
    ],
    range: 2..=7,
};

static WORD_REFR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REFR_CHILDREN),
    value: None,
};

pub static WORD_REFR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eh"),
        dictgen::InsensitiveStr::Ascii("ehser"),
        dictgen::InsensitiveStr::Ascii("eing"),
        dictgen::InsensitiveStr::Ascii("ence"),
        dictgen::InsensitiveStr::Ascii("enced"),
        dictgen::InsensitiveStr::Ascii("ences"),
        dictgen::InsensitiveStr::Ascii("encing"),
        dictgen::InsensitiveStr::Ascii("erence"),
        dictgen::InsensitiveStr::Ascii("erenced"),
        dictgen::InsensitiveStr::Ascii("erenceing"),
        dictgen::InsensitiveStr::Ascii("erences"),
        dictgen::InsensitiveStr::Ascii("erencial"),
        dictgen::InsensitiveStr::Ascii("ers"),
        dictgen::InsensitiveStr::Ascii("eshd"),
        dictgen::InsensitiveStr::Ascii("eshener"),
        dictgen::InsensitiveStr::Ascii("eshr"),
        dictgen::InsensitiveStr::Ascii("eshs"),
        dictgen::InsensitiveStr::Ascii("eshses"),
        dictgen::InsensitiveStr::Ascii("iderator"),
        dictgen::InsensitiveStr::Ascii("idgeration"),
        dictgen::InsensitiveStr::Ascii("idgerator"),
        dictgen::InsensitiveStr::Ascii("igarator"),
        dictgen::InsensitiveStr::Ascii("igerador"),
        dictgen::InsensitiveStr::Ascii("igerar"),
        dictgen::InsensitiveStr::Ascii("igerater"),
        dictgen::InsensitiveStr::Ascii("igirator"),
        dictgen::InsensitiveStr::Ascii("om"),
        dictgen::InsensitiveStr::Ascii("omation"),
        dictgen::InsensitiveStr::Ascii("omatting"),
        dictgen::InsensitiveStr::Ascii("omed"),
        dictgen::InsensitiveStr::Ascii("oming"),
        dictgen::InsensitiveStr::Ascii("omist"),
        dictgen::InsensitiveStr::Ascii("omists"),
        dictgen::InsensitiveStr::Ascii("oms"),
        dictgen::InsensitiveStr::Ascii("ormatting"),
        dictgen::InsensitiveStr::Ascii("ubished"),
    ],
    values: &[
        &["refresh"],
        &["refresher"],
        &["referring"],
        &["reference"],
        &["referenced"],
        &["references"],
        &["referencing"],
        &["reference"],
        &["referenced"],
        &["referencing"],
        &["references"],
        &["referential"],
        &["refers"],
        &["refreshed"],
        &["refresher"],
        &["refresher"],
        &["refreshes"],
        &["refreshes"],
        &["refrigerator"],
        &["refrigeration"],
        &["refrigerator"],
        &["refrigerator"],
        &["refrigerator"],
        &["refrigerator"],
        &["refrigerator"],
        &["refrigerator"],
        &["reform"],
        &["reformation"],
        &["refomatting"],
        &["reformed"],
        &["reforming"],
        &["reformist"],
        &["reformists"],
        &["reforms"],
        &["reformatting"],
        &["refurbished"],
    ],
    range: 2..=10,
};

static WORD_REFO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REFO_CHILDREN),
    value: None,
};

pub static WORD_REFO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cuss"),
        dictgen::InsensitiveStr::Ascii("cussed"),
        dictgen::InsensitiveStr::Ascii("rmated"),
        dictgen::InsensitiveStr::Ascii("rmating"),
        dictgen::InsensitiveStr::Ascii("rmattd"),
        dictgen::InsensitiveStr::Ascii("rmerad"),
        dictgen::InsensitiveStr::Ascii("rmes"),
    ],
    values: &[
        &["refocus"],
        &["refocused"],
        &["reformatted"],
        &["reformatting"],
        &["reformatted"],
        &["reformed"],
        &["reforms"],
    ],
    range: 4..=7,
};

static WORD_REFL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REFL_CHILDREN),
    value: None,
};

pub static WORD_REFL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eciton"),
        dictgen::InsensitiveStr::Ascii("ecte"),
        dictgen::InsensitiveStr::Ascii("ecters"),
        dictgen::InsensitiveStr::Ascii("ectie"),
        dictgen::InsensitiveStr::Ascii("ectivos"),
        dictgen::InsensitiveStr::Ascii("ecto"),
        dictgen::InsensitiveStr::Ascii("ektion"),
        dictgen::InsensitiveStr::Ascii("et"),
        dictgen::InsensitiveStr::Ascii("eted"),
        dictgen::InsensitiveStr::Ascii("eting"),
        dictgen::InsensitiveStr::Ascii("etion"),
        dictgen::InsensitiveStr::Ascii("etions"),
        dictgen::InsensitiveStr::Ascii("ets"),
        dictgen::InsensitiveStr::Ascii("exs"),
        dictgen::InsensitiveStr::Ascii("extion"),
    ],
    values: &[
        &["reflections"],
        &["reflective"],
        &["reflects"],
        &["reflective"],
        &["reflections"],
        &["reflection"],
        &["reflection"],
        &["reflect"],
        &["reflected"],
        &["reflecting"],
        &["reflection"],
        &["reflections"],
        &["reflects"],
        &["reflexes"],
        &["reflection"],
    ],
    range: 2..=7,
};

static WORD_REFI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REFI_CHILDREN),
    value: None,
};

pub static WORD_REFI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("lles"),
        dictgen::InsensitiveStr::Ascii("llls"),
        dictgen::InsensitiveStr::Ascii("nemenet"),
        dictgen::InsensitiveStr::Ascii("nmenet"),
        dictgen::InsensitiveStr::Ascii("nment"),
        dictgen::InsensitiveStr::Ascii("rgerator"),
    ],
    values: &[
        &["refills"],
        &["refills"],
        &["refinement"],
        &["refinement"],
        &["refinement"],
        &["refrigerator"],
    ],
    range: 4..=8,
};

static WORD_REFF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REFF_CHILDREN),
    value: None,
};

pub static WORD_REFF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ered"),
        dictgen::InsensitiveStr::Ascii("erence"),
        dictgen::InsensitiveStr::Ascii("eres"),
        dictgen::InsensitiveStr::Ascii("ering"),
        dictgen::InsensitiveStr::Ascii("err"),
        dictgen::InsensitiveStr::Ascii("ers"),
    ],
    values: &[
        &["referred"],
        &["reference"],
        &["refers", "referees"],
        &["referring"],
        &["refer"],
        &["refers"],
    ],
    range: 3..=6,
};

static WORD_REFE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_REFE_CHILDREN),
    value: None,
};

static WORD_REFE_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    Some(&WORD_REFEC_NODE),
    Some(&WORD_REFED_NODE),
    Some(&WORD_REFEE_NODE),
    None,
    None,
    None,
    Some(&WORD_REFEI_NODE),
    None,
    None,
    Some(&WORD_REFEL_NODE),
    None,
    Some(&WORD_REFEN_NODE),
    None,
    None,
    None,
    Some(&WORD_REFER_NODE),
    Some(&WORD_REFES_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_REFES_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REFES_CHILDREN),
    value: None,
};

pub static WORD_REFES_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("h"),
        dictgen::InsensitiveStr::Ascii("hed"),
        dictgen::InsensitiveStr::Ascii("hes"),
        dictgen::InsensitiveStr::Ascii("hing"),
    ],
    values: &[
        &["refresh"],
        &["refreshed"],
        &["refreshes"],
        &["refreshing"],
    ],
    range: 1..=4,
};

static WORD_REFER_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_REFER_CHILDREN),
    value: None,
};

static WORD_REFER_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_REFERA_NODE),
    None,
    None,
    None,
    Some(&WORD_REFERE_NODE),
    None,
    None,
    None,
    Some(&WORD_REFERI_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_REFERN_NODE),
    None,
    None,
    None,
    Some(&WORD_REFERR_NODE),
    Some(&WORD_REFERS_NODE),
    Some(&WORD_REFERT_NODE),
    Some(&WORD_REFERU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_REFERU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REFERU_CHILDREN),
    value: None,
};

pub static WORD_REFERU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ndum")],
    values: &[&["referendum"]],
    range: 4..=4,
};

static WORD_REFERT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REFERT_CHILDREN),
    value: None,
};

pub static WORD_REFERT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ence"),
        dictgen::InsensitiveStr::Ascii("enced"),
        dictgen::InsensitiveStr::Ascii("ences"),
    ],
    values: &[&["reference"], &["referenced"], &["references"]],
    range: 4..=5,
};

static WORD_REFERS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REFERS_CHILDREN),
    value: None,
};

pub static WORD_REFERS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("hed"),
        dictgen::InsensitiveStr::Ascii("her"),
    ],
    values: &[&["refreshed"], &["refresher"]],
    range: 3..=3,
};

static WORD_REFERR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REFERR_CHILDREN),
    value: Some(&["refer"]),
};

pub static WORD_REFERR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ence"),
        dictgen::InsensitiveStr::Ascii("enced"),
        dictgen::InsensitiveStr::Ascii("ences"),
        dictgen::InsensitiveStr::Ascii("encing"),
        dictgen::InsensitiveStr::Ascii("eres"),
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("red"),
        dictgen::InsensitiveStr::Ascii("s"),
    ],
    values: &[
        &["reference"],
        &["referenced"],
        &["references"],
        &["referencing"],
        &["referrers"],
        &["refers"],
        &["referred"],
        &["refers"],
    ],
    range: 1..=6,
};

static WORD_REFERN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REFERN_CHILDREN),
    value: None,
};

pub static WORD_REFERN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ce"),
        dictgen::InsensitiveStr::Ascii("ced"),
        dictgen::InsensitiveStr::Ascii("cence"),
        dictgen::InsensitiveStr::Ascii("cences"),
        dictgen::InsensitiveStr::Ascii("ces"),
        dictgen::InsensitiveStr::Ascii("cial"),
        dictgen::InsensitiveStr::Ascii("cing"),
        dictgen::InsensitiveStr::Ascii("ece"),
        dictgen::InsensitiveStr::Ascii("eced"),
        dictgen::InsensitiveStr::Ascii("eces"),
        dictgen::InsensitiveStr::Ascii("nce"),
    ],
    values: &[
        &["reference"],
        &["referenced"],
        &["reference"],
        &["references"],
        &["references"],
        &["referential"],
        &["referencing"],
        &["reference"],
        &["referenced"],
        &["references"],
        &["reference"],
    ],
    range: 2..=6,
};

static WORD_REFERI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REFERI_CHILDREN),
    value: None,
};

pub static WORD_REFERI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ang"),
        dictgen::InsensitiveStr::Ascii("g"),
        dictgen::InsensitiveStr::Ascii("gn"),
        dictgen::InsensitiveStr::Ascii("ncing"),
        dictgen::InsensitiveStr::Ascii("ng"),
        dictgen::InsensitiveStr::Ascii("nng"),
    ],
    values: &[
        &["referring"],
        &["referring"],
        &["referring"],
        &["referencing"],
        &["referring"],
        &["referring"],
    ],
    range: 1..=5,
};

static WORD_REFERE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REFERE_CHILDREN),
    value: Some(&["refer", "referee"]),
};

pub static WORD_REFERE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("bces"),
        dictgen::InsensitiveStr::Ascii("ce"),
        dictgen::InsensitiveStr::Ascii("cence"),
        dictgen::InsensitiveStr::Ascii("cences"),
        dictgen::InsensitiveStr::Ascii("ces"),
        dictgen::InsensitiveStr::Ascii("cne"),
        dictgen::InsensitiveStr::Ascii("d"),
        dictgen::InsensitiveStr::Ascii("de"),
        dictgen::InsensitiveStr::Ascii("ees"),
        dictgen::InsensitiveStr::Ascii("ers"),
        dictgen::InsensitiveStr::Ascii("fences"),
        dictgen::InsensitiveStr::Ascii("mce"),
        dictgen::InsensitiveStr::Ascii("mces"),
        dictgen::InsensitiveStr::Ascii("mdum"),
        dictgen::InsensitiveStr::Ascii("nace"),
        dictgen::InsensitiveStr::Ascii("nc"),
        dictgen::InsensitiveStr::Ascii("ncable"),
        dictgen::InsensitiveStr::Ascii("nceing"),
        dictgen::InsensitiveStr::Ascii("ncial"),
        dictgen::InsensitiveStr::Ascii("ncially"),
        dictgen::InsensitiveStr::Ascii("ncs"),
        dictgen::InsensitiveStr::Ascii("nct"),
        dictgen::InsensitiveStr::Ascii("ndim"),
        dictgen::InsensitiveStr::Ascii("ndom"),
        dictgen::InsensitiveStr::Ascii("ne"),
        dictgen::InsensitiveStr::Ascii("nece"),
        dictgen::InsensitiveStr::Ascii("neced"),
        dictgen::InsensitiveStr::Ascii("neces"),
        dictgen::InsensitiveStr::Ascii("necs"),
        dictgen::InsensitiveStr::Ascii("ned"),
        dictgen::InsensitiveStr::Ascii("nence"),
        dictgen::InsensitiveStr::Ascii("nenced"),
        dictgen::InsensitiveStr::Ascii("nences"),
        dictgen::InsensitiveStr::Ascii("nes"),
        dictgen::InsensitiveStr::Ascii("ning"),
        dictgen::InsensitiveStr::Ascii("nnces"),
        dictgen::InsensitiveStr::Ascii("ns"),
        dictgen::InsensitiveStr::Ascii("nse"),
        dictgen::InsensitiveStr::Ascii("nsed"),
        dictgen::InsensitiveStr::Ascii("nses"),
        dictgen::InsensitiveStr::Ascii("ntes"),
        dictgen::InsensitiveStr::Ascii("nz"),
        dictgen::InsensitiveStr::Ascii("nzes"),
        dictgen::InsensitiveStr::Ascii("rd"),
        dictgen::InsensitiveStr::Ascii("re"),
        dictgen::InsensitiveStr::Ascii("rence"),
        dictgen::InsensitiveStr::Ascii("rs"),
        dictgen::InsensitiveStr::Ascii("s"),
    ],
    values: &[
        &["references"],
        &["reference"],
        &["reference"],
        &["references"],
        &["references"],
        &["reference"],
        &["referred"],
        &["referee"],
        &["referees"],
        &["referees"],
        &["references"],
        &["reference"],
        &["references"],
        &["referendum"],
        &["reference"],
        &["reference"],
        &["referenceable"],
        &["referencing"],
        &["referential"],
        &["referentially"],
        &["references"],
        &["referenced"],
        &["referendum"],
        &["referendum"],
        &["referee", "reference"],
        &["reference"],
        &["referenced"],
        &["references"],
        &["references"],
        &["referenced"],
        &["reference"],
        &["referenced"],
        &["references"],
        &["references"],
        &["referencing"],
        &["references"],
        &["references"],
        &["references", "reference"],
        &["referenced"],
        &["referees", "references"],
        &["references"],
        &["reference"],
        &["references"],
        &["referred"],
        &["referee"],
        &["reference"],
        &["referrer", "referrers"],
        &["refers", "referees"],
    ],
    range: 1..=7,
};

static WORD_REFERA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REFERA_CHILDREN),
    value: None,
};

pub static WORD_REFERA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("l"),
        dictgen::InsensitiveStr::Ascii("nce"),
        dictgen::InsensitiveStr::Ascii("nced"),
        dictgen::InsensitiveStr::Ascii("nces"),
        dictgen::InsensitiveStr::Ascii("ncing"),
        dictgen::InsensitiveStr::Ascii("ndum"),
        dictgen::InsensitiveStr::Ascii("nt"),
    ],
    values: &[
        &["referral"],
        &["reference"],
        &["referenced"],
        &["references"],
        &["referencing"],
        &["referendum"],
        &["referent"],
    ],
    range: 1..=5,
};

static WORD_REFEN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REFEN_CHILDREN),
    value: None,
};

pub static WORD_REFEN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ce"),
        dictgen::InsensitiveStr::Ascii("ces"),
        dictgen::InsensitiveStr::Ascii("ence"),
        dictgen::InsensitiveStr::Ascii("renced"),
    ],
    values: &[
        &["reference"],
        &["references"],
        &["reference"],
        &["referenced"],
    ],
    range: 2..=6,
};

static WORD_REFEL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REFEL_CHILDREN),
    value: None,
};

pub static WORD_REFEL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ct"),
        dictgen::InsensitiveStr::Ascii("cted"),
        dictgen::InsensitiveStr::Ascii("cting"),
        dictgen::InsensitiveStr::Ascii("ction"),
        dictgen::InsensitiveStr::Ascii("ctions"),
        dictgen::InsensitiveStr::Ascii("ctive"),
        dictgen::InsensitiveStr::Ascii("cts"),
        dictgen::InsensitiveStr::Ascii("ects"),
        dictgen::InsensitiveStr::Ascii("xes"),
    ],
    values: &[
        &["reflect"],
        &["reflected"],
        &["reflecting"],
        &["reflection"],
        &["reflections"],
        &["reflective"],
        &["reflects"],
        &["reflects"],
        &["reflexes"],
    ],
    range: 2..=6,
};

static WORD_REFEI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REFEI_CHILDREN),
    value: None,
};

pub static WORD_REFEI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("nement"),
        dictgen::InsensitiveStr::Ascii("nements"),
    ],
    values: &[&["refinement"], &["refinements"]],
    range: 6..=7,
};

static WORD_REFEE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REFEE_CHILDREN),
    value: None,
};

pub static WORD_REFEE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("res")],
    values: &[&["referees"]],
    range: 3..=3,
};

static WORD_REFED_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REFED_CHILDREN),
    value: None,
};

pub static WORD_REFED_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("endum")],
    values: &[&["referendum"]],
    range: 5..=5,
};

static WORD_REFEC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REFEC_CHILDREN),
    value: None,
};

pub static WORD_REFEC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("ted"),
        dictgen::InsensitiveStr::Ascii("ting"),
        dictgen::InsensitiveStr::Ascii("tiv"),
        dictgen::InsensitiveStr::Ascii("tor"),
        dictgen::InsensitiveStr::Ascii("toring"),
        dictgen::InsensitiveStr::Ascii("ts"),
    ],
    values: &[
        &["reflect"],
        &["reflected"],
        &["reflecting"],
        &["reflective"],
        &["refactor"],
        &["refactoring"],
        &["reflects"],
    ],
    range: 1..=6,
};

static WORD_REFC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REFC_CHILDREN),
    value: None,
};

pub static WORD_REFC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ound"),
        dictgen::InsensitiveStr::Ascii("ounf"),
    ],
    values: &[&["refcount"], &["refcount"]],
    range: 4..=4,
};

static WORD_REFA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REFA_CHILDREN),
    value: None,
};

pub static WORD_REFA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("rtor"),
        dictgen::InsensitiveStr::Ascii("rtored"),
        dictgen::InsensitiveStr::Ascii("rtoring"),
    ],
    values: &[
        &["refactor", "refractor"],
        &["refactored", "refracted"],
        &["refactoring", "refractoring"],
    ],
    range: 4..=7,
};

static WORD_REE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REE_CHILDREN),
    value: None,
};

pub static WORD_REE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ase"),
        dictgen::InsensitiveStr::Ascii("ased"),
        dictgen::InsensitiveStr::Ascii("aser"),
        dictgen::InsensitiveStr::Ascii("asers"),
        dictgen::InsensitiveStr::Ascii("ases"),
        dictgen::InsensitiveStr::Ascii("asing"),
        dictgen::InsensitiveStr::Ascii("demed"),
        dictgen::InsensitiveStr::Ascii("deming"),
        dictgen::InsensitiveStr::Ascii("gion"),
        dictgen::InsensitiveStr::Ascii("gions"),
        dictgen::InsensitiveStr::Ascii("lation"),
        dictgen::InsensitiveStr::Ascii("lease"),
        dictgen::InsensitiveStr::Ascii("name"),
        dictgen::InsensitiveStr::Ascii("ncarnation"),
        dictgen::InsensitiveStr::Ascii("nfoce"),
        dictgen::InsensitiveStr::Ascii("nfoced"),
        dictgen::InsensitiveStr::Ascii("nfocement"),
        dictgen::InsensitiveStr::Ascii("nfoces"),
        dictgen::InsensitiveStr::Ascii("nfocing"),
        dictgen::InsensitiveStr::Ascii("nforcement"),
        dictgen::InsensitiveStr::Ascii("nforcements"),
        dictgen::InsensitiveStr::Ascii("srved"),
        dictgen::InsensitiveStr::Ascii("sult"),
        dictgen::InsensitiveStr::Ascii("turn"),
        dictgen::InsensitiveStr::Ascii("turned"),
        dictgen::InsensitiveStr::Ascii("turning"),
        dictgen::InsensitiveStr::Ascii("turns"),
        dictgen::InsensitiveStr::Ascii("valulate"),
        dictgen::InsensitiveStr::Ascii("valutate"),
        dictgen::InsensitiveStr::Ascii("valute"),
        dictgen::InsensitiveStr::Ascii("vaulate"),
        dictgen::InsensitiveStr::Ascii("vaulated"),
        dictgen::InsensitiveStr::Ascii("vaulating"),
    ],
    values: &[
        &["release"],
        &["released"],
        &["releaser"],
        &["releasers"],
        &["releases"],
        &["releasing"],
        &["redeemed"],
        &["redeeming"],
        &["region"],
        &["regions"],
        &["relation"],
        &["release"],
        &["rename"],
        &["reincarnation"],
        &["reenforce"],
        &["reenforced"],
        &["reinforcement"],
        &["reenforces"],
        &["reenforcing"],
        &["reinforcement"],
        &["reinforcements"],
        &["reserved"],
        &["result"],
        &["return"],
        &["returned"],
        &["returning"],
        &["returns"],
        &["reevaluate"],
        &["reevaluate"],
        &["reevaluate"],
        &["reevaluate"],
        &["reevaluate"],
        &["reevaluating"],
    ],
    range: 3..=11,
};

static WORD_RED_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_RED_CHILDREN),
    value: None,
};

static WORD_RED_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_REDA_NODE),
    None,
    Some(&WORD_REDC_NODE),
    None,
    Some(&WORD_REDE_NODE),
    None,
    None,
    None,
    Some(&WORD_REDI_NODE),
    None,
    None,
    Some(&WORD_REDL_NODE),
    Some(&WORD_REDM_NODE),
    Some(&WORD_REDN_NODE),
    Some(&WORD_REDO_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_REDU_NODE),
    None,
    None,
    None,
    Some(&WORD_REDY_NODE),
    None,
];

static WORD_REDY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REDY_CHILDREN),
    value: Some(&["ready", "red"]),
};

pub static WORD_REDY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[],
    values: &[],
    range: 0..=0,
};

static WORD_REDU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REDU_CHILDREN),
    value: None,
};

pub static WORD_REDU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ceable"),
        dictgen::InsensitiveStr::Ascii("dancy"),
        dictgen::InsensitiveStr::Ascii("dant"),
        dictgen::InsensitiveStr::Ascii("nancy"),
        dictgen::InsensitiveStr::Ascii("nant"),
        dictgen::InsensitiveStr::Ascii("ncancy"),
        dictgen::InsensitiveStr::Ascii("ncant"),
        dictgen::InsensitiveStr::Ascii("ndacy"),
        dictgen::InsensitiveStr::Ascii("ndand"),
        dictgen::InsensitiveStr::Ascii("ndantcy"),
        dictgen::InsensitiveStr::Ascii("ndany"),
        dictgen::InsensitiveStr::Ascii("ndat"),
        dictgen::InsensitiveStr::Ascii("ndency"),
        dictgen::InsensitiveStr::Ascii("ndent"),
        dictgen::InsensitiveStr::Ascii("ndnacy"),
        dictgen::InsensitiveStr::Ascii("nduncy"),
        dictgen::InsensitiveStr::Ascii("ntancy"),
        dictgen::InsensitiveStr::Ascii("ntant"),
        dictgen::InsensitiveStr::Ascii("se"),
    ],
    values: &[
        &["reducible"],
        &["redundancy"],
        &["redundant"],
        &["redundancy"],
        &["redundant"],
        &["redundancy"],
        &["redundant"],
        &["redundancy"],
        &["redundant"],
        &["redundancy"],
        &["redundancy"],
        &["redundant"],
        &["redundancy"],
        &["redundant"],
        &["redundancy"],
        &["redundancy"],
        &["redundancy"],
        &["redundant"],
        &["reduce", "reuse"],
    ],
    range: 2..=7,
};

static WORD_REDO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REDO_CHILDREN),
    value: None,
};

pub static WORD_REDO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("nly")],
    values: &[&["readonly"]],
    range: 3..=3,
};

static WORD_REDN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REDN_CHILDREN),
    value: None,
};

pub static WORD_REDN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eckers"),
        dictgen::InsensitiveStr::Ascii("eckese"),
        dictgen::InsensitiveStr::Ascii("eckest"),
        dictgen::InsensitiveStr::Ascii("erer"),
        dictgen::InsensitiveStr::Ascii("ers"),
    ],
    values: &[
        &["rednecks"],
        &["rednecks"],
        &["rednecks"],
        &["renderer"],
        &["renders"],
    ],
    range: 3..=6,
};

static WORD_REDM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REDM_CHILDREN),
    value: None,
};

pub static WORD_REDM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("eption")],
    values: &[&["redemption"]],
    range: 6..=6,
};

static WORD_REDL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REDL_CHILDREN),
    value: None,
};

pub static WORD_REDL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("iens")],
    values: &[&["redlines"]],
    range: 4..=4,
};

static WORD_REDI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REDI_CHILDREN),
    value: None,
};

pub static WORD_REDI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ct"),
        dictgen::InsensitiveStr::Ascii("culous"),
        dictgen::InsensitiveStr::Ascii("dual"),
        dictgen::InsensitiveStr::Ascii("ect"),
        dictgen::InsensitiveStr::Ascii("ected"),
        dictgen::InsensitiveStr::Ascii("fine"),
        dictgen::InsensitiveStr::Ascii("finition"),
        dictgen::InsensitiveStr::Ascii("finitions"),
        dictgen::InsensitiveStr::Ascii("fintion"),
        dictgen::InsensitiveStr::Ascii("fintions"),
        dictgen::InsensitiveStr::Ascii("ng"),
        dictgen::InsensitiveStr::Ascii("ngs"),
        dictgen::InsensitiveStr::Ascii("rcet"),
        dictgen::InsensitiveStr::Ascii("rec"),
        dictgen::InsensitiveStr::Ascii("rectd"),
        dictgen::InsensitiveStr::Ascii("rectrion"),
        dictgen::InsensitiveStr::Ascii("sign"),
        dictgen::InsensitiveStr::Ascii("stirbute"),
        dictgen::InsensitiveStr::Ascii("stirbuted"),
        dictgen::InsensitiveStr::Ascii("stirbutes"),
        dictgen::InsensitiveStr::Ascii("stirbuting"),
        dictgen::InsensitiveStr::Ascii("stirbution"),
        dictgen::InsensitiveStr::Ascii("stribucion"),
        dictgen::InsensitiveStr::Ascii("stribuito"),
        dictgen::InsensitiveStr::Ascii("stributeable"),
        dictgen::InsensitiveStr::Ascii("stributin"),
        dictgen::InsensitiveStr::Ascii("stributivo"),
        dictgen::InsensitiveStr::Ascii("strubition"),
        dictgen::InsensitiveStr::Ascii("strubute"),
        dictgen::InsensitiveStr::Ascii("strubuted"),
        dictgen::InsensitiveStr::Ascii("strubution"),
        dictgen::InsensitiveStr::Ascii("strubutions"),
    ],
    values: &[
        &["redirect"],
        &["ridiculous"],
        &["residual"],
        &["redirect"],
        &["redirected"],
        &["redefine"],
        &["redefinition"],
        &["redefinitions"],
        &["redefinition"],
        &["redefinitions"],
        &["reading"],
        &["readings"],
        &["redirect"],
        &["redirect"],
        &["redirected"],
        &["redirection"],
        &["redesign"],
        &["redistribute"],
        &["redistributed"],
        &["redistributes"],
        &["redistributing"],
        &["redistribution"],
        &["redistribution"],
        &["redistribution"],
        &["redistributable"],
        &["redistribution"],
        &["redistribution"],
        &["redistribution"],
        &["redistribute"],
        &["redistributed"],
        &["redistribution"],
        &["redistributions"],
    ],
    range: 2..=12,
};

static WORD_REDE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REDE_CHILDREN),
    value: None,
};

pub static WORD_REDE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("able"),
        dictgen::InsensitiveStr::Ascii("claation"),
        dictgen::InsensitiveStr::Ascii("emd"),
        dictgen::InsensitiveStr::Ascii("emeed"),
        dictgen::InsensitiveStr::Ascii("fiend"),
        dictgen::InsensitiveStr::Ascii("fiende"),
        dictgen::InsensitiveStr::Ascii("finied"),
        dictgen::InsensitiveStr::Ascii("finine"),
        dictgen::InsensitiveStr::Ascii("fintion"),
        dictgen::InsensitiveStr::Ascii("fintions"),
        dictgen::InsensitiveStr::Ascii("isgn"),
        dictgen::InsensitiveStr::Ascii("meed"),
        dictgen::InsensitiveStr::Ascii("mtion"),
        dictgen::InsensitiveStr::Ascii("mtions"),
        dictgen::InsensitiveStr::Ascii("mtpion"),
        dictgen::InsensitiveStr::Ascii("nderer"),
        dictgen::InsensitiveStr::Ascii("pmtion"),
        dictgen::InsensitiveStr::Ascii("red"),
        dictgen::InsensitiveStr::Ascii("sgin"),
        dictgen::InsensitiveStr::Ascii("siging"),
        dictgen::InsensitiveStr::Ascii("sing"),
    ],
    values: &[
        &["readable"],
        &["redeclaration"],
        &["redeemed"],
        &["redeemed"],
        &["redefined"],
        &["redefined"],
        &["redefine"],
        &["redefine"],
        &["redefinition"],
        &["redefinitions"],
        &["redesign"],
        &["redeemed"],
        &["redemption"],
        &["redemptions"],
        &["redemption"],
        &["renderer"],
        &["redemption"],
        &["rendered"],
        &["redesign"],
        &["redesign"],
        &["redesign"],
    ],
    range: 3..=8,
};

static WORD_REDC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REDC_CHILDREN),
    value: None,
};

pub static WORD_REDC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("tion")],
    values: &[&["reduction", "redaction"]],
    range: 4..=4,
};

static WORD_REDA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REDA_CHILDREN),
    value: None,
};

pub static WORD_REDA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("bility"),
        dictgen::InsensitiveStr::Ascii("ble"),
        dictgen::InsensitiveStr::Ascii("ndant"),
    ],
    values: &[&["readability"], &["readable"], &["redundant"]],
    range: 3..=6,
};

static WORD_REC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_REC_CHILDREN),
    value: None,
};

static WORD_REC_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_RECA_NODE),
    None,
    Some(&WORD_RECC_NODE),
    None,
    Some(&WORD_RECE_NODE),
    None,
    Some(&WORD_RECG_NODE),
    Some(&WORD_RECH_NODE),
    Some(&WORD_RECI_NODE),
    Some(&WORD_RECJ_NODE),
    None,
    Some(&WORD_RECL_NODE),
    None,
    Some(&WORD_RECN_NODE),
    Some(&WORD_RECO_NODE),
    Some(&WORD_RECP_NODE),
    Some(&WORD_RECQ_NODE),
    Some(&WORD_RECR_NODE),
    None,
    Some(&WORD_RECT_NODE),
    Some(&WORD_RECU_NODE),
    None,
    None,
    None,
    Some(&WORD_RECY_NODE),
    None,
];

static WORD_RECY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RECY_CHILDREN),
    value: None,
};

pub static WORD_RECY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("clying"),
        dictgen::InsensitiveStr::Ascii("lcing"),
        dictgen::InsensitiveStr::Ascii("le"),
        dictgen::InsensitiveStr::Ascii("led"),
        dictgen::InsensitiveStr::Ascii("les"),
        dictgen::InsensitiveStr::Ascii("ling"),
    ],
    values: &[
        &["recycling"],
        &["recycling"],
        &["recycle"],
        &["recycled"],
        &["recycles"],
        &["recycling"],
    ],
    range: 2..=6,
};

static WORD_RECU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RECU_CHILDREN),
    value: None,
};

pub static WORD_RECU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("de"),
        dictgen::InsensitiveStr::Ascii("iting"),
        dictgen::InsensitiveStr::Ascii("lrively"),
        dictgen::InsensitiveStr::Ascii("n"),
        dictgen::InsensitiveStr::Ascii("nd"),
        dictgen::InsensitiveStr::Ascii("ning"),
        dictgen::InsensitiveStr::Ascii("ring"),
        dictgen::InsensitiveStr::Ascii("rion"),
        dictgen::InsensitiveStr::Ascii("rions"),
        dictgen::InsensitiveStr::Ascii("rison"),
        dictgen::InsensitiveStr::Ascii("risvely"),
        dictgen::InsensitiveStr::Ascii("rited"),
        dictgen::InsensitiveStr::Ascii("riter"),
        dictgen::InsensitiveStr::Ascii("riters"),
        dictgen::InsensitiveStr::Ascii("ritment"),
        dictgen::InsensitiveStr::Ascii("rits"),
        dictgen::InsensitiveStr::Ascii("rively"),
        dictgen::InsensitiveStr::Ascii("rrance"),
        dictgen::InsensitiveStr::Ascii("rsily"),
        dictgen::InsensitiveStr::Ascii("rsivelly"),
        dictgen::InsensitiveStr::Ascii("rsivion"),
        dictgen::InsensitiveStr::Ascii("rsivley"),
        dictgen::InsensitiveStr::Ascii("rsivly"),
        dictgen::InsensitiveStr::Ascii("rsse"),
        dictgen::InsensitiveStr::Ascii("rssed"),
        dictgen::InsensitiveStr::Ascii("rsses"),
        dictgen::InsensitiveStr::Ascii("rssing"),
        dictgen::InsensitiveStr::Ascii("rssion"),
        dictgen::InsensitiveStr::Ascii("rssive"),
        dictgen::InsensitiveStr::Ascii("sion"),
        dictgen::InsensitiveStr::Ascii("sive"),
        dictgen::InsensitiveStr::Ascii("sively"),
        dictgen::InsensitiveStr::Ascii("srion"),
        dictgen::InsensitiveStr::Ascii("srive"),
        dictgen::InsensitiveStr::Ascii("srively"),
        dictgen::InsensitiveStr::Ascii("srsive"),
        dictgen::InsensitiveStr::Ascii("stion"),
    ],
    values: &[
        &["reduce"],
        &["recruiting"],
        &["recursively"],
        &["reckon", "recon", "recur"],
        &["fecund", "reckoned"],
        &["reckoning", "recusing", "retuning"],
        &["recurring"],
        &["recursion"],
        &["recursions"],
        &["recursion"],
        &["recursively"],
        &["recruited"],
        &["recruiter"],
        &["recruiters"],
        &["recruitment"],
        &["recruits"],
        &["recursively"],
        &["recurrence"],
        &["recursively"],
        &["recursively"],
        &["recursion"],
        &["recursively"],
        &["recursively"],
        &["recurse", "recurses"],
        &["recursed"],
        &["recurses"],
        &["recursing"],
        &["recursion"],
        &["recursive"],
        &["recursion", "reclusion"],
        &["recursive", "reclusive"],
        &["recursively", "reclusively"],
        &["recursion"],
        &["recursive"],
        &["recursively"],
        &["recursive"],
        &["recursion"],
    ],
    range: 1..=8,
};

static WORD_RECT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RECT_CHILDREN),
    value: None,
};

pub static WORD_RECT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ange"),
        dictgen::InsensitiveStr::Ascii("angel"),
        dictgen::InsensitiveStr::Ascii("anges"),
        dictgen::InsensitiveStr::Ascii("anglar"),
        dictgen::InsensitiveStr::Ascii("angluar"),
        dictgen::InsensitiveStr::Ascii("angual"),
        dictgen::InsensitiveStr::Ascii("angualr"),
        dictgen::InsensitiveStr::Ascii("anguar"),
        dictgen::InsensitiveStr::Ascii("angulaire"),
        dictgen::InsensitiveStr::Ascii("anlge"),
        dictgen::InsensitiveStr::Ascii("engular"),
        dictgen::InsensitiveStr::Ascii("ifiy"),
        dictgen::InsensitiveStr::Ascii("iinear"),
    ],
    values: &[
        &["rectangle"],
        &["rectangle"],
        &["rectangles"],
        &["rectangular"],
        &["rectangular"],
        &["rectangular", "rectangle"],
        &["rectangular"],
        &["rectangular"],
        &["rectangular"],
        &["rectangle"],
        &["rectangular"],
        &["rectify"],
        &["rectilinear"],
    ],
    range: 4..=9,
};

static WORD_RECR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RECR_CHILDREN),
    value: None,
};

pub static WORD_RECR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ational"),
        dictgen::InsensitiveStr::Ascii("eacion"),
        dictgen::InsensitiveStr::Ascii("eacional"),
        dictgen::InsensitiveStr::Ascii("eateation"),
        dictgen::InsensitiveStr::Ascii("eatie"),
        dictgen::InsensitiveStr::Ascii("eatief"),
        dictgen::InsensitiveStr::Ascii("eationnal"),
        dictgen::InsensitiveStr::Ascii("eativo"),
        dictgen::InsensitiveStr::Ascii("ete"),
        dictgen::InsensitiveStr::Ascii("eted"),
        dictgen::InsensitiveStr::Ascii("etes"),
        dictgen::InsensitiveStr::Ascii("eting"),
        dictgen::InsensitiveStr::Ascii("etion"),
        dictgen::InsensitiveStr::Ascii("etional"),
        dictgen::InsensitiveStr::Ascii("iational"),
        dictgen::InsensitiveStr::Ascii("od"),
        dictgen::InsensitiveStr::Ascii("ods"),
        dictgen::InsensitiveStr::Ascii("oot"),
        dictgen::InsensitiveStr::Ascii("ooted"),
        dictgen::InsensitiveStr::Ascii("ooter"),
        dictgen::InsensitiveStr::Ascii("ooters"),
        dictgen::InsensitiveStr::Ascii("ooting"),
        dictgen::InsensitiveStr::Ascii("oots"),
        dictgen::InsensitiveStr::Ascii("uitcs"),
        dictgen::InsensitiveStr::Ascii("uites"),
        dictgen::InsensitiveStr::Ascii("usevly"),
        dictgen::InsensitiveStr::Ascii("usion"),
        dictgen::InsensitiveStr::Ascii("usive"),
        dictgen::InsensitiveStr::Ascii("usivelly"),
        dictgen::InsensitiveStr::Ascii("usively"),
        dictgen::InsensitiveStr::Ascii("utied"),
        dictgen::InsensitiveStr::Ascii("utier"),
        dictgen::InsensitiveStr::Ascii("utiers"),
        dictgen::InsensitiveStr::Ascii("utiment"),
    ],
    values: &[
        &["recreational"],
        &["recreation"],
        &["recreational"],
        &["recreation"],
        &["recreate"],
        &["recreate"],
        &["recreational"],
        &["recreation"],
        &["recreate"],
        &["recreated"],
        &["recreates"],
        &["recreating"],
        &["recreation"],
        &["recreational"],
        &["recreational"],
        &["record"],
        &["records"],
        &["recruit"],
        &["recruited"],
        &["recruiter"],
        &["recruiters"],
        &["recruiting"],
        &["recruits"],
        &["recruits"],
        &["recruits"],
        &["recursively"],
        &["recursion"],
        &["recursive"],
        &["recursively"],
        &["recursively"],
        &["recruited"],
        &["recruiter"],
        &["recruiters"],
        &["recruitment"],
    ],
    range: 2..=9,
};

static WORD_RECQ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RECQ_CHILDREN),
    value: None,
};

pub static WORD_RECQ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("uired")],
    values: &[&["required"]],
    range: 5..=5,
};

static WORD_RECP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RECP_CHILDREN),
    value: None,
};

pub static WORD_RECP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("etionist"),
        dictgen::InsensitiveStr::Ascii("etive"),
        dictgen::InsensitiveStr::Ascii("etors"),
        dictgen::InsensitiveStr::Ascii("ie"),
        dictgen::InsensitiveStr::Ascii("ies"),
    ],
    values: &[
        &["receptionist"],
        &["receptive"],
        &["receptors"],
        &["recipe"],
        &["recipes"],
    ],
    range: 2..=8,
};

static WORD_RECO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_RECO_CHILDREN),
    value: None,
};

static WORD_RECO_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    Some(&WORD_RECOC_NODE),
    Some(&WORD_RECOD_NODE),
    None,
    Some(&WORD_RECOF_NODE),
    Some(&WORD_RECOG_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_RECOL_NODE),
    Some(&WORD_RECOM_NODE),
    Some(&WORD_RECON_NODE),
    None,
    None,
    None,
    Some(&WORD_RECOR_NODE),
    None,
    None,
    Some(&WORD_RECOU_NODE),
    Some(&WORD_RECOV_NODE),
    None,
    None,
    None,
    None,
];

static WORD_RECOV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RECOV_CHILDREN),
    value: None,
};

pub static WORD_RECOV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ation"),
        dictgen::InsensitiveStr::Ascii("eres"),
        dictgen::InsensitiveStr::Ascii("erys"),
        dictgen::InsensitiveStr::Ascii("es"),
    ],
    values: &[&["revocation"], &["recovers"], &["recovers"], &["recovers"]],
    range: 2..=5,
};

static WORD_RECOU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RECOU_CHILDREN),
    value: None,
};

pub static WORD_RECOU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("rce"),
        dictgen::InsensitiveStr::Ascii("rced"),
        dictgen::InsensitiveStr::Ascii("rces"),
        dictgen::InsensitiveStr::Ascii("rcing"),
    ],
    values: &[
        &["resource", "recourse"],
        &["resourced"],
        &["resources"],
        &["resourcing"],
    ],
    range: 3..=5,
};

static WORD_RECOR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RECOR_CHILDREN),
    value: None,
};

pub static WORD_RECOR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("dare"),
        dictgen::InsensitiveStr::Ascii("darle"),
        dictgen::InsensitiveStr::Ascii("darme"),
        dictgen::InsensitiveStr::Ascii("darse"),
        dictgen::InsensitiveStr::Ascii("darte"),
        dictgen::InsensitiveStr::Ascii("dss"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("iding"),
        dictgen::InsensitiveStr::Ascii("re"),
    ],
    values: &[
        &["recorder"],
        &["recorder"],
        &["recorder"],
        &["recorder"],
        &["recorder"],
        &["records"],
        &["recorded"],
        &["recording"],
        &["recorder"],
    ],
    range: 2..=5,
};

static WORD_RECON_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_RECON_CHILDREN),
    value: None,
};

static WORD_RECON_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_RECONA_NODE),
    None,
    Some(&WORD_RECONC_NODE),
    Some(&WORD_RECOND_NODE),
    Some(&WORD_RECONE_NODE),
    Some(&WORD_RECONF_NODE),
    Some(&WORD_RECONG_NODE),
    None,
    Some(&WORD_RECONI_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_RECONN_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_RECONS_NODE),
    Some(&WORD_RECONT_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_RECONT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RECONT_CHILDREN),
    value: None,
};

pub static WORD_RECONT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ruct"),
        dictgen::InsensitiveStr::Ascii("ructed"),
        dictgen::InsensitiveStr::Ascii("ructing"),
        dictgen::InsensitiveStr::Ascii("ruction"),
        dictgen::InsensitiveStr::Ascii("ructions"),
        dictgen::InsensitiveStr::Ascii("ructor"),
        dictgen::InsensitiveStr::Ascii("ructors"),
        dictgen::InsensitiveStr::Ascii("ructs"),
    ],
    values: &[
        &["reconstruct"],
        &["reconstructed"],
        &["reconstructing"],
        &["reconstruction"],
        &["reconstructions"],
        &["reconstructor"],
        &["reconstructors"],
        &["reconstructs"],
    ],
    range: 4..=8,
};

static WORD_RECONS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RECONS_CHILDREN),
    value: None,
};

pub static WORD_RECONS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("idder"),
        dictgen::InsensitiveStr::Ascii("iled"),
        dictgen::InsensitiveStr::Ascii("trcut"),
        dictgen::InsensitiveStr::Ascii("trcuted"),
        dictgen::InsensitiveStr::Ascii("trcution"),
        dictgen::InsensitiveStr::Ascii("truccion"),
        dictgen::InsensitiveStr::Ascii("trucion"),
        dictgen::InsensitiveStr::Ascii("tuct"),
        dictgen::InsensitiveStr::Ascii("tucted"),
        dictgen::InsensitiveStr::Ascii("tucting"),
        dictgen::InsensitiveStr::Ascii("tucts"),
        dictgen::InsensitiveStr::Ascii("turction"),
    ],
    values: &[
        &["reconsider"],
        &["reconsider"],
        &["reconstruct"],
        &["reconstructed"],
        &["reconstruction"],
        &["reconstruction"],
        &["reconstruction"],
        &["reconstruct"],
        &["reconstructed"],
        &["reconstructing"],
        &["reconstructs"],
        &["reconstruction"],
    ],
    range: 4..=8,
};

static WORD_RECONN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RECONN_CHILDREN),
    value: None,
};

pub static WORD_RECONN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aisance"),
        dictgen::InsensitiveStr::Ascii("aissence"),
        dictgen::InsensitiveStr::Ascii("ct"),
        dictgen::InsensitiveStr::Ascii("cted"),
        dictgen::InsensitiveStr::Ascii("cting"),
        dictgen::InsensitiveStr::Ascii("cts"),
        dictgen::InsensitiveStr::Ascii("et"),
    ],
    values: &[
        &["reconnaissance"],
        &["reconnaissance"],
        &["reconnect"],
        &["reconnected"],
        &["reconnecting"],
        &["reconnects"],
        &["reconnect"],
    ],
    range: 2..=8,
};

static WORD_RECONI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RECONI_CHILDREN),
    value: None,
};

pub static WORD_RECONI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cle"),
        dictgen::InsensitiveStr::Ascii("sder"),
        dictgen::InsensitiveStr::Ascii("ze"),
        dictgen::InsensitiveStr::Ascii("zed"),
    ],
    values: &[
        &["reconcile"],
        &["reconsider"],
        &["recognize"],
        &["recognized"],
    ],
    range: 2..=4,
};

static WORD_RECONG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RECONG_CHILDREN),
    value: None,
};

pub static WORD_RECONG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ifure"),
        dictgen::InsensitiveStr::Ascii("ise"),
        dictgen::InsensitiveStr::Ascii("ised"),
        dictgen::InsensitiveStr::Ascii("ition"),
        dictgen::InsensitiveStr::Ascii("izable"),
        dictgen::InsensitiveStr::Ascii("ize"),
        dictgen::InsensitiveStr::Ascii("ized"),
        dictgen::InsensitiveStr::Ascii("izes"),
        dictgen::InsensitiveStr::Ascii("izing"),
        dictgen::InsensitiveStr::Ascii("nises"),
        dictgen::InsensitiveStr::Ascii("nizes"),
    ],
    values: &[
        &["reconfigure"],
        &["recognise"],
        &["recognised"],
        &["recognition"],
        &["recognizable"],
        &["recognize"],
        &["recognized"],
        &["recognizes"],
        &["recognizing"],
        &["recognises"],
        &["recognizes"],
    ],
    range: 3..=6,
};

static WORD_RECONF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RECONF_CHILDREN),
    value: None,
};

pub static WORD_RECONF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ifure"),
        dictgen::InsensitiveStr::Ascii("iged"),
        dictgen::InsensitiveStr::Ascii("ugire"),
        dictgen::InsensitiveStr::Ascii("ugre"),
        dictgen::InsensitiveStr::Ascii("ugure"),
        dictgen::InsensitiveStr::Ascii("ure"),
    ],
    values: &[
        &["reconfigure"],
        &["reconfigured"],
        &["reconfigure"],
        &["reconfigure"],
        &["reconfigure"],
        &["reconfigure"],
    ],
    range: 3..=5,
};

static WORD_RECONE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RECONE_CHILDREN),
    value: None,
};

pub static WORD_RECONE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cct"),
        dictgen::InsensitiveStr::Ascii("ccted"),
        dictgen::InsensitiveStr::Ascii("ccting"),
        dictgen::InsensitiveStr::Ascii("cction"),
        dictgen::InsensitiveStr::Ascii("cctions"),
        dictgen::InsensitiveStr::Ascii("ccts"),
        dictgen::InsensitiveStr::Ascii("ct"),
        dictgen::InsensitiveStr::Ascii("cted"),
        dictgen::InsensitiveStr::Ascii("cting"),
        dictgen::InsensitiveStr::Ascii("ction"),
        dictgen::InsensitiveStr::Ascii("ctions"),
        dictgen::InsensitiveStr::Ascii("cts"),
        dictgen::InsensitiveStr::Ascii("ect"),
        dictgen::InsensitiveStr::Ascii("ected"),
        dictgen::InsensitiveStr::Ascii("ecting"),
        dictgen::InsensitiveStr::Ascii("ection"),
        dictgen::InsensitiveStr::Ascii("ections"),
        dictgen::InsensitiveStr::Ascii("ects"),
        dictgen::InsensitiveStr::Ascii("nct"),
        dictgen::InsensitiveStr::Ascii("ncted"),
        dictgen::InsensitiveStr::Ascii("ncting"),
        dictgen::InsensitiveStr::Ascii("nction"),
        dictgen::InsensitiveStr::Ascii("nctions"),
        dictgen::InsensitiveStr::Ascii("ncts"),
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("ted"),
        dictgen::InsensitiveStr::Ascii("ting"),
        dictgen::InsensitiveStr::Ascii("tion"),
        dictgen::InsensitiveStr::Ascii("tions"),
        dictgen::InsensitiveStr::Ascii("ts"),
    ],
    values: &[
        &["reconnect"],
        &["reconnected"],
        &["reconnecting"],
        &["reconnection"],
        &["reconnections"],
        &["reconnects"],
        &["reconnect"],
        &["reconnected"],
        &["reconnecting"],
        &["reconnection"],
        &["reconnections"],
        &["reconnects"],
        &["reconnect"],
        &["reconnected"],
        &["reconnecting"],
        &["reconnection"],
        &["reconnections"],
        &["reconnects"],
        &["reconnect"],
        &["reconnected"],
        &["reconnecting"],
        &["reconnection"],
        &["reconnections"],
        &["reconnects"],
        &["reconnect"],
        &["reconnected"],
        &["reconnecting"],
        &["reconnection"],
        &["reconnections"],
        &["reconnects"],
    ],
    range: 1..=7,
};

static WORD_RECOND_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RECOND_CHILDREN),
    value: None,
};

pub static WORD_RECOND_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ifure")],
    values: &[&["reconfigure"]],
    range: 5..=5,
};

static WORD_RECONC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RECONC_CHILDREN),
    value: None,
};

pub static WORD_RECONC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ider"),
        dictgen::InsensitiveStr::Ascii("ilation"),
        dictgen::InsensitiveStr::Ascii("ille"),
        dictgen::InsensitiveStr::Ascii("illed"),
    ],
    values: &[
        &["reconsider"],
        &["reconciliation"],
        &["reconcile"],
        &["reconcile"],
    ],
    range: 4..=7,
};

static WORD_RECONA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RECONA_CHILDREN),
    value: None,
};

pub static WORD_RECONA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("issance"),
        dictgen::InsensitiveStr::Ascii("sence"),
    ],
    values: &[&["reconnaissance"], &["reconnaissance"]],
    range: 5..=7,
};

static WORD_RECOM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RECOM_CHILDREN),
    value: None,
};

pub static WORD_RECOM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("end"),
        dictgen::InsensitiveStr::Ascii("endation"),
        dictgen::InsensitiveStr::Ascii("endations"),
        dictgen::InsensitiveStr::Ascii("endatoin"),
        dictgen::InsensitiveStr::Ascii("endatoins"),
        dictgen::InsensitiveStr::Ascii("ended"),
        dictgen::InsensitiveStr::Ascii("ending"),
        dictgen::InsensitiveStr::Ascii("ends"),
        dictgen::InsensitiveStr::Ascii("mad"),
        dictgen::InsensitiveStr::Ascii("maded"),
        dictgen::InsensitiveStr::Ascii("mand"),
        dictgen::InsensitiveStr::Ascii("mandation"),
        dictgen::InsensitiveStr::Ascii("mandations"),
        dictgen::InsensitiveStr::Ascii("mande"),
        dictgen::InsensitiveStr::Ascii("manded"),
        dictgen::InsensitiveStr::Ascii("mandes"),
        dictgen::InsensitiveStr::Ascii("manding"),
        dictgen::InsensitiveStr::Ascii("mands"),
        dictgen::InsensitiveStr::Ascii("md"),
        dictgen::InsensitiveStr::Ascii("mdation"),
        dictgen::InsensitiveStr::Ascii("mded"),
        dictgen::InsensitiveStr::Ascii("mdend"),
        dictgen::InsensitiveStr::Ascii("mdended"),
        dictgen::InsensitiveStr::Ascii("mdends"),
        dictgen::InsensitiveStr::Ascii("mds"),
        dictgen::InsensitiveStr::Ascii("med"),
        dictgen::InsensitiveStr::Ascii("medation"),
        dictgen::InsensitiveStr::Ascii("medations"),
        dictgen::InsensitiveStr::Ascii("meded"),
        dictgen::InsensitiveStr::Ascii("meding"),
        dictgen::InsensitiveStr::Ascii("meds"),
        dictgen::InsensitiveStr::Ascii("mendeds"),
        dictgen::InsensitiveStr::Ascii("mendes"),
        dictgen::InsensitiveStr::Ascii("mendors"),
        dictgen::InsensitiveStr::Ascii("mened"),
        dictgen::InsensitiveStr::Ascii("meneded"),
        dictgen::InsensitiveStr::Ascii("mennd"),
        dictgen::InsensitiveStr::Ascii("mens"),
        dictgen::InsensitiveStr::Ascii("ment"),
        dictgen::InsensitiveStr::Ascii("mented"),
        dictgen::InsensitiveStr::Ascii("menting"),
        dictgen::InsensitiveStr::Ascii("ments"),
        dictgen::InsensitiveStr::Ascii("mmend"),
        dictgen::InsensitiveStr::Ascii("mmended"),
        dictgen::InsensitiveStr::Ascii("mmends"),
        dictgen::InsensitiveStr::Ascii("mnd"),
        dictgen::InsensitiveStr::Ascii("mnded"),
        dictgen::InsensitiveStr::Ascii("mnds"),
        dictgen::InsensitiveStr::Ascii("mned"),
        dictgen::InsensitiveStr::Ascii("mneded"),
        dictgen::InsensitiveStr::Ascii("mneds"),
        dictgen::InsensitiveStr::Ascii("mondation"),
        dictgen::InsensitiveStr::Ascii("mondations"),
        dictgen::InsensitiveStr::Ascii("mpile"),
        dictgen::InsensitiveStr::Ascii("mpiled"),
        dictgen::InsensitiveStr::Ascii("pence"),
        dictgen::InsensitiveStr::Ascii("plie"),
        dictgen::InsensitiveStr::Ascii("put"),
        dictgen::InsensitiveStr::Ascii("putaion"),
        dictgen::InsensitiveStr::Ascii("puute"),
        dictgen::InsensitiveStr::Ascii("puuted"),
        dictgen::InsensitiveStr::Ascii("puutes"),
        dictgen::InsensitiveStr::Ascii("puuting"),
    ],
    values: &[
        &["recommend"],
        &["recommendation"],
        &["recommendations"],
        &["recommendation"],
        &["recommendations"],
        &["recommended"],
        &["recommending"],
        &["recommends"],
        &["recommend"],
        &["recommended"],
        &["recommend"],
        &["recommendation"],
        &["recommendations"],
        &["recommend"],
        &["recommended"],
        &["recommends"],
        &["recommending"],
        &["recommends"],
        &["recommend"],
        &["recommendation"],
        &["recommended"],
        &["recommend"],
        &["recommended"],
        &["recommends"],
        &["recommends"],
        &["recommend"],
        &["recommendation"],
        &["recommendations"],
        &["recommended"],
        &["recommending"],
        &["recommends"],
        &["recommends"],
        &["recommends"],
        &["recommends"],
        &["recommend", "recommended"],
        &["recommended"],
        &["recommends"],
        &["recommends"],
        &["recommend"],
        &["recommended"],
        &["recommending"],
        &["recommends"],
        &["recommend"],
        &["recommended"],
        &["recommends"],
        &["recommend"],
        &["recommended"],
        &["recommends"],
        &["recommend"],
        &["recommended"],
        &["recommends"],
        &["recommendation"],
        &["recommendations"],
        &["recompile"],
        &["recompiled"],
        &["recompense"],
        &["recompile", "recomply"],
        &["recompute"],
        &["recomputation"],
        &["recompute"],
        &["recomputed"],
        &["recomputes"],
        &["recomputing"],
    ],
    range: 2..=10,
};

static WORD_RECOL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RECOL_CHILDREN),
    value: None,
};

pub static WORD_RECOL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("leciton")],
    values: &[&["recollection"]],
    range: 7..=7,
};

static WORD_RECOG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RECOG_CHILDREN),
    value: None,
};

pub static WORD_RECOG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("inizer"),
        dictgen::InsensitiveStr::Ascii("inse"),
        dictgen::InsensitiveStr::Ascii("insed"),
        dictgen::InsensitiveStr::Ascii("inze"),
        dictgen::InsensitiveStr::Ascii("inzed"),
        dictgen::InsensitiveStr::Ascii("ise"),
        dictgen::InsensitiveStr::Ascii("ize"),
        dictgen::InsensitiveStr::Ascii("ized"),
        dictgen::InsensitiveStr::Ascii("izes"),
        dictgen::InsensitiveStr::Ascii("izing"),
        dictgen::InsensitiveStr::Ascii("niced"),
        dictgen::InsensitiveStr::Ascii("nices"),
        dictgen::InsensitiveStr::Ascii("nicing"),
        dictgen::InsensitiveStr::Ascii("nie"),
        dictgen::InsensitiveStr::Ascii("ninse"),
        dictgen::InsensitiveStr::Ascii("nision"),
        dictgen::InsensitiveStr::Ascii("niton"),
        dictgen::InsensitiveStr::Ascii("nizeable"),
        dictgen::InsensitiveStr::Ascii("nizible"),
        dictgen::InsensitiveStr::Ascii("nzied"),
    ],
    values: &[
        &["recognizer"],
        &["recognise"],
        &["recognised"],
        &["recognize"],
        &["recognized"],
        &["recognise"],
        &["recognize"],
        &["recognized"],
        &["recognizes"],
        &["recognizing"],
        &["recognised"],
        &["recognizes"],
        &["recognizing"],
        &["recognizes"],
        &["recognise"],
        &["recognition"],
        &["recognition"],
        &["recognizable"],
        &["recognizable"],
        &["recognised", "recognized"],
    ],
    range: 3..=8,
};

static WORD_RECOF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RECOF_CHILDREN),
    value: None,
};

pub static WORD_RECOF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ig")],
    values: &[&["reconfig"]],
    range: 2..=2,
};

static WORD_RECOD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RECOD_CHILDREN),
    value: Some(&["record"]),
};

pub static WORD_RECOD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[],
    values: &[],
    range: 0..=0,
};

static WORD_RECOC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RECOC_CHILDREN),
    value: None,
};

pub static WORD_RECOC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ation"),
        dictgen::InsensitiveStr::Ascii("nisable"),
        dictgen::InsensitiveStr::Ascii("nised"),
    ],
    values: &[
        &["revocation"],
        &["recognisable", "reconcilable"],
        &["recognised"],
    ],
    range: 5..=7,
};

static WORD_RECN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RECN_CHILDREN),
    value: None,
};

pub static WORD_RECN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("tly"),
    ],
    values: &[&["recent", "recant", "rent"], &["recently"]],
    range: 1..=3,
};

static WORD_RECL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RECL_CHILDREN),
    value: None,
};

pub static WORD_RECL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aimation"),
        dictgen::InsensitiveStr::Ascii("ami"),
        dictgen::InsensitiveStr::Ascii("iam"),
        dictgen::InsensitiveStr::Ascii("utant"),
        dictgen::InsensitiveStr::Ascii("utantly"),
    ],
    values: &[
        &["reclamation"],
        &["reclaim"],
        &["reclaim"],
        &["reluctant"],
        &["reluctantly"],
    ],
    range: 3..=8,
};

static WORD_RECJ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RECJ_CHILDREN),
    value: None,
};

pub static WORD_RECJ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ect"),
        dictgen::InsensitiveStr::Ascii("ected"),
        dictgen::InsensitiveStr::Ascii("ecting"),
        dictgen::InsensitiveStr::Ascii("ects"),
    ],
    values: &[&["reject"], &["rejected"], &["rejecting"], &["rejects"]],
    range: 3..=6,
};

static WORD_RECI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RECI_CHILDREN),
    value: None,
};

pub static WORD_RECI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("de"),
        dictgen::InsensitiveStr::Ascii("ded"),
        dictgen::InsensitiveStr::Ascii("dent"),
        dictgen::InsensitiveStr::Ascii("dents"),
        dictgen::InsensitiveStr::Ascii("ding"),
        dictgen::InsensitiveStr::Ascii("epents"),
        dictgen::InsensitiveStr::Ascii("ept"),
        dictgen::InsensitiveStr::Ascii("evd"),
        dictgen::InsensitiveStr::Ascii("eve"),
        dictgen::InsensitiveStr::Ascii("eved"),
        dictgen::InsensitiveStr::Ascii("ever"),
        dictgen::InsensitiveStr::Ascii("evers"),
        dictgen::InsensitiveStr::Ascii("eves"),
        dictgen::InsensitiveStr::Ascii("eving"),
        dictgen::InsensitiveStr::Ascii("evs"),
        dictgen::InsensitiveStr::Ascii("pees"),
        dictgen::InsensitiveStr::Ascii("peints"),
        dictgen::InsensitiveStr::Ascii("pent"),
        dictgen::InsensitiveStr::Ascii("pents"),
        dictgen::InsensitiveStr::Ascii("pets"),
        dictgen::InsensitiveStr::Ascii("piant"),
        dictgen::InsensitiveStr::Ascii("piants"),
        dictgen::InsensitiveStr::Ascii("pie"),
        dictgen::InsensitiveStr::Ascii("pientes"),
        dictgen::InsensitiveStr::Ascii("pies"),
        dictgen::InsensitiveStr::Ascii("porcate"),
        dictgen::InsensitiveStr::Ascii("porcated"),
        dictgen::InsensitiveStr::Ascii("pricate"),
        dictgen::InsensitiveStr::Ascii("procant"),
        dictgen::InsensitiveStr::Ascii("proce"),
        dictgen::InsensitiveStr::Ascii("prociate"),
        dictgen::InsensitiveStr::Ascii("procite"),
        dictgen::InsensitiveStr::Ascii("procoal"),
        dictgen::InsensitiveStr::Ascii("procoals"),
        dictgen::InsensitiveStr::Ascii("procrate"),
        dictgen::InsensitiveStr::Ascii("tfy"),
        dictgen::InsensitiveStr::Ascii("ve"),
        dictgen::InsensitiveStr::Ascii("ved"),
        dictgen::InsensitiveStr::Ascii("ver"),
        dictgen::InsensitiveStr::Ascii("vers"),
        dictgen::InsensitiveStr::Ascii("vership"),
        dictgen::InsensitiveStr::Ascii("ves"),
        dictgen::InsensitiveStr::Ascii("ving"),
    ],
    values: &[
        &["reside"],
        &["resided"],
        &["resident"],
        &["residents"],
        &["residing"],
        &["recipients"],
        &["receipt"],
        &["received"],
        &["receive"],
        &["received"],
        &["receiver"],
        &["receivers"],
        &["receives"],
        &["receiving"],
        &["receives"],
        &["recipes"],
        &["recipients"],
        &["recipient"],
        &["recipients"],
        &["recipes"],
        &["recipient"],
        &["recipients"],
        &["recipe"],
        &["recipients"],
        &["recipes"],
        &["reciprocate"],
        &["reciprocate"],
        &["reciprocate"],
        &["reciprocate"],
        &["reciprocate"],
        &["reciprocate"],
        &["reciprocate"],
        &["reciprocal"],
        &["reciprocals"],
        &["reciprocate"],
        &["rectify"],
        &["receive"],
        &["received"],
        &["receiver"],
        &["receivers"],
        &["receivership"],
        &["receives"],
        &["receiving"],
    ],
    range: 2..=8,
};

static WORD_RECH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RECH_CHILDREN),
    value: None,
};

pub static WORD_RECH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("able"),
        dictgen::InsensitiveStr::Ascii("argable"),
        dictgen::InsensitiveStr::Ascii("eability"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("ek"),
    ],
    values: &[
        &["reachable"],
        &["rechargeable"],
        &["reachability"],
        &["reached"],
        &["recheck"],
    ],
    range: 2..=8,
};

static WORD_RECG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RECG_CHILDREN),
    value: None,
};

pub static WORD_RECG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("onise"),
        dictgen::InsensitiveStr::Ascii("onised"),
        dictgen::InsensitiveStr::Ascii("onition"),
        dictgen::InsensitiveStr::Ascii("onizable"),
        dictgen::InsensitiveStr::Ascii("onize"),
        dictgen::InsensitiveStr::Ascii("onized"),
        dictgen::InsensitiveStr::Ascii("onizes"),
        dictgen::InsensitiveStr::Ascii("onizing"),
    ],
    values: &[
        &["recognise"],
        &["recognised"],
        &["recognition"],
        &["recognizable"],
        &["recognize"],
        &["recognized"],
        &["recognizes"],
        &["recognizing"],
    ],
    range: 5..=8,
};

static WORD_RECE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RECE_CHILDREN),
    value: None,
};

pub static WORD_RECE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eded"),
        dictgen::InsensitiveStr::Ascii("eding"),
        dictgen::InsensitiveStr::Ascii("et"),
        dictgen::InsensitiveStr::Ascii("ets"),
        dictgen::InsensitiveStr::Ascii("ied"),
        dictgen::InsensitiveStr::Ascii("ieve"),
        dictgen::InsensitiveStr::Ascii("ieved"),
        dictgen::InsensitiveStr::Ascii("ieves"),
        dictgen::InsensitiveStr::Ascii("ieving"),
        dictgen::InsensitiveStr::Ascii("ipient"),
        dictgen::InsensitiveStr::Ascii("ipients"),
        dictgen::InsensitiveStr::Ascii("ips"),
        dictgen::InsensitiveStr::Ascii("iption"),
        dictgen::InsensitiveStr::Ascii("iv"),
        dictgen::InsensitiveStr::Ascii("ivd"),
        dictgen::InsensitiveStr::Ascii("iveing"),
        dictgen::InsensitiveStr::Ascii("iviing"),
        dictgen::InsensitiveStr::Ascii("ivs"),
        dictgen::InsensitiveStr::Ascii("nd"),
        dictgen::InsensitiveStr::Ascii("ndable"),
        dictgen::InsensitiveStr::Ascii("nded"),
        dictgen::InsensitiveStr::Ascii("ndes"),
        dictgen::InsensitiveStr::Ascii("nding"),
        dictgen::InsensitiveStr::Ascii("nds"),
        dictgen::InsensitiveStr::Ascii("net"),
        dictgen::InsensitiveStr::Ascii("nlty"),
        dictgen::InsensitiveStr::Ascii("nly"),
        dictgen::InsensitiveStr::Ascii("nty"),
        dictgen::InsensitiveStr::Ascii("pcionist"),
        dictgen::InsensitiveStr::Ascii("pient"),
        dictgen::InsensitiveStr::Ascii("pients"),
        dictgen::InsensitiveStr::Ascii("pion"),
        dictgen::InsensitiveStr::Ascii("pit"),
        dictgen::InsensitiveStr::Ascii("pits"),
        dictgen::InsensitiveStr::Ascii("ptical"),
        dictgen::InsensitiveStr::Ascii("pticals"),
        dictgen::InsensitiveStr::Ascii("ptie"),
        dictgen::InsensitiveStr::Ascii("ptionest"),
        dictgen::InsensitiveStr::Ascii("ptionnist"),
        dictgen::InsensitiveStr::Ascii("ptionsist"),
        dictgen::InsensitiveStr::Ascii("ptionst"),
        dictgen::InsensitiveStr::Ascii("ptoras"),
        dictgen::InsensitiveStr::Ascii("ptores"),
        dictgen::InsensitiveStr::Ascii("ptos"),
        dictgen::InsensitiveStr::Ascii("ve"),
        dictgen::InsensitiveStr::Ascii("ved"),
        dictgen::InsensitiveStr::Ascii("ves"),
        dictgen::InsensitiveStr::Ascii("vie"),
        dictgen::InsensitiveStr::Ascii("vied"),
        dictgen::InsensitiveStr::Ascii("vier"),
        dictgen::InsensitiveStr::Ascii("vies"),
        dictgen::InsensitiveStr::Ascii("ving"),
    ],
    values: &[
        &["receded"],
        &["receding"],
        &["receipt"],
        &["receipts"],
        &["received"],
        &["receive"],
        &["received"],
        &["receives"],
        &["receiving"],
        &["recipient"],
        &["recipients"],
        &["receipts"],
        &["reception"],
        &["receive"],
        &["received"],
        &["receiving"],
        &["receiving"],
        &["receives"],
        &["rescind"],
        &["rescindable"],
        &["rescinded"],
        &["rescinds"],
        &["rescinding"],
        &["rescinds"],
        &["recent"],
        &["recently"],
        &["recently"],
        &["recently"],
        &["receptionist"],
        &["recipient"],
        &["recipients"],
        &["reception"],
        &["recipe", "receipt"],
        &["receipts"],
        &["receptacle"],
        &["receptacles"],
        &["receptive"],
        &["receptionist"],
        &["receptionist"],
        &["receptionist"],
        &["receptionist"],
        &["receptors"],
        &["receptors"],
        &["receptors"],
        &["receive"],
        &["received"],
        &["receives"],
        &["receive"],
        &["received"],
        &["receiver"],
        &["receives"],
        &["receiving"],
    ],
    range: 2..=9,
};

static WORD_RECC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RECC_CHILDREN),
    value: None,
};

pub static WORD_RECC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("omend"),
        dictgen::InsensitiveStr::Ascii("omendations"),
        dictgen::InsensitiveStr::Ascii("omended"),
        dictgen::InsensitiveStr::Ascii("omending"),
        dictgen::InsensitiveStr::Ascii("ommend"),
        dictgen::InsensitiveStr::Ascii("ommendation"),
        dictgen::InsensitiveStr::Ascii("ommendations"),
        dictgen::InsensitiveStr::Ascii("ommended"),
        dictgen::InsensitiveStr::Ascii("ommending"),
        dictgen::InsensitiveStr::Ascii("ommends"),
        dictgen::InsensitiveStr::Ascii("onecct"),
        dictgen::InsensitiveStr::Ascii("oneccted"),
        dictgen::InsensitiveStr::Ascii("oneccting"),
        dictgen::InsensitiveStr::Ascii("onecction"),
        dictgen::InsensitiveStr::Ascii("onecctions"),
        dictgen::InsensitiveStr::Ascii("oneccts"),
        dictgen::InsensitiveStr::Ascii("onect"),
        dictgen::InsensitiveStr::Ascii("onected"),
        dictgen::InsensitiveStr::Ascii("onecting"),
        dictgen::InsensitiveStr::Ascii("onection"),
        dictgen::InsensitiveStr::Ascii("onections"),
        dictgen::InsensitiveStr::Ascii("onects"),
        dictgen::InsensitiveStr::Ascii("oneect"),
        dictgen::InsensitiveStr::Ascii("oneected"),
        dictgen::InsensitiveStr::Ascii("oneecting"),
        dictgen::InsensitiveStr::Ascii("oneection"),
        dictgen::InsensitiveStr::Ascii("oneections"),
        dictgen::InsensitiveStr::Ascii("oneects"),
        dictgen::InsensitiveStr::Ascii("onenct"),
        dictgen::InsensitiveStr::Ascii("onencted"),
        dictgen::InsensitiveStr::Ascii("onencting"),
        dictgen::InsensitiveStr::Ascii("onenction"),
        dictgen::InsensitiveStr::Ascii("onenctions"),
        dictgen::InsensitiveStr::Ascii("onencts"),
        dictgen::InsensitiveStr::Ascii("onet"),
        dictgen::InsensitiveStr::Ascii("oneted"),
        dictgen::InsensitiveStr::Ascii("oneting"),
        dictgen::InsensitiveStr::Ascii("onetion"),
        dictgen::InsensitiveStr::Ascii("onetions"),
        dictgen::InsensitiveStr::Ascii("onets"),
        dictgen::InsensitiveStr::Ascii("ord"),
        dictgen::InsensitiveStr::Ascii("orded"),
        dictgen::InsensitiveStr::Ascii("ording"),
        dictgen::InsensitiveStr::Ascii("ords"),
        dictgen::InsensitiveStr::Ascii("uring"),
        dictgen::InsensitiveStr::Ascii("ursive"),
        dictgen::InsensitiveStr::Ascii("ursively"),
    ],
    values: &[
        &["recommend"],
        &["recommendations"],
        &["recommended"],
        &["recommending"],
        &["recommend"],
        &["recommendation"],
        &["recommendations"],
        &["recommended"],
        &["recommending"],
        &["recommends"],
        &["reconnect"],
        &["reconnected"],
        &["reconnecting"],
        &["reconnection"],
        &["reconnections"],
        &["reconnects"],
        &["reconnect"],
        &["reconnected"],
        &["reconnecting"],
        &["reconnection"],
        &["reconnections"],
        &["reconnects"],
        &["reconnect"],
        &["reconnected"],
        &["reconnecting"],
        &["reconnection"],
        &["reconnections"],
        &["reconnects"],
        &["reconnect"],
        &["reconnected"],
        &["reconnecting"],
        &["reconnection"],
        &["reconnections"],
        &["reconnects"],
        &["reconnect"],
        &["reconnected"],
        &["reconnecting"],
        &["reconnection"],
        &["reconnections"],
        &["reconnects"],
        &["record"],
        &["recorded"],
        &["recording"],
        &["records"],
        &["recurring"],
        &["recursive"],
        &["recursively"],
    ],
    range: 3..=12,
};

static WORD_RECA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RECA_CHILDREN),
    value: None,
};

pub static WORD_RECA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("hed"),
        dictgen::InsensitiveStr::Ascii("l"),
        dictgen::InsensitiveStr::Ascii("lcelated"),
        dictgen::InsensitiveStr::Ascii("lcualte"),
        dictgen::InsensitiveStr::Ascii("lcualted"),
        dictgen::InsensitiveStr::Ascii("lcualtes"),
        dictgen::InsensitiveStr::Ascii("lcualting"),
        dictgen::InsensitiveStr::Ascii("lcualtion"),
        dictgen::InsensitiveStr::Ascii("lcualtions"),
        dictgen::InsensitiveStr::Ascii("lcuate"),
        dictgen::InsensitiveStr::Ascii("lcuated"),
        dictgen::InsensitiveStr::Ascii("lcuates"),
        dictgen::InsensitiveStr::Ascii("lcuations"),
        dictgen::InsensitiveStr::Ascii("lculaion"),
        dictgen::InsensitiveStr::Ascii("lcution"),
        dictgen::InsensitiveStr::Ascii("lim"),
        dictgen::InsensitiveStr::Ascii("llection"),
        dictgen::InsensitiveStr::Ascii("lulate"),
        dictgen::InsensitiveStr::Ascii("lulation"),
        dictgen::InsensitiveStr::Ascii("ngle"),
        dictgen::InsensitiveStr::Ascii("ngles"),
        dictgen::InsensitiveStr::Ascii("tions"),
    ],
    values: &[
        &["reached"],
        &["recall"],
        &["recalculated"],
        &["recalculate"],
        &["recalculated"],
        &["recalculates"],
        &["recalculating"],
        &["recalculation"],
        &["recalculations"],
        &["recalculate"],
        &["recalculated"],
        &["recalculates"],
        &["recalculations"],
        &["recalculation"],
        &["recalculation"],
        &["reclaim"],
        &["recollection"],
        &["recalculate"],
        &["recalculation"],
        &["rectangle"],
        &["rectangles"],
        &["creations"],
    ],
    range: 1..=10,
};

static WORD_REB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REB_CHILDREN),
    value: None,
};

pub static WORD_REB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ellios"),
        dictgen::InsensitiveStr::Ascii("ellis"),
        dictgen::InsensitiveStr::Ascii("iulding"),
        dictgen::InsensitiveStr::Ascii("llions"),
        dictgen::InsensitiveStr::Ascii("oto"),
        dictgen::InsensitiveStr::Ascii("oudning"),
        dictgen::InsensitiveStr::Ascii("oudns"),
        dictgen::InsensitiveStr::Ascii("ounce"),
        dictgen::InsensitiveStr::Ascii("ouncing"),
        dictgen::InsensitiveStr::Ascii("ouns"),
        dictgen::InsensitiveStr::Ascii("uidling"),
        dictgen::InsensitiveStr::Ascii("uil"),
        dictgen::InsensitiveStr::Ascii("uilded"),
        dictgen::InsensitiveStr::Ascii("uildling"),
        dictgen::InsensitiveStr::Ascii("uildt"),
        dictgen::InsensitiveStr::Ascii("uillt"),
        dictgen::InsensitiveStr::Ascii("uils"),
        dictgen::InsensitiveStr::Ascii("uilts"),
        dictgen::InsensitiveStr::Ascii("uit"),
        dictgen::InsensitiveStr::Ascii("uld"),
        dictgen::InsensitiveStr::Ascii("ulding"),
        dictgen::InsensitiveStr::Ascii("ulds"),
        dictgen::InsensitiveStr::Ascii("ulid"),
        dictgen::InsensitiveStr::Ascii("uliding"),
        dictgen::InsensitiveStr::Ascii("ulids"),
        dictgen::InsensitiveStr::Ascii("ulit"),
        dictgen::InsensitiveStr::Ascii("uplic"),
        dictgen::InsensitiveStr::Ascii("uplican"),
        dictgen::InsensitiveStr::Ascii("uplicans"),
    ],
    values: &[
        &["rebellious"],
        &["rebellious"],
        &["rebuilding"],
        &["rebellions"],
        &["reboot"],
        &["rebounding"],
        &["rebounds"],
        &["rebound"],
        &["rebounding"],
        &["rebounds"],
        &["rebuilding"],
        &["rebuild", "rebuilt"],
        &["rebuilt"],
        &["rebuilding"],
        &["rebuilt"],
        &["rebuilt"],
        &["rebuilds"],
        &["rebuilds", "rebuilt", "rebuild"],
        &["rebuilt"],
        &["rebuild"],
        &["rebuilding"],
        &["rebuilds"],
        &["rebuild"],
        &["rebuilding"],
        &["rebuilds"],
        &["rebuilt"],
        &["republic"],
        &["republican"],
        &["republicans"],
    ],
    range: 3..=8,
};

static WORD_REA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_REA_CHILDREN),
    value: None,
};

static WORD_REA_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_REAA_NODE),
    None,
    Some(&WORD_REAC_NODE),
    Some(&WORD_READ_NODE),
    Some(&WORD_REAE_NODE),
    None,
    Some(&WORD_REAG_NODE),
    None,
    Some(&WORD_REAI_NODE),
    None,
    Some(&WORD_REAK_NODE),
    Some(&WORD_REAL_NODE),
    Some(&WORD_REAM_NODE),
    Some(&WORD_REAN_NODE),
    Some(&WORD_REAO_NODE),
    Some(&WORD_REAP_NODE),
    Some(&WORD_REAQ_NODE),
    Some(&WORD_REAR_NODE),
    Some(&WORD_REAS_NODE),
    Some(&WORD_REAT_NODE),
    None,
    Some(&WORD_REAV_NODE),
    None,
    None,
    Some(&WORD_REAY_NODE),
    None,
];

static WORD_REAY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REAY_CHILDREN),
    value: Some(&["ready", "really", "ray"]),
};

pub static WORD_REAY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("d")],
    values: &[&["ready", "read"]],
    range: 1..=1,
};

static WORD_REAV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REAV_CHILDREN),
    value: None,
};

pub static WORD_REAV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eled"),
        dictgen::InsensitiveStr::Ascii("eling"),
    ],
    values: &[&["revealed"], &["revealing"]],
    range: 4..=5,
};

static WORD_REAT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REAT_CHILDREN),
    value: None,
};

pub static WORD_REAT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("her"),
        dictgen::InsensitiveStr::Ascii("iler"),
        dictgen::InsensitiveStr::Ascii("ime"),
        dictgen::InsensitiveStr::Ascii("tache"),
        dictgen::InsensitiveStr::Ascii("tachement"),
    ],
    values: &[
        &["create", "relate"],
        &["creates"],
        &["feather", "rather"],
        &["retailer"],
        &["realtime"],
        &["reattach", "reattached"],
        &["reattachment"],
    ],
    range: 1..=9,
};

static WORD_REAS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REAS_CHILDREN),
    value: None,
};

pub static WORD_REAS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("earch"),
        dictgen::InsensitiveStr::Ascii("earcher"),
        dictgen::InsensitiveStr::Ascii("earchers"),
        dictgen::InsensitiveStr::Ascii("erch"),
        dictgen::InsensitiveStr::Ascii("erched"),
        dictgen::InsensitiveStr::Ascii("ercher"),
        dictgen::InsensitiveStr::Ascii("erchers"),
        dictgen::InsensitiveStr::Ascii("erching"),
        dictgen::InsensitiveStr::Ascii("nable"),
        dictgen::InsensitiveStr::Ascii("oable"),
        dictgen::InsensitiveStr::Ascii("onabily"),
        dictgen::InsensitiveStr::Ascii("onablely"),
        dictgen::InsensitiveStr::Ascii("onabley"),
        dictgen::InsensitiveStr::Ascii("onablly"),
        dictgen::InsensitiveStr::Ascii("onal"),
        dictgen::InsensitiveStr::Ascii("onble"),
        dictgen::InsensitiveStr::Ascii("onbly"),
        dictgen::InsensitiveStr::Ascii("onnable"),
        dictgen::InsensitiveStr::Ascii("onnably"),
        dictgen::InsensitiveStr::Ascii("singing"),
        dictgen::InsensitiveStr::Ascii("socation"),
        dictgen::InsensitiveStr::Ascii("socition"),
        dictgen::InsensitiveStr::Ascii("ssign"),
        dictgen::InsensitiveStr::Ascii("sureing"),
        dictgen::InsensitiveStr::Ascii("surring"),
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("y"),
    ],
    values: &[
        &["research"],
        &["researcher"],
        &["researchers"],
        &["research"],
        &["researched"],
        &["researcher"],
        &["researchers"],
        &["researching"],
        &["reasonable"],
        &["reasonable"],
        &["reasonably"],
        &["reasonably"],
        &["reasonably"],
        &["reasonably"],
        &["reasonably"],
        &["reasonable"],
        &["reasonably"],
        &["reasonable"],
        &["reasonably"],
        &["reassigning"],
        &["reassociation"],
        &["reassociation"],
        &["reassign"],
        &["reassuring"],
        &["reassuring"],
        &["rest"],
        &["ready", "easy"],
    ],
    range: 1..=8,
};

static WORD_REAR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REAR_CHILDREN),
    value: None,
};

pub static WORD_REAR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ely"),
        dictgen::InsensitiveStr::Ascii("ranable"),
        dictgen::InsensitiveStr::Ascii("rane"),
        dictgen::InsensitiveStr::Ascii("raned"),
        dictgen::InsensitiveStr::Ascii("ranement"),
        dictgen::InsensitiveStr::Ascii("ranements"),
        dictgen::InsensitiveStr::Ascii("ranent"),
        dictgen::InsensitiveStr::Ascii("ranents"),
        dictgen::InsensitiveStr::Ascii("ranes"),
        dictgen::InsensitiveStr::Ascii("rang"),
        dictgen::InsensitiveStr::Ascii("rangable"),
        dictgen::InsensitiveStr::Ascii("rangaeble"),
        dictgen::InsensitiveStr::Ascii("rangaelbe"),
        dictgen::InsensitiveStr::Ascii("rangd"),
        dictgen::InsensitiveStr::Ascii("rangde"),
        dictgen::InsensitiveStr::Ascii("rangent"),
        dictgen::InsensitiveStr::Ascii("rangents"),
        dictgen::InsensitiveStr::Ascii("rangmeent"),
        dictgen::InsensitiveStr::Ascii("rangmeents"),
        dictgen::InsensitiveStr::Ascii("rangmenet"),
        dictgen::InsensitiveStr::Ascii("rangmenets"),
        dictgen::InsensitiveStr::Ascii("rangment"),
        dictgen::InsensitiveStr::Ascii("rangments"),
        dictgen::InsensitiveStr::Ascii("rangnig"),
        dictgen::InsensitiveStr::Ascii("rangning"),
        dictgen::InsensitiveStr::Ascii("rangs"),
        dictgen::InsensitiveStr::Ascii("rangse"),
        dictgen::InsensitiveStr::Ascii("rangt"),
        dictgen::InsensitiveStr::Ascii("rangte"),
        dictgen::InsensitiveStr::Ascii("rangteable"),
        dictgen::InsensitiveStr::Ascii("rangteables"),
        dictgen::InsensitiveStr::Ascii("rangted"),
        dictgen::InsensitiveStr::Ascii("rangtement"),
        dictgen::InsensitiveStr::Ascii("rangtements"),
        dictgen::InsensitiveStr::Ascii("rangtes"),
        dictgen::InsensitiveStr::Ascii("rangting"),
        dictgen::InsensitiveStr::Ascii("rangts"),
        dictgen::InsensitiveStr::Ascii("raning"),
        dictgen::InsensitiveStr::Ascii("ranment"),
        dictgen::InsensitiveStr::Ascii("ranments"),
        dictgen::InsensitiveStr::Ascii("rant"),
        dictgen::InsensitiveStr::Ascii("rants"),
    ],
    values: &[
        &["rarely"],
        &["rearrangeable"],
        &["rearrange"],
        &["rearranged"],
        &["rearrangement"],
        &["rearrangements"],
        &["rearrangement"],
        &["rearrangements"],
        &["rearranges"],
        &["rearrange"],
        &["rearrangeable"],
        &["rearrangeable"],
        &["rearrangeable"],
        &["rearranged"],
        &["rearranged"],
        &["rearrangement"],
        &["rearrangements"],
        &["rearrangement"],
        &["rearrangements"],
        &["rearrangement"],
        &["rearrangements"],
        &["rearrangement"],
        &["rearrangements"],
        &["rearranging"],
        &["rearranging"],
        &["rearranges"],
        &["rearranges"],
        &["rearrangement"],
        &["rearrange"],
        &["rearrangeable"],
        &["rearrangeables"],
        &["rearranged"],
        &["rearrangement"],
        &["rearrangements"],
        &["rearranges"],
        &["rearranging"],
        &["rearrangements"],
        &["rearranging"],
        &["rearrangement"],
        &["rearrangements"],
        &["rearrangement"],
        &["rearrangements"],
    ],
    range: 3..=11,
};

static WORD_REAQ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REAQ_CHILDREN),
    value: None,
};

pub static WORD_REAQ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("uire")],
    values: &[&["reacquire", "require"]],
    range: 4..=4,
};

static WORD_REAP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REAP_CHILDREN),
    value: None,
};

pub static WORD_REAP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eat"),
        dictgen::InsensitiveStr::Ascii("eated"),
        dictgen::InsensitiveStr::Ascii("eater"),
        dictgen::InsensitiveStr::Ascii("eating"),
        dictgen::InsensitiveStr::Ascii("eats"),
        dictgen::InsensitiveStr::Ascii("ired"),
        dictgen::InsensitiveStr::Ascii("irs"),
        dictgen::InsensitiveStr::Ascii("lugs"),
        dictgen::InsensitiveStr::Ascii("lying"),
        dictgen::InsensitiveStr::Ascii("onsibilities"),
        dictgen::InsensitiveStr::Ascii("onsibility"),
        dictgen::InsensitiveStr::Ascii("peares"),
        dictgen::InsensitiveStr::Ascii("per"),
        dictgen::InsensitiveStr::Ascii("pered"),
        dictgen::InsensitiveStr::Ascii("pering"),
    ],
    values: &[
        &["repeat"],
        &["repeated"],
        &["repeater"],
        &["repeating"],
        &["repeats"],
        &["repaired"],
        &["repairs"],
        &["earplugs"],
        &["replaying"],
        &["responsibilities"],
        &["responsibility"],
        &["reappears"],
        &["reappear"],
        &["reappeared"],
        &["reappearing"],
    ],
    range: 3..=12,
};

static WORD_REAO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REAO_CHILDREN),
    value: None,
};

pub static WORD_REAO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("n"),
        dictgen::InsensitiveStr::Ascii("ns"),
    ],
    values: &[&["reason"], &["reasons"]],
    range: 1..=2,
};

static WORD_REAN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REAN_CHILDREN),
    value: None,
};

pub static WORD_REAN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("der"),
        dictgen::InsensitiveStr::Ascii("me"),
        dictgen::InsensitiveStr::Ascii("med"),
        dictgen::InsensitiveStr::Ascii("mes"),
        dictgen::InsensitiveStr::Ascii("ming"),
    ],
    values: &[
        &["render"],
        &["rename"],
        &["renamed"],
        &["renames"],
        &["renaming"],
    ],
    range: 2..=4,
};

static WORD_REAM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REAM_CHILDREN),
    value: None,
};

pub static WORD_REAM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("de"),
        dictgen::InsensitiveStr::Ascii("in"),
        dictgen::InsensitiveStr::Ascii("ined"),
        dictgen::InsensitiveStr::Ascii("ining"),
        dictgen::InsensitiveStr::Ascii("ins"),
        dictgen::InsensitiveStr::Ascii("pping"),
    ],
    values: &[
        &["readme"],
        &["remain"],
        &["remained"],
        &["remaining"],
        &["remains"],
        &["remapping", "revamping"],
    ],
    range: 2..=5,
};

static WORD_REAL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REAL_CHILDREN),
    value: None,
};

pub static WORD_REAL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ease"),
        dictgen::InsensitiveStr::Ascii("eased"),
        dictgen::InsensitiveStr::Ascii("eases"),
        dictgen::InsensitiveStr::Ascii("iable"),
        dictgen::InsensitiveStr::Ascii("ibility"),
        dictgen::InsensitiveStr::Ascii("ible"),
        dictgen::InsensitiveStr::Ascii("ibly"),
        dictgen::InsensitiveStr::Ascii("ies"),
        dictgen::InsensitiveStr::Ascii("iest"),
        dictgen::InsensitiveStr::Ascii("isim"),
        dictgen::InsensitiveStr::Ascii("isitc"),
        dictgen::InsensitiveStr::Ascii("isitcally"),
        dictgen::InsensitiveStr::Ascii("isme"),
        dictgen::InsensitiveStr::Ascii("istc"),
        dictgen::InsensitiveStr::Ascii("iste"),
        dictgen::InsensitiveStr::Ascii("isticaly"),
        dictgen::InsensitiveStr::Ascii("isticlly"),
        dictgen::InsensitiveStr::Ascii("istisch"),
        dictgen::InsensitiveStr::Ascii("itime"),
        dictgen::InsensitiveStr::Ascii("itvely"),
        dictgen::InsensitiveStr::Ascii("iy"),
        dictgen::InsensitiveStr::Ascii("iztion"),
        dictgen::InsensitiveStr::Ascii("iztions"),
        dictgen::InsensitiveStr::Ascii("l"),
        dictgen::InsensitiveStr::Ascii("ling"),
        dictgen::InsensitiveStr::Ascii("lize"),
        dictgen::InsensitiveStr::Ascii("lllly"),
        dictgen::InsensitiveStr::Ascii("locae"),
        dictgen::InsensitiveStr::Ascii("locaes"),
        dictgen::InsensitiveStr::Ascii("locaiing"),
        dictgen::InsensitiveStr::Ascii("locaing"),
        dictgen::InsensitiveStr::Ascii("locaion"),
        dictgen::InsensitiveStr::Ascii("locaions"),
        dictgen::InsensitiveStr::Ascii("locaite"),
        dictgen::InsensitiveStr::Ascii("locaites"),
        dictgen::InsensitiveStr::Ascii("locaiting"),
        dictgen::InsensitiveStr::Ascii("locaition"),
        dictgen::InsensitiveStr::Ascii("locaitions"),
        dictgen::InsensitiveStr::Ascii("locaiton"),
        dictgen::InsensitiveStr::Ascii("locaitons"),
        dictgen::InsensitiveStr::Ascii("oded"),
        dictgen::InsensitiveStr::Ascii("oding"),
        dictgen::InsensitiveStr::Ascii("sie"),
        dictgen::InsensitiveStr::Ascii("sied"),
        dictgen::InsensitiveStr::Ascii("sim"),
        dictgen::InsensitiveStr::Ascii("sitic"),
        dictgen::InsensitiveStr::Ascii("stic"),
        dictgen::InsensitiveStr::Ascii("table"),
        dictgen::InsensitiveStr::Ascii("ted"),
        dictgen::InsensitiveStr::Ascii("tes"),
        dictgen::InsensitiveStr::Ascii("tion"),
        dictgen::InsensitiveStr::Ascii("tions"),
        dictgen::InsensitiveStr::Ascii("tionships"),
        dictgen::InsensitiveStr::Ascii("tive"),
        dictgen::InsensitiveStr::Ascii("tively"),
        dictgen::InsensitiveStr::Ascii("tives"),
        dictgen::InsensitiveStr::Ascii("tivity"),
        dictgen::InsensitiveStr::Ascii("y"),
        dictgen::InsensitiveStr::Ascii("yl"),
    ],
    values: &[
        &["release"],
        &["released"],
        &["releases"],
        &["reliable"],
        &["reliability"],
        &["reliable"],
        &["reliably"],
        &["realise"],
        &["earliest"],
        &["realism"],
        &["realistic"],
        &["realistically"],
        &["realise"],
        &["realistic"],
        &["realise"],
        &["realistically"],
        &["realistically"],
        &["realistic"],
        &["realtime"],
        &["relatively"],
        &["really"],
        &["realization"],
        &["realizations"],
        &["real", "really", "recall"],
        &["really"],
        &["realize"],
        &["really"],
        &["reallocate"],
        &["reallocates"],
        &["reallocating"],
        &["reallocating"],
        &["reallocation"],
        &["reallocations"],
        &["reallocate"],
        &["reallocates"],
        &["reallocating"],
        &["reallocation"],
        &["reallocations"],
        &["reallocation"],
        &["reallocations"],
        &["reloaded"],
        &["reloading"],
        &["realise"],
        &["realised"],
        &["realism"],
        &["realistic"],
        &["realistic"],
        &["relatable"],
        &["related"],
        &["relates"],
        &["relation", "reaction"],
        &["relations", "reactions"],
        &["relationships"],
        &["relative", "reactive"],
        &["relatively"],
        &["relatives"],
        &["relativity"],
        &["really", "relay", "real"],
        &["really"],
    ],
    range: 1..=10,
};

static WORD_REAK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REAK_CHILDREN),
    value: None,
};

pub static WORD_REAK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("tivate"),
        dictgen::InsensitiveStr::Ascii("tivated"),
    ],
    values: &[&["reactivate"], &["reactivated"]],
    range: 6..=7,
};

static WORD_REAI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REAI_CHILDREN),
    value: None,
};

pub static WORD_REAI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("se")],
    values: &[&["realise", "raise"]],
    range: 2..=2,
};

static WORD_REAG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REAG_CHILDREN),
    value: None,
};

pub static WORD_REAG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("rding"),
        dictgen::InsensitiveStr::Ascii("rds"),
    ],
    values: &[&["regarding"], &["regards"]],
    range: 3..=5,
};

static WORD_REAE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REAE_CHILDREN),
    value: None,
};

pub static WORD_REAE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ched")],
    values: &[&["reached"]],
    range: 4..=4,
};

static WORD_READ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_READ_CHILDREN),
    value: None,
};

pub static WORD_READ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("abilty"),
        dictgen::InsensitiveStr::Ascii("anle"),
        dictgen::InsensitiveStr::Ascii("ble"),
        dictgen::InsensitiveStr::Ascii("by"),
        dictgen::InsensitiveStr::Ascii("drss"),
        dictgen::InsensitiveStr::Ascii("drssed"),
        dictgen::InsensitiveStr::Ascii("drsses"),
        dictgen::InsensitiveStr::Ascii("drssing"),
        dictgen::InsensitiveStr::Ascii("eable"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("eme"),
        dictgen::InsensitiveStr::Ascii("iable"),
        dictgen::InsensitiveStr::Ascii("ibility"),
        dictgen::InsensitiveStr::Ascii("ible"),
        dictgen::InsensitiveStr::Ascii("ig"),
        dictgen::InsensitiveStr::Ascii("igs"),
        dictgen::InsensitiveStr::Ascii("ius"),
        dictgen::InsensitiveStr::Ascii("ly"),
        dictgen::InsensitiveStr::Ascii("mition"),
        dictgen::InsensitiveStr::Ascii("nig"),
        dictgen::InsensitiveStr::Ascii("ning"),
        dictgen::InsensitiveStr::Ascii("yness"),
    ],
    values: &[
        &["readability"],
        &["readable"],
        &["readable"],
        &["read"],
        &["readdress"],
        &["readdressed"],
        &["readdresses"],
        &["readdressing"],
        &["readable"],
        &["read", "readd", "readded"],
        &["readme"],
        &["readable"],
        &["readability"],
        &["readable"],
        &["reading"],
        &["readings"],
        &["radius"],
        &["readily", "ready"],
        &["readmission"],
        &["reading"],
        &["reading"],
        &["readiness"],
    ],
    range: 2..=7,
};

static WORD_REAC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REAC_CHILDREN),
    value: None,
};

pub static WORD_REAC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ahable"),
        dictgen::InsensitiveStr::Ascii("ahble"),
        dictgen::InsensitiveStr::Ascii("curring"),
        dictgen::InsensitiveStr::Ascii("eive"),
        dictgen::InsensitiveStr::Ascii("heable"),
        dictgen::InsensitiveStr::Ascii("her"),
        dictgen::InsensitiveStr::Ascii("hers"),
        dictgen::InsensitiveStr::Ascii("hs"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("ll"),
        dictgen::InsensitiveStr::Ascii("tionair"),
        dictgen::InsensitiveStr::Ascii("tionairy"),
        dictgen::InsensitiveStr::Ascii("tionnary"),
        dictgen::InsensitiveStr::Ascii("tiony"),
        dictgen::InsensitiveStr::Ascii("tquire"),
    ],
    values: &[
        &["reachable"],
        &["reachable"],
        &["recurring"],
        &["receive"],
        &["reachable"],
        &["richer", "reader"],
        &["readers"],
        &["reaches"],
        &["reaching"],
        &["recall"],
        &["reactionary"],
        &["reactionary"],
        &["reactionary"],
        &["reactionary"],
        &["reacquire"],
    ],
    range: 2..=8,
};

static WORD_REAA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_REAA_CHILDREN),
    value: None,
};

pub static WORD_REAA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ly"),
        dictgen::InsensitiveStr::Ascii("range"),
        dictgen::InsensitiveStr::Ascii("ranges"),
        dictgen::InsensitiveStr::Ascii("signed"),
    ],
    values: &[
        &["really"],
        &["rearrange"],
        &["rearranges"],
        &["reassigned"],
    ],
    range: 2..=6,
};

static WORD_RD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RD_CHILDREN),
    value: None,
};

pub static WORD_RD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("uce")],
    values: &[&["reduce"]],
    range: 3..=3,
};

static WORD_RC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RC_CHILDREN),
    value: None,
};

pub static WORD_RC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("all"),
        dictgen::InsensitiveStr::Ascii("eate"),
        dictgen::InsensitiveStr::Ascii("eating"),
    ],
    values: &[&["recall"], &["create"], &["creating"]],
    range: 3..=6,
};

static WORD_RA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_RA_CHILDREN),
    value: None,
};

static WORD_RA_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    Some(&WORD_RAB_NODE),
    Some(&WORD_RAC_NODE),
    Some(&WORD_RAD_NODE),
    Some(&WORD_RAE_NODE),
    None,
    None,
    Some(&WORD_RAH_NODE),
    Some(&WORD_RAI_NODE),
    None,
    None,
    Some(&WORD_RAL_NODE),
    Some(&WORD_RAM_NODE),
    Some(&WORD_RAN_NODE),
    Some(&WORD_RAO_NODE),
    Some(&WORD_RAP_NODE),
    None,
    Some(&WORD_RAR_NODE),
    Some(&WORD_RAS_NODE),
    Some(&WORD_RAT_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_RAT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RAT_CHILDREN),
    value: None,
};

pub static WORD_RAT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("atooee"),
        dictgen::InsensitiveStr::Ascii("atoolee"),
        dictgen::InsensitiveStr::Ascii("atui"),
        dictgen::InsensitiveStr::Ascii("har"),
        dictgen::InsensitiveStr::Ascii("hcet"),
        dictgen::InsensitiveStr::Ascii("hern"),
        dictgen::InsensitiveStr::Ascii("ionalizaiton"),
        dictgen::InsensitiveStr::Ascii("ionalizating"),
        dictgen::InsensitiveStr::Ascii("ionalizaton"),
        dictgen::InsensitiveStr::Ascii("ionalle"),
        dictgen::InsensitiveStr::Ascii("ionallity"),
        dictgen::InsensitiveStr::Ascii("ionaly"),
        dictgen::InsensitiveStr::Ascii("ionel"),
        dictgen::InsensitiveStr::Ascii("ionnal"),
        dictgen::InsensitiveStr::Ascii("ionnals"),
        dictgen::InsensitiveStr::Ascii("pure"),
    ],
    values: &[
        &["ratatouille"],
        &["ratatouille"],
        &["ratatouille"],
        &["rather"],
        &["ratchet"],
        &["rather"],
        &["rationalization"],
        &["rationalization"],
        &["rationalization"],
        &["rationale"],
        &["rationally"],
        &["rationally"],
        &["rationale"],
        &["rational", "rationale"],
        &["rationales", "rationals"],
        &["rapture"],
    ],
    range: 3..=12,
};

static WORD_RAS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RAS_CHILDREN),
    value: None,
};

pub static WORD_RAS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("berry"),
        dictgen::InsensitiveStr::Ascii("bperries"),
        dictgen::InsensitiveStr::Ascii("bperry"),
        dictgen::InsensitiveStr::Ascii("ie"),
        dictgen::InsensitiveStr::Ascii("ied"),
        dictgen::InsensitiveStr::Ascii("ies"),
        dictgen::InsensitiveStr::Ascii("iing"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("ons"),
        dictgen::InsensitiveStr::Ascii("pberrry"),
        dictgen::InsensitiveStr::Ascii("pbery"),
        dictgen::InsensitiveStr::Ascii("poberry"),
        dictgen::InsensitiveStr::Ascii("terizor"),
    ],
    values: &[
        &["raspberry"],
        &["raspberries"],
        &["raspberry"],
        &["raise"],
        &["raised"],
        &["raises"],
        &["raising"],
        &["raising"],
        &["reasons"],
        &["raspberry"],
        &["raspberry"],
        &["raspberry"],
        &["rasterizer"],
    ],
    range: 2..=8,
};

static WORD_RAR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RAR_CHILDREN),
    value: None,
};

pub static WORD_RAR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("elly"),
        dictgen::InsensitiveStr::Ascii("ified"),
    ],
    values: &[&["rarely"], &["rarefied"]],
    range: 4..=5,
};

static WORD_RAP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RAP_CHILDREN),
    value: None,
};

pub static WORD_RAP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ell"),
        dictgen::InsensitiveStr::Ascii("elled"),
        dictgen::InsensitiveStr::Ascii("elling"),
        dictgen::InsensitiveStr::Ascii("ells"),
        dictgen::InsensitiveStr::Ascii("hsody"),
        dictgen::InsensitiveStr::Ascii("lace"),
        dictgen::InsensitiveStr::Ascii("lacing"),
        dictgen::InsensitiveStr::Ascii("ore"),
        dictgen::InsensitiveStr::Ascii("resent"),
        dictgen::InsensitiveStr::Ascii("resentation"),
        dictgen::InsensitiveStr::Ascii("resented"),
        dictgen::InsensitiveStr::Ascii("resenting"),
        dictgen::InsensitiveStr::Ascii("resents"),
        dictgen::InsensitiveStr::Ascii("sadies"),
        dictgen::InsensitiveStr::Ascii("sady"),
        dictgen::InsensitiveStr::Ascii("sadys"),
        dictgen::InsensitiveStr::Ascii("sberry"),
        dictgen::InsensitiveStr::Ascii("tores"),
        dictgen::InsensitiveStr::Ascii("tros"),
        dictgen::InsensitiveStr::Ascii("utre"),
    ],
    values: &[
        &["rappel"],
        &["rappelled"],
        &["rappelling"],
        &["rappells"],
        &["rhapsody"],
        &["replace"],
        &["replacing"],
        &["rapport"],
        &["represent"],
        &["representation"],
        &["represented"],
        &["representing"],
        &["represents"],
        &["rhapsodies"],
        &["rhapsody"],
        &["rhapsodies"],
        &["raspberry"],
        &["raptors"],
        &["raptors"],
        &["rapture"],
    ],
    range: 3..=11,
};

static WORD_RAO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RAO_CHILDREN),
    value: None,
};

pub static WORD_RAO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ches"),
        dictgen::InsensitiveStr::Ascii("ming"),
        dictgen::InsensitiveStr::Ascii("sting"),
        dictgen::InsensitiveStr::Ascii("tat"),
        dictgen::InsensitiveStr::Ascii("tate"),
        dictgen::InsensitiveStr::Ascii("tated"),
        dictgen::InsensitiveStr::Ascii("tates"),
        dictgen::InsensitiveStr::Ascii("tating"),
        dictgen::InsensitiveStr::Ascii("tation"),
        dictgen::InsensitiveStr::Ascii("tations"),
        dictgen::InsensitiveStr::Ascii("tats"),
    ],
    values: &[
        &["roaches"],
        &["roaming"],
        &["roasting"],
        &["rotate"],
        &["rotate"],
        &["rotated"],
        &["rotates"],
        &["rotating"],
        &["rotation"],
        &["rotations"],
        &["rotates"],
    ],
    range: 3..=7,
};

static WORD_RAN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RAN_CHILDREN),
    value: None,
};

pub static WORD_RAN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("dayvoo"),
        dictgen::InsensitiveStr::Ascii("dayvooed"),
        dictgen::InsensitiveStr::Ascii("dayvoos"),
        dictgen::InsensitiveStr::Ascii("dayvou"),
        dictgen::InsensitiveStr::Ascii("dayvoued"),
        dictgen::InsensitiveStr::Ascii("dayvous"),
        dictgen::InsensitiveStr::Ascii("dazyvoo"),
        dictgen::InsensitiveStr::Ascii("dazyvooed"),
        dictgen::InsensitiveStr::Ascii("dazyvoos"),
        dictgen::InsensitiveStr::Ascii("dazyvou"),
        dictgen::InsensitiveStr::Ascii("dazyvoued"),
        dictgen::InsensitiveStr::Ascii("dazyvous"),
        dictgen::InsensitiveStr::Ascii("dmom"),
        dictgen::InsensitiveStr::Ascii("dmoness"),
        dictgen::InsensitiveStr::Ascii("domally"),
        dictgen::InsensitiveStr::Ascii("domes"),
        dictgen::InsensitiveStr::Ascii("domez"),
        dictgen::InsensitiveStr::Ascii("domns"),
        dictgen::InsensitiveStr::Ascii("domrs"),
        dictgen::InsensitiveStr::Ascii("domus"),
        dictgen::InsensitiveStr::Ascii("domzied"),
        dictgen::InsensitiveStr::Ascii("donmess"),
        dictgen::InsensitiveStr::Ascii("dum"),
        dictgen::InsensitiveStr::Ascii("dumness"),
    ],
    values: &[
        &["rendezvous"],
        &["rendezvoused"],
        &["rendezvous"],
        &["rendezvous"],
        &["rendezvoused"],
        &["rendezvous"],
        &["rendezvous"],
        &["rendezvoused"],
        &["rendezvous"],
        &["rendezvous"],
        &["rendezvoused"],
        &["rendezvous"],
        &["random"],
        &["randomness"],
        &["randomly"],
        &["randoms"],
        &["randomized"],
        &["randoms"],
        &["randoms"],
        &["randoms"],
        &["randomized"],
        &["randomness"],
        &["random"],
        &["randomness"],
    ],
    range: 3..=9,
};

static WORD_RAM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RAM_CHILDREN),
    value: None,
};

pub static WORD_RAM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ificaitons")],
    values: &[&["ramifications"]],
    range: 10..=10,
};

static WORD_RAL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RAL_CHILDREN),
    value: None,
};

pub static WORD_RAL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ation")],
    values: &[&["relation"]],
    range: 5..=5,
};

static WORD_RAI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RAI_CHILDREN),
    value: None,
};

pub static WORD_RAI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("dance"),
        dictgen::InsensitiveStr::Ascii("dant"),
        dictgen::InsensitiveStr::Ascii("doactive"),
        dictgen::InsensitiveStr::Ascii("lraod"),
        dictgen::InsensitiveStr::Ascii("lrod"),
        dictgen::InsensitiveStr::Ascii("nbos"),
        dictgen::InsensitiveStr::Ascii("nbowers"),
        dictgen::InsensitiveStr::Ascii("sedd"),
        dictgen::InsensitiveStr::Ascii("son"),
    ],
    values: &[
        &["radiance"],
        &["radiant"],
        &["radioactive"],
        &["railroad"],
        &["railroad"],
        &["rainbows"],
        &["rainbows"],
        &["raised"],
        &["reason", "raisin"],
    ],
    range: 3..=8,
};

static WORD_RAH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RAH_CHILDREN),
    value: None,
};

pub static WORD_RAH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("psody")],
    values: &[&["rhapsody"]],
    range: 5..=5,
};

static WORD_RAE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RAE_CHILDREN),
    value: None,
};

pub static WORD_RAE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("d"),
        dictgen::InsensitiveStr::Ascii("ding"),
        dictgen::InsensitiveStr::Ascii("ds"),
        dictgen::InsensitiveStr::Ascii("dy"),
        dictgen::InsensitiveStr::Ascii("lism"),
        dictgen::InsensitiveStr::Ascii("lly"),
    ],
    values: &[
        &["read"],
        &["reading"],
        &["reads"],
        &["ready"],
        &["realism"],
        &["really"],
    ],
    range: 1..=4,
};

static WORD_RAD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RAD_CHILDREN),
    value: None,
};

pub static WORD_RAD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aince"),
        dictgen::InsensitiveStr::Ascii("aint"),
        dictgen::InsensitiveStr::Ascii("ation"),
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("emption"),
        dictgen::InsensitiveStr::Ascii("emptions"),
        dictgen::InsensitiveStr::Ascii("emtion"),
        dictgen::InsensitiveStr::Ascii("emtions"),
        dictgen::InsensitiveStr::Ascii("eus"),
        dictgen::InsensitiveStr::Ascii("euses"),
        dictgen::InsensitiveStr::Ascii("iactive"),
        dictgen::InsensitiveStr::Ascii("iane"),
        dictgen::InsensitiveStr::Ascii("iaoctive"),
        dictgen::InsensitiveStr::Ascii("iaton"),
        dictgen::InsensitiveStr::Ascii("icalis"),
        dictgen::InsensitiveStr::Ascii("icas"),
        dictgen::InsensitiveStr::Ascii("iers"),
        dictgen::InsensitiveStr::Ascii("ify"),
        dictgen::InsensitiveStr::Ascii("ioacive"),
        dictgen::InsensitiveStr::Ascii("ioactice"),
        dictgen::InsensitiveStr::Ascii("ioactief"),
        dictgen::InsensitiveStr::Ascii("ioactieve"),
        dictgen::InsensitiveStr::Ascii("ioaktive"),
        dictgen::InsensitiveStr::Ascii("iobuttion"),
        dictgen::InsensitiveStr::Ascii("iocative"),
        dictgen::InsensitiveStr::Ascii("is"),
        dictgen::InsensitiveStr::Ascii("uis"),
        dictgen::InsensitiveStr::Ascii("us"),
        dictgen::InsensitiveStr::Ascii("y"),
    ],
    values: &[
        &["radiance"],
        &["radiant"],
        &["radiation"],
        &["read", "raid"],
        &["redemption"],
        &["redemptions"],
        &["redemption"],
        &["redemptions"],
        &["radius"],
        &["radii", "radiuses"],
        &["radioactive"],
        &["radiance"],
        &["radioactive"],
        &["radiation"],
        &["radicals"],
        &["radicals"],
        &["raiders"],
        &["ratify"],
        &["radioactive"],
        &["radioactive"],
        &["radioactive"],
        &["radioactive"],
        &["radioactive"],
        &["radiobutton"],
        &["radioactive"],
        &["radix"],
        &["radius"],
        &["radius"],
        &["ready"],
    ],
    range: 1..=9,
};

static WORD_RAC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RAC_CHILDREN),
    value: None,
};

pub static WORD_RAC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aus"),
        dictgen::InsensitiveStr::Ascii("ionalization"),
        dictgen::InsensitiveStr::Ascii("isst"),
        dictgen::InsensitiveStr::Ascii("istas"),
        dictgen::InsensitiveStr::Ascii("istes"),
        dictgen::InsensitiveStr::Ascii("kit"),
        dictgen::InsensitiveStr::Ascii("kits"),
        dictgen::InsensitiveStr::Ascii("thet"),
        dictgen::InsensitiveStr::Ascii("tise"),
    ],
    values: &[
        &["raucous"],
        &["rationalization"],
        &["racists"],
        &["racists"],
        &["racists"],
        &["racket"],
        &["rackets"],
        &["ratchet"],
        &["practise"],
    ],
    range: 3..=12,
};

static WORD_RAB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_RAB_CHILDREN),
    value: None,
};

pub static WORD_RAB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("bitos"),
        dictgen::InsensitiveStr::Ascii("bitts"),
        dictgen::InsensitiveStr::Ascii("innical"),
        dictgen::InsensitiveStr::Ascii("it"),
        dictgen::InsensitiveStr::Ascii("its"),
    ],
    values: &[
        &["rabbits"],
        &["rabbits"],
        &["rabbinical"],
        &["rabbit"],
        &["rabbits"],
    ],
    range: 2..=7,
};

static WORD_Q_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_Q_CHILDREN),
    value: None,
};

static WORD_Q_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_QA_NODE),
    None,
    None,
    None,
    Some(&WORD_QE_NODE),
    None,
    None,
    Some(&WORD_QH_NODE),
    Some(&WORD_QI_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_QO_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_QT_NODE),
    Some(&WORD_QU_NODE),
    None,
    Some(&WORD_QW_NODE),
    None,
    None,
    None,
];

static WORD_QW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_QW_CHILDREN),
    value: None,
};

pub static WORD_QW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("esant"),
        dictgen::InsensitiveStr::Ascii("esants"),
        dictgen::InsensitiveStr::Ascii("essant"),
        dictgen::InsensitiveStr::Ascii("essants"),
    ],
    values: &[
        &["croissant"],
        &["croissants"],
        &["croissant"],
        &["croissants"],
    ],
    range: 5..=7,
};

static WORD_QU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_QU_CHILDREN),
    value: None,
};

static WORD_QU_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_QUA_NODE),
    None,
    Some(&WORD_QUC_NODE),
    Some(&WORD_QUD_NODE),
    Some(&WORD_QUE_NODE),
    None,
    None,
    None,
    Some(&WORD_QUI_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_QUN_NODE),
    Some(&WORD_QUO_NODE),
    None,
    None,
    Some(&WORD_QUR_NODE),
    Some(&WORD_QUS_NODE),
    Some(&WORD_QUT_NODE),
    Some(&WORD_QUU_NODE),
    None,
    Some(&WORD_QUW_NODE),
    None,
    None,
    None,
];

static WORD_QUW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_QUW_CHILDREN),
    value: None,
};

pub static WORD_QUW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("esant"),
        dictgen::InsensitiveStr::Ascii("esants"),
        dictgen::InsensitiveStr::Ascii("essant"),
        dictgen::InsensitiveStr::Ascii("essants"),
    ],
    values: &[
        &["croissant"],
        &["croissants"],
        &["croissant"],
        &["croissants"],
    ],
    range: 5..=7,
};

static WORD_QUU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_QUU_CHILDREN),
    value: None,
};

pub static WORD_QUU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ery")],
    values: &[&["query"]],
    range: 3..=3,
};

static WORD_QUT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_QUT_CHILDREN),
    value: None,
};

pub static WORD_QUT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ie")],
    values: &[&["quite", "quiet"]],
    range: 2..=2,
};

static WORD_QUS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_QUS_CHILDREN),
    value: None,
};

pub static WORD_QUS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("ts"),
    ],
    values: &[&["quest"], &["quests"]],
    range: 1..=2,
};

static WORD_QUR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_QUR_CHILDREN),
    value: None,
};

pub static WORD_QUR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ied"),
        dictgen::InsensitiveStr::Ascii("oum"),
    ],
    values: &[&["queried"], &["quorum"]],
    range: 3..=3,
};

static WORD_QUO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_QUO_CHILDREN),
    value: None,
};

pub static WORD_QUO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("shant"),
        dictgen::InsensitiveStr::Ascii("shants"),
        dictgen::InsensitiveStr::Ascii("taion"),
        dictgen::InsensitiveStr::Ascii("taions"),
        dictgen::InsensitiveStr::Ascii("teed"),
        dictgen::InsensitiveStr::Ascii("tent"),
        dictgen::InsensitiveStr::Ascii("ttes"),
    ],
    values: &[
        &["quotient"],
        &["quotients"],
        &["quotation"],
        &["quotations"],
        &["quoted"],
        &["quotient"],
        &["quotes"],
    ],
    range: 4..=6,
};

static WORD_QUN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_QUN_CHILDREN),
    value: None,
};

pub static WORD_QUN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("atum"),
        dictgen::InsensitiveStr::Ascii("etin"),
    ],
    values: &[&["quantum"], &["quentin"]],
    range: 4..=4,
};

static WORD_QUI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_QUI_CHILDREN),
    value: None,
};

pub static WORD_QUI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cket"),
        dictgen::InsensitiveStr::Ascii("ckets"),
        dictgen::InsensitiveStr::Ascii("ckier"),
        dictgen::InsensitiveStr::Ascii("cklyu"),
        dictgen::InsensitiveStr::Ascii("cky"),
        dictgen::InsensitiveStr::Ascii("ckyl"),
        dictgen::InsensitiveStr::Ascii("cly"),
        dictgen::InsensitiveStr::Ascii("elty"),
        dictgen::InsensitiveStr::Ascii("essent"),
        dictgen::InsensitiveStr::Ascii("est"),
        dictgen::InsensitiveStr::Ascii("ests"),
        dictgen::InsensitiveStr::Ascii("kc"),
        dictgen::InsensitiveStr::Ascii("nessential"),
        dictgen::InsensitiveStr::Ascii("ries"),
        dictgen::InsensitiveStr::Ascii("tely"),
        dictgen::InsensitiveStr::Ascii("th"),
        dictgen::InsensitiveStr::Ascii("ting"),
        dictgen::InsensitiveStr::Ascii("tt"),
        dictgen::InsensitiveStr::Ascii("tted"),
        dictgen::InsensitiveStr::Ascii("zes"),
        dictgen::InsensitiveStr::Ascii("zs"),
        dictgen::InsensitiveStr::Ascii("zzs"),
    ],
    values: &[
        &["quickest"],
        &["quickest"],
        &["quicker"],
        &["quickly"],
        &["quickie", "quickly"],
        &["quickly"],
        &["quickly"],
        &["quietly"],
        &["quiescent"],
        &["quest", "quiet"],
        &["quests"],
        &["quick"],
        &["quintessential"],
        &["queries"],
        &["quietly", "quite"],
        &["quit", "with"],
        &["quitting"],
        &["quit"],
        &["quit"],
        &["quizzes"],
        &["quizzes"],
        &["quizzes"],
    ],
    range: 2..=10,
};

static WORD_QUE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_QUE_CHILDREN),
    value: None,
};

pub static WORD_QUE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ation"),
        dictgen::InsensitiveStr::Ascii("ations"),
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("enland"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("ires"),
        dictgen::InsensitiveStr::Ascii("iried"),
        dictgen::InsensitiveStr::Ascii("isce"),
        dictgen::InsensitiveStr::Ascii("itly"),
        dictgen::InsensitiveStr::Ascii("ntion"),
        dictgen::InsensitiveStr::Ascii("red"),
        dictgen::InsensitiveStr::Ascii("reis"),
        dictgen::InsensitiveStr::Ascii("riable"),
        dictgen::InsensitiveStr::Ascii("ring"),
        dictgen::InsensitiveStr::Ascii("rries"),
        dictgen::InsensitiveStr::Ascii("rry"),
        dictgen::InsensitiveStr::Ascii("ryies"),
        dictgen::InsensitiveStr::Ascii("ryinterace"),
        dictgen::InsensitiveStr::Ascii("rys"),
        dictgen::InsensitiveStr::Ascii("sant"),
        dictgen::InsensitiveStr::Ascii("sants"),
        dictgen::InsensitiveStr::Ascii("set"),
        dictgen::InsensitiveStr::Ascii("sets"),
        dictgen::InsensitiveStr::Ascii("siton"),
        dictgen::InsensitiveStr::Ascii("sitonable"),
        dictgen::InsensitiveStr::Ascii("sitoned"),
        dictgen::InsensitiveStr::Ascii("sitoning"),
        dictgen::InsensitiveStr::Ascii("sitons"),
        dictgen::InsensitiveStr::Ascii("sr"),
        dictgen::InsensitiveStr::Ascii("srs"),
        dictgen::InsensitiveStr::Ascii("ss"),
        dictgen::InsensitiveStr::Ascii("ssant"),
        dictgen::InsensitiveStr::Ascii("ssants"),
        dictgen::InsensitiveStr::Ascii("stionaire"),
        dictgen::InsensitiveStr::Ascii("stional"),
        dictgen::InsensitiveStr::Ascii("stionalbe"),
        dictgen::InsensitiveStr::Ascii("stionalble"),
        dictgen::InsensitiveStr::Ascii("stionare"),
        dictgen::InsensitiveStr::Ascii("stionares"),
        dictgen::InsensitiveStr::Ascii("stiond"),
        dictgen::InsensitiveStr::Ascii("stiong"),
        dictgen::InsensitiveStr::Ascii("stionn"),
        dictgen::InsensitiveStr::Ascii("stionnair"),
        dictgen::InsensitiveStr::Ascii("stionne"),
        dictgen::InsensitiveStr::Ascii("stionned"),
        dictgen::InsensitiveStr::Ascii("stionning"),
        dictgen::InsensitiveStr::Ascii("stionsign"),
        dictgen::InsensitiveStr::Ascii("stoin"),
        dictgen::InsensitiveStr::Ascii("stoins"),
        dictgen::InsensitiveStr::Ascii("stonable"),
        dictgen::InsensitiveStr::Ascii("u"),
        dictgen::InsensitiveStr::Ascii("ueud"),
        dictgen::InsensitiveStr::Ascii("us"),
        dictgen::InsensitiveStr::Ascii("w"),
    ],
    values: &[
        &["equation"],
        &["equations"],
        &["queue"],
        &["queensland"],
        &["queuing"],
        &["queries"],
        &["queried"],
        &["quiesce"],
        &["quietly"],
        &["quentin"],
        &["queried"],
        &["queries"],
        &["queryable"],
        &["querying"],
        &["queries"],
        &["quarry", "query"],
        &["queries"],
        &["queryinterface"],
        &["queries"],
        &["croissant"],
        &["croissants"],
        &["quest"],
        &["quests"],
        &["question"],
        &["questionable"],
        &["questioned"],
        &["questioning"],
        &["questions"],
        &["quest"],
        &["quests"],
        &["guess", "quests"],
        &["croissant"],
        &["croissants"],
        &["questionnaire"],
        &["questionable"],
        &["questionable"],
        &["questionable"],
        &["questionnaire"],
        &["questionnaires"],
        &["questioned"],
        &["questioning"],
        &["questioning"],
        &["questionnaire"],
        &["questioned"],
        &["questioned"],
        &["questioning"],
        &["questioning"],
        &["question"],
        &["questions"],
        &["questionable"],
        &["queue"],
        &["queued"],
        &["queues"],
        &["queue"],
    ],
    range: 1..=10,
};

static WORD_QUD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_QUD_CHILDREN),
    value: None,
};

pub static WORD_QUD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("rangles")],
    values: &[&["quadrangles"]],
    range: 7..=7,
};

static WORD_QUC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_QUC_CHILDREN),
    value: None,
};

pub static WORD_QUC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ikest"),
        dictgen::InsensitiveStr::Ascii("kstarter"),
    ],
    values: &[&["quickest"], &["quickstarter"]],
    range: 5..=8,
};

static WORD_QUA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_QUA_CHILDREN),
    value: None,
};

static WORD_QUA_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    None,
    Some(&WORD_QUAD_NODE),
    None,
    Some(&WORD_QUAF_NODE),
    None,
    None,
    Some(&WORD_QUAI_NODE),
    None,
    None,
    Some(&WORD_QUAL_NODE),
    None,
    Some(&WORD_QUAN_NODE),
    None,
    None,
    None,
    Some(&WORD_QUAR_NODE),
    None,
    Some(&WORD_QUAT_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_QUAT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_QUAT_CHILDREN),
    value: None,
};

pub static WORD_QUAT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ation"),
        dictgen::InsensitiveStr::Ascii("er"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("ion"),
        dictgen::InsensitiveStr::Ascii("ions"),
    ],
    values: &[
        &["quotation"],
        &["quarter"],
        &["quoting", "squatting", "equating"],
        &["equation"],
        &["equations"],
    ],
    range: 2..=5,
};

static WORD_QUAR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_QUAR_CHILDREN),
    value: None,
};

pub static WORD_QUAR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("antaine"),
        dictgen::InsensitiveStr::Ascii("ante"),
        dictgen::InsensitiveStr::Ascii("antena"),
        dictgen::InsensitiveStr::Ascii("antene"),
        dictgen::InsensitiveStr::Ascii("antenni"),
        dictgen::InsensitiveStr::Ascii("antied"),
        dictgen::InsensitiveStr::Ascii("entine"),
        dictgen::InsensitiveStr::Ascii("intine"),
        dictgen::InsensitiveStr::Ascii("tenion"),
        dictgen::InsensitiveStr::Ascii("tenions"),
        dictgen::InsensitiveStr::Ascii("terbackers"),
        dictgen::InsensitiveStr::Ascii("terblack"),
        dictgen::InsensitiveStr::Ascii("tercask"),
        dictgen::InsensitiveStr::Ascii("tery"),
        dictgen::InsensitiveStr::Ascii("tically"),
        dictgen::InsensitiveStr::Ascii("tlery"),
        dictgen::InsensitiveStr::Ascii("untine"),
    ],
    values: &[
        &["quarantine"],
        &["quarantine"],
        &["quarantine"],
        &["quarantine"],
        &["quarantine"],
        &["quarantine"],
        &["quarantine"],
        &["quarantine"],
        &["quaternion"],
        &["quaternions"],
        &["quarterbacks"],
        &["quarterback"],
        &["quarterbacks"],
        &["quarterly"],
        &["quadratically"],
        &["quarterly"],
        &["quarantine"],
    ],
    range: 4..=10,
};

static WORD_QUAN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_QUAN_CHILDREN),
    value: None,
};

pub static WORD_QUAN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("itfy"),
        dictgen::InsensitiveStr::Ascii("ities"),
        dictgen::InsensitiveStr::Ascii("itified"),
        dictgen::InsensitiveStr::Ascii("itites"),
        dictgen::InsensitiveStr::Ascii("ity"),
        dictgen::InsensitiveStr::Ascii("lification"),
        dictgen::InsensitiveStr::Ascii("lified"),
        dictgen::InsensitiveStr::Ascii("lifies"),
        dictgen::InsensitiveStr::Ascii("lify"),
        dictgen::InsensitiveStr::Ascii("taties"),
        dictgen::InsensitiveStr::Ascii("tatitive"),
        dictgen::InsensitiveStr::Ascii("taty"),
        dictgen::InsensitiveStr::Ascii("tifiy"),
        dictgen::InsensitiveStr::Ascii("titaive"),
        dictgen::InsensitiveStr::Ascii("titatve"),
        dictgen::InsensitiveStr::Ascii("tite"),
        dictgen::InsensitiveStr::Ascii("titites"),
        dictgen::InsensitiveStr::Ascii("tititive"),
        dictgen::InsensitiveStr::Ascii("titity"),
        dictgen::InsensitiveStr::Ascii("titiy"),
        dictgen::InsensitiveStr::Ascii("titize"),
        dictgen::InsensitiveStr::Ascii("titties"),
        dictgen::InsensitiveStr::Ascii("titty"),
        dictgen::InsensitiveStr::Ascii("tuum"),
    ],
    values: &[
        &["quantify"],
        &["quantities"],
        &["quantified"],
        &["quantities"],
        &["quantity"],
        &["qualification", "quantification"],
        &["qualified", "quantified"],
        &["qualifies", "quantifies"],
        &["qualify", "quantify"],
        &["quantities"],
        &["quantitative"],
        &["quantity"],
        &["quantify"],
        &["quantitative"],
        &["quantitative"],
        &["quantities"],
        &["quantities"],
        &["quantitative"],
        &["quantity"],
        &["quantity"],
        &["quantities"],
        &["quantities"],
        &["quantity"],
        &["quantum"],
    ],
    range: 3..=10,
};

static WORD_QUAL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_QUAL_CHILDREN),
    value: None,
};

pub static WORD_QUAL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("fied"),
        dictgen::InsensitiveStr::Ascii("fiiers"),
        dictgen::InsensitiveStr::Ascii("fy"),
        dictgen::InsensitiveStr::Ascii("ifer"),
        dictgen::InsensitiveStr::Ascii("ifiaction"),
        dictgen::InsensitiveStr::Ascii("ifiactions"),
        dictgen::InsensitiveStr::Ascii("ificaiton"),
        dictgen::InsensitiveStr::Ascii("ificaitons"),
        dictgen::InsensitiveStr::Ascii("ificato"),
        dictgen::InsensitiveStr::Ascii("ificaton"),
        dictgen::InsensitiveStr::Ascii("ificatons"),
        dictgen::InsensitiveStr::Ascii("ifieds"),
        dictgen::InsensitiveStr::Ascii("ifierais"),
        dictgen::InsensitiveStr::Ascii("ifieres"),
        dictgen::InsensitiveStr::Ascii("ifiies"),
        dictgen::InsensitiveStr::Ascii("ifiing"),
        dictgen::InsensitiveStr::Ascii("ifikation"),
        dictgen::InsensitiveStr::Ascii("ifires"),
        dictgen::InsensitiveStr::Ascii("ifiy"),
        dictgen::InsensitiveStr::Ascii("ifyers"),
        dictgen::InsensitiveStr::Ascii("itification"),
        dictgen::InsensitiveStr::Ascii("itifications"),
        dictgen::InsensitiveStr::Ascii("itying"),
        dictgen::InsensitiveStr::Ascii("titative"),
    ],
    values: &[
        &["qualified"],
        &["qualifiers"],
        &["qualify"],
        &["qualifier"],
        &["qualification"],
        &["qualification"],
        &["qualifications"],
        &["qualifications"],
        &["qualification"],
        &["qualification"],
        &["qualifications"],
        &["qualifies"],
        &["qualifiers"],
        &["qualifiers"],
        &["qualifiers"],
        &["qualifying"],
        &["qualification"],
        &["qualifiers"],
        &["qualify"],
        &["qualifiers"],
        &["qualification"],
        &["qualifications"],
        &["qualifying"],
        &["quantitative"],
    ],
    range: 2..=12,
};

static WORD_QUAI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_QUAI_CHILDREN),
    value: None,
};

pub static WORD_QUAI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("lfiers"),
        dictgen::InsensitiveStr::Ascii("lfy"),
        dictgen::InsensitiveStr::Ascii("lified"),
        dictgen::InsensitiveStr::Ascii("lty"),
    ],
    values: &[&["qualifiers"], &["qualify"], &["qualified"], &["quality"]],
    range: 3..=6,
};

static WORD_QUAF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_QUAF_CHILDREN),
    value: None,
};

pub static WORD_QUAF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eur"),
        dictgen::InsensitiveStr::Ascii("eured"),
    ],
    values: &[&["coiffure"], &["coiffured"]],
    range: 3..=5,
};

static WORD_QUAD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_QUAD_CHILDREN),
    value: None,
};

pub static WORD_QUAD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ddec"),
        dictgen::InsensitiveStr::Ascii("ranle"),
        dictgen::InsensitiveStr::Ascii("raped"),
        dictgen::InsensitiveStr::Ascii("rapedal"),
        dictgen::InsensitiveStr::Ascii("rapeds"),
        dictgen::InsensitiveStr::Ascii("roople"),
        dictgen::InsensitiveStr::Ascii("roopled"),
        dictgen::InsensitiveStr::Ascii("rooples"),
        dictgen::InsensitiveStr::Ascii("roopling"),
    ],
    values: &[
        &["quaddec"],
        &["quadrangle"],
        &["quadruped"],
        &["quadrupedal"],
        &["quadrupeds"],
        &["quadruple"],
        &["quadrupled"],
        &["quadruples"],
        &["quadrupling"],
    ],
    range: 4..=8,
};

static WORD_QT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_QT_CHILDREN),
    value: None,
};

pub static WORD_QT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("uie")],
    values: &[&["quite", "quiet"]],
    range: 3..=3,
};

static WORD_QO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_QO_CHILDREN),
    value: None,
};

pub static WORD_QO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ute"),
        dictgen::InsensitiveStr::Ascii("uted"),
        dictgen::InsensitiveStr::Ascii("utes"),
        dictgen::InsensitiveStr::Ascii("uting"),
    ],
    values: &[&["quote"], &["quoted"], &["quotes"], &["quoting"]],
    range: 3..=5,
};

static WORD_QI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_QI_CHILDREN),
    value: None,
};

pub static WORD_QI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("est"),
        dictgen::InsensitiveStr::Ascii("ests"),
        dictgen::InsensitiveStr::Ascii("th"),
    ],
    values: &[&["quest"], &["quests"], &["with"]],
    range: 2..=4,
};

static WORD_QH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_QH_CHILDREN),
    value: None,
};

pub static WORD_QH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ich")],
    values: &[&["quiche", "which"]],
    range: 3..=3,
};

static WORD_QE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_QE_CHILDREN),
    value: None,
};

pub static WORD_QE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("st"),
        dictgen::InsensitiveStr::Ascii("sts"),
        dictgen::InsensitiveStr::Ascii("uest"),
        dictgen::InsensitiveStr::Ascii("uests"),
        dictgen::InsensitiveStr::Ascii("ueue"),
        dictgen::InsensitiveStr::Ascii("ust"),
        dictgen::InsensitiveStr::Ascii("usts"),
    ],
    values: &[
        &["quest"],
        &["quests"],
        &["quest"],
        &["quests"],
        &["queue"],
        &["quest"],
        &["quests"],
    ],
    range: 2..=5,
};

static WORD_QA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_QA_CHILDREN),
    value: None,
};

pub static WORD_QA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ulification"),
        dictgen::InsensitiveStr::Ascii("ulifications"),
        dictgen::InsensitiveStr::Ascii("ulifiers"),
        dictgen::InsensitiveStr::Ascii("ulifies"),
        dictgen::InsensitiveStr::Ascii("ulify"),
        dictgen::InsensitiveStr::Ascii("ulity"),
        dictgen::InsensitiveStr::Ascii("untity"),
        dictgen::InsensitiveStr::Ascii("untum"),
        dictgen::InsensitiveStr::Ascii("urterback"),
    ],
    values: &[
        &["qualification"],
        &["qualification"],
        &["qualifiers"],
        &["qualifies"],
        &["qualify"],
        &["quality"],
        &["quantity"],
        &["quantum"],
        &["quarterback"],
    ],
    range: 5..=12,
};

static WORD_P_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_P_CHILDREN),
    value: None,
};

static WORD_P_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_PA_NODE),
    Some(&WORD_PB_NODE),
    None,
    None,
    Some(&WORD_PE_NODE),
    None,
    None,
    Some(&WORD_PH_NODE),
    Some(&WORD_PI_NODE),
    None,
    Some(&WORD_PK_NODE),
    Some(&WORD_PL_NODE),
    None,
    Some(&WORD_PN_NODE),
    Some(&WORD_PO_NODE),
    Some(&WORD_PP_NODE),
    None,
    Some(&WORD_PR_NODE),
    Some(&WORD_PS_NODE),
    Some(&WORD_PT_NODE),
    Some(&WORD_PU_NODE),
    None,
    Some(&WORD_PW_NODE),
    Some(&WORD_PX_NODE),
    Some(&WORD_PY_NODE),
    None,
];

static WORD_PY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PY_CHILDREN),
    value: None,
};

pub static WORD_PY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("armid"),
        dictgen::InsensitiveStr::Ascii("hon"),
        dictgen::InsensitiveStr::Ascii("hsical"),
        dictgen::InsensitiveStr::Ascii("hsically"),
        dictgen::InsensitiveStr::Ascii("hsicals"),
        dictgen::InsensitiveStr::Ascii("hsicaly"),
        dictgen::InsensitiveStr::Ascii("hthon"),
        dictgen::InsensitiveStr::Ascii("hton"),
        dictgen::InsensitiveStr::Ascii("ramidas"),
        dictgen::InsensitiveStr::Ascii("ramide"),
        dictgen::InsensitiveStr::Ascii("ramides"),
        dictgen::InsensitiveStr::Ascii("ramind"),
        dictgen::InsensitiveStr::Ascii("ramis"),
        dictgen::InsensitiveStr::Ascii("rhon"),
        dictgen::InsensitiveStr::Ascii("rimads"),
        dictgen::InsensitiveStr::Ascii("rmaid"),
        dictgen::InsensitiveStr::Ascii("rmaids"),
        dictgen::InsensitiveStr::Ascii("sched"),
        dictgen::InsensitiveStr::Ascii("schedelic"),
        dictgen::InsensitiveStr::Ascii("schedelics"),
        dictgen::InsensitiveStr::Ascii("schiatric"),
        dictgen::InsensitiveStr::Ascii("schiatrist"),
        dictgen::InsensitiveStr::Ascii("schiatrists"),
        dictgen::InsensitiveStr::Ascii("schological"),
        dictgen::InsensitiveStr::Ascii("schologically"),
        dictgen::InsensitiveStr::Ascii("schologist"),
        dictgen::InsensitiveStr::Ascii("schologists"),
        dictgen::InsensitiveStr::Ascii("schology"),
        dictgen::InsensitiveStr::Ascii("schopath"),
        dictgen::InsensitiveStr::Ascii("schopathic"),
        dictgen::InsensitiveStr::Ascii("schopaths"),
        dictgen::InsensitiveStr::Ascii("schosis"),
        dictgen::InsensitiveStr::Ascii("schotic"),
        dictgen::InsensitiveStr::Ascii("scic"),
        dictgen::InsensitiveStr::Ascii("sical"),
        dictgen::InsensitiveStr::Ascii("sically"),
        dictgen::InsensitiveStr::Ascii("sics"),
        dictgen::InsensitiveStr::Ascii("thin"),
        dictgen::InsensitiveStr::Ascii("thjon"),
        dictgen::InsensitiveStr::Ascii("tho"),
        dictgen::InsensitiveStr::Ascii("thong"),
        dictgen::InsensitiveStr::Ascii("thonl"),
        dictgen::InsensitiveStr::Ascii("tnon"),
        dictgen::InsensitiveStr::Ascii("tohn"),
        dictgen::InsensitiveStr::Ascii("ton"),
        dictgen::InsensitiveStr::Ascii("tyon"),
    ],
    values: &[
        &["pyramid"],
        &["python"],
        &["physical"],
        &["physically"],
        &["physicals"],
        &["physically"],
        &["python"],
        &["python"],
        &["pyramids"],
        &["pyramid"],
        &["pyramids"],
        &["pyramid"],
        &["pyramids"],
        &["python"],
        &["pyramids"],
        &["pyramid"],
        &["pyramids"],
        &["psyched"],
        &["psychedelic"],
        &["psychedelics"],
        &["psychiatric"],
        &["psychiatrist"],
        &["psychiatrists"],
        &["psychological"],
        &["psychologically"],
        &["psychologist"],
        &["psychologists"],
        &["psychology"],
        &["psychopath"],
        &["psychopathic"],
        &["psychopaths"],
        &["psychosis"],
        &["psychotic"],
        &["psychic"],
        &["physical"],
        &["physically"],
        &["physics"],
        &["python"],
        &["python"],
        &["python"],
        &["python"],
        &["python"],
        &["python"],
        &["python"],
        &["python"],
        &["python"],
    ],
    range: 3..=13,
};

static WORD_PX_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PX_CHILDREN),
    value: None,
};

pub static WORD_PX_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("oxied"),
        dictgen::InsensitiveStr::Ascii("oxies"),
        dictgen::InsensitiveStr::Ascii("oxy"),
    ],
    values: &[&["proxied"], &["proxies"], &["proxy"]],
    range: 3..=5,
};

static WORD_PW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PW_CHILDREN),
    value: None,
};

pub static WORD_PW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("oer")],
    values: &[&["power"]],
    range: 3..=3,
};

static WORD_PU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_PU_CHILDREN),
    value: None,
};

static WORD_PU_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_PUA_NODE),
    Some(&WORD_PUB_NODE),
    Some(&WORD_PUC_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_PUH_NODE),
    Some(&WORD_PUI_NODE),
    None,
    None,
    Some(&WORD_PUL_NODE),
    Some(&WORD_PUM_NODE),
    Some(&WORD_PUN_NODE),
    None,
    Some(&WORD_PUP_NODE),
    None,
    Some(&WORD_PUR_NODE),
    Some(&WORD_PUS_NODE),
    Some(&WORD_PUT_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_PUT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PUT_CHILDREN),
    value: None,
};

pub static WORD_PUT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("pose"),
        dictgen::InsensitiveStr::Ascii("posed"),
        dictgen::InsensitiveStr::Ascii("poses"),
    ],
    values: &[&["putting"], &["purpose"], &["purposed"], &["purposes"]],
    range: 3..=5,
};

static WORD_PUS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PUS_CHILDREN),
    value: None,
};

pub static WORD_PUS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("blishing"),
        dictgen::InsensitiveStr::Ascii("ehd"),
        dictgen::InsensitiveStr::Ascii("hpus"),
        dictgen::InsensitiveStr::Ascii("usading"),
    ],
    values: &[&["publishing"], &["pushed"], &["pushups"], &["persuading"]],
    range: 3..=8,
};

static WORD_PUR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PUR_CHILDREN),
    value: None,
};

pub static WORD_PUR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("agtory"),
        dictgen::InsensitiveStr::Ascii("cahed"),
        dictgen::InsensitiveStr::Ascii("cahse"),
        dictgen::InsensitiveStr::Ascii("cahsed"),
        dictgen::InsensitiveStr::Ascii("cahses"),
        dictgen::InsensitiveStr::Ascii("chacing"),
        dictgen::InsensitiveStr::Ascii("chaseing"),
        dictgen::InsensitiveStr::Ascii("chashing"),
        dictgen::InsensitiveStr::Ascii("gable"),
        dictgen::InsensitiveStr::Ascii("gest"),
        dictgen::InsensitiveStr::Ascii("hcase"),
        dictgen::InsensitiveStr::Ascii("hcased"),
        dictgen::InsensitiveStr::Ascii("itannical"),
        dictgen::InsensitiveStr::Ascii("pendicular"),
        dictgen::InsensitiveStr::Ascii("petrators"),
        dictgen::InsensitiveStr::Ascii("petuating"),
        dictgen::InsensitiveStr::Ascii("polsion"),
        dictgen::InsensitiveStr::Ascii("posedly"),
        dictgen::InsensitiveStr::Ascii("posefuly"),
        dictgen::InsensitiveStr::Ascii("poselly"),
        dictgen::InsensitiveStr::Ascii("posley"),
        dictgen::InsensitiveStr::Ascii("potedly"),
        dictgen::InsensitiveStr::Ascii("pse"),
        dictgen::InsensitiveStr::Ascii("pusefully"),
        dictgen::InsensitiveStr::Ascii("siut"),
        dictgen::InsensitiveStr::Ascii("suade"),
        dictgen::InsensitiveStr::Ascii("suaded"),
        dictgen::InsensitiveStr::Ascii("suades"),
        dictgen::InsensitiveStr::Ascii("sude"),
        dictgen::InsensitiveStr::Ascii("tain"),
        dictgen::InsensitiveStr::Ascii("tained"),
        dictgen::InsensitiveStr::Ascii("taining"),
        dictgen::InsensitiveStr::Ascii("tains"),
        dictgen::InsensitiveStr::Ascii("used"),
    ],
    values: &[
        &["purgatory"],
        &["purchased"],
        &["purchase"],
        &["purchased"],
        &["purchases"],
        &["purchasing"],
        &["purchasing"],
        &["purchasing"],
        &["purgeable"],
        &["purges"],
        &["purchase"],
        &["purchased"],
        &["puritanical"],
        &["perpendicular"],
        &["perpetrators"],
        &["perpetuating"],
        &["propulsion"],
        &["purposely"],
        &["purposefully"],
        &["purposely"],
        &["purposely"],
        &["purportedly"],
        &["purpose"],
        &["purposefully"],
        &["pursuit"],
        &["persuade"],
        &["persuaded"],
        &["persuades"],
        &["pursued"],
        &["pertain"],
        &["pertained"],
        &["pertaining"],
        &["pertains"],
        &["pursued"],
    ],
    range: 3..=10,
};

static WORD_PUP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PUP_CHILDREN),
    value: None,
};

pub static WORD_PUP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("lar"),
        dictgen::InsensitiveStr::Ascii("larity"),
        dictgen::InsensitiveStr::Ascii("late"),
        dictgen::InsensitiveStr::Ascii("lated"),
        dictgen::InsensitiveStr::Ascii("lates"),
        dictgen::InsensitiveStr::Ascii("lating"),
        dictgen::InsensitiveStr::Ascii("lation"),
        dictgen::InsensitiveStr::Ascii("lications"),
        dictgen::InsensitiveStr::Ascii("lisher"),
        dictgen::InsensitiveStr::Ascii("ose"),
        dictgen::InsensitiveStr::Ascii("oses"),
        dictgen::InsensitiveStr::Ascii("ulated"),
    ],
    values: &[
        &["popular"],
        &["popularity"],
        &["populate"],
        &["populated"],
        &["populates"],
        &["populating"],
        &["population"],
        &["publications"],
        &["publisher"],
        &["purpose"],
        &["purposes"],
        &["populated"],
    ],
    range: 3..=9,
};

static WORD_PUN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PUN_CHILDREN),
    value: None,
};

pub static WORD_PUN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ctation"),
        dictgen::InsensitiveStr::Ascii("ctiation"),
        dictgen::InsensitiveStr::Ascii("cutation"),
        dictgen::InsensitiveStr::Ascii("dent"),
        dictgen::InsensitiveStr::Ascii("dents"),
        dictgen::InsensitiveStr::Ascii("ihsment"),
        dictgen::InsensitiveStr::Ascii("ishemnt"),
        dictgen::InsensitiveStr::Ascii("ishible"),
        dictgen::InsensitiveStr::Ascii("ishmet"),
        dictgen::InsensitiveStr::Ascii("ishmnet"),
        dictgen::InsensitiveStr::Ascii("ishs"),
        dictgen::InsensitiveStr::Ascii("issable"),
        dictgen::InsensitiveStr::Ascii("isse"),
        dictgen::InsensitiveStr::Ascii("shier"),
        dictgen::InsensitiveStr::Ascii("shiments"),
        dictgen::InsensitiveStr::Ascii("sihable"),
        dictgen::InsensitiveStr::Ascii("siher"),
        dictgen::InsensitiveStr::Ascii("sihes"),
        dictgen::InsensitiveStr::Ascii("sihments"),
    ],
    values: &[
        &["punctuation"],
        &["punctuation"],
        &["punctuation"],
        &["pundit"],
        &["pundits"],
        &["punishments"],
        &["punishments"],
        &["punishable"],
        &["punishments"],
        &["punishments"],
        &["punishes"],
        &["punishable"],
        &["punishes"],
        &["punisher"],
        &["punishments"],
        &["punishable"],
        &["punisher"],
        &["punishes"],
        &["punishments"],
    ],
    range: 4..=8,
};

static WORD_PUM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PUM_CHILDREN),
    value: None,
};

pub static WORD_PUM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("kin"),
        dictgen::InsensitiveStr::Ascii("kpins"),
        dictgen::InsensitiveStr::Ascii("pinks"),
        dictgen::InsensitiveStr::Ascii("pknis"),
    ],
    values: &[&["pumpkin"], &["pumpkins"], &["pumpkins"], &["pumpkins"]],
    range: 3..=5,
};

static WORD_PUL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PUL_CHILDREN),
    value: None,
};

pub static WORD_PUL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ic"),
        dictgen::InsensitiveStr::Ascii("isher"),
        dictgen::InsensitiveStr::Ascii("s"),
    ],
    values: &[&["public"], &["publisher"], &["pulse", "plus"]],
    range: 1..=5,
};

static WORD_PUI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PUI_CHILDREN),
    value: None,
};

pub static WORD_PUI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("nsher")],
    values: &[&["punisher"]],
    range: 5..=5,
};

static WORD_PUH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PUH_CHILDREN),
    value: None,
};

pub static WORD_PUH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("sups")],
    values: &[&["pushups"]],
    range: 4..=4,
};

static WORD_PUC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PUC_CHILDREN),
    value: None,
};

pub static WORD_PUC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("h"),
        dictgen::InsensitiveStr::Ascii("hasing"),
        dictgen::InsensitiveStr::Ascii("ini"),
    ],
    values: &[&["push"], &["purchasing"], &["puccini"]],
    range: 1..=6,
};

static WORD_PUB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_PUB_CHILDREN),
    value: None,
};

static WORD_PUB_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_PUBI_NODE),
    None,
    None,
    Some(&WORD_PUBL_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_PUBL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PUBL_CHILDREN),
    value: None,
};

pub static WORD_PUBL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("c"),
        dictgen::InsensitiveStr::Ascii("cation"),
        dictgen::InsensitiveStr::Ascii("cise"),
        dictgen::InsensitiveStr::Ascii("cize"),
        dictgen::InsensitiveStr::Ascii("iaher"),
        dictgen::InsensitiveStr::Ascii("ically"),
        dictgen::InsensitiveStr::Ascii("icaly"),
        dictgen::InsensitiveStr::Ascii("icani"),
        dictgen::InsensitiveStr::Ascii("ich"),
        dictgen::InsensitiveStr::Ascii("iched"),
        dictgen::InsensitiveStr::Ascii("icher"),
        dictgen::InsensitiveStr::Ascii("ichers"),
        dictgen::InsensitiveStr::Ascii("iches"),
        dictgen::InsensitiveStr::Ascii("iching"),
        dictgen::InsensitiveStr::Ascii("icitan"),
        dictgen::InsensitiveStr::Ascii("ick"),
        dictgen::InsensitiveStr::Ascii("iclly"),
        dictgen::InsensitiveStr::Ascii("icy"),
        dictgen::InsensitiveStr::Ascii("ihsed"),
        dictgen::InsensitiveStr::Ascii("ihser"),
        dictgen::InsensitiveStr::Ascii("ikation"),
        dictgen::InsensitiveStr::Ascii("ised"),
        dictgen::InsensitiveStr::Ascii("isehd"),
        dictgen::InsensitiveStr::Ascii("isehr"),
        dictgen::InsensitiveStr::Ascii("isehrs"),
        dictgen::InsensitiveStr::Ascii("iser"),
        dictgen::InsensitiveStr::Ascii("isers"),
        dictgen::InsensitiveStr::Ascii("isged"),
        dictgen::InsensitiveStr::Ascii("isger"),
        dictgen::InsensitiveStr::Ascii("isgers"),
        dictgen::InsensitiveStr::Ascii("ishd"),
        dictgen::InsensitiveStr::Ascii("isheed"),
        dictgen::InsensitiveStr::Ascii("isherr"),
        dictgen::InsensitiveStr::Ascii("ishher"),
        dictgen::InsensitiveStr::Ascii("ishor"),
        dictgen::InsensitiveStr::Ascii("ishr"),
        dictgen::InsensitiveStr::Ascii("ishre"),
        dictgen::InsensitiveStr::Ascii("ishrs"),
        dictgen::InsensitiveStr::Ascii("ising"),
        dictgen::InsensitiveStr::Ascii("issher"),
        dictgen::InsensitiveStr::Ascii("lisher"),
        dictgen::InsensitiveStr::Ascii("sh"),
        dictgen::InsensitiveStr::Ascii("shed"),
        dictgen::InsensitiveStr::Ascii("sher"),
        dictgen::InsensitiveStr::Ascii("shers"),
        dictgen::InsensitiveStr::Ascii("shing"),
        dictgen::InsensitiveStr::Ascii("sih"),
        dictgen::InsensitiveStr::Ascii("sihed"),
        dictgen::InsensitiveStr::Ascii("siher"),
        dictgen::InsensitiveStr::Ascii("sihers"),
        dictgen::InsensitiveStr::Ascii("sihes"),
        dictgen::InsensitiveStr::Ascii("sihing"),
        dictgen::InsensitiveStr::Ascii("uc"),
        dictgen::InsensitiveStr::Ascii("ucation"),
        dictgen::InsensitiveStr::Ascii("ush"),
        dictgen::InsensitiveStr::Ascii("usher"),
        dictgen::InsensitiveStr::Ascii("ushers"),
        dictgen::InsensitiveStr::Ascii("ushes"),
        dictgen::InsensitiveStr::Ascii("ushing"),
    ],
    values: &[
        &["public", "pubic"],
        &["publication"],
        &["publicise"],
        &["publicize"],
        &["publisher"],
        &["publicly"],
        &["publicly"],
        &["publication"],
        &["publish", "public"],
        &["published"],
        &["publisher"],
        &["publishers"],
        &["publishes"],
        &["publishing"],
        &["publication"],
        &["public"],
        &["publicly"],
        &["publicly"],
        &["published"],
        &["publisher"],
        &["publication"],
        &["published"],
        &["published"],
        &["publisher"],
        &["publishers"],
        &["publisher"],
        &["publishers"],
        &["published"],
        &["publisher"],
        &["publishers"],
        &["published"],
        &["published"],
        &["publisher"],
        &["publisher"],
        &["publisher"],
        &["publisher"],
        &["publisher"],
        &["publishers"],
        &["publishing"],
        &["publisher"],
        &["publisher"],
        &["publish"],
        &["published"],
        &["publisher"],
        &["publishers"],
        &["publishing"],
        &["publish"],
        &["published"],
        &["publisher"],
        &["publishers"],
        &["publishes"],
        &["publishing"],
        &["public"],
        &["publication"],
        &["publish"],
        &["publisher"],
        &["publishers"],
        &["publishes"],
        &["publishing"],
    ],
    range: 1..=7,
};

static WORD_PUBI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PUBI_CHILDREN),
    value: None,
};

pub static WORD_PUBI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("lsh"),
        dictgen::InsensitiveStr::Ascii("lshed"),
        dictgen::InsensitiveStr::Ascii("lsher"),
        dictgen::InsensitiveStr::Ascii("lshers"),
        dictgen::InsensitiveStr::Ascii("lshing"),
        dictgen::InsensitiveStr::Ascii("sh"),
        dictgen::InsensitiveStr::Ascii("shed"),
        dictgen::InsensitiveStr::Ascii("sher"),
        dictgen::InsensitiveStr::Ascii("shers"),
        dictgen::InsensitiveStr::Ascii("shing"),
    ],
    values: &[
        &["publish"],
        &["published"],
        &["publisher"],
        &["publishers"],
        &["publishing"],
        &["publish"],
        &["published"],
        &["publisher"],
        &["publishers"],
        &["publishing"],
    ],
    range: 2..=6,
};

static WORD_PUA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PUA_CHILDREN),
    value: None,
};

pub static WORD_PUA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("sing")],
    values: &[&["pausing"]],
    range: 4..=4,
};

static WORD_PT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PT_CHILDREN),
    value: None,
};

pub static WORD_PT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("d"),
        dictgen::InsensitiveStr::Ascii("herad"),
        dictgen::InsensitiveStr::Ascii("herads"),
        dictgen::InsensitiveStr::Ascii("hon"),
        dictgen::InsensitiveStr::Ascii("hred"),
        dictgen::InsensitiveStr::Ascii("hreds"),
        dictgen::InsensitiveStr::Ascii("iched"),
        dictgen::InsensitiveStr::Ascii("icher"),
        dictgen::InsensitiveStr::Ascii("ichers"),
        dictgen::InsensitiveStr::Ascii("ichfork"),
        dictgen::InsensitiveStr::Ascii("ichforks"),
        dictgen::InsensitiveStr::Ascii("orions"),
        dictgen::InsensitiveStr::Ascii("rss"),
        dictgen::InsensitiveStr::Ascii("yhon"),
    ],
    values: &[
        &["pdf"],
        &["pthread"],
        &["pthreads"],
        &["python"],
        &["pthread"],
        &["pthreads"],
        &["pitched"],
        &["pitcher"],
        &["pitchers"],
        &["pitchfork"],
        &["pitchforks"],
        &["portions"],
        &["press"],
        &["python"],
    ],
    range: 1..=8,
};

static WORD_PS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_PS_CHILDREN),
    value: None,
};

static WORD_PS_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_PSA_NODE),
    None,
    Some(&WORD_PSC_NODE),
    None,
    Some(&WORD_PSE_NODE),
    None,
    None,
    Some(&WORD_PSH_NODE),
    Some(&WORD_PSI_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_PSO_NODE),
    None,
    None,
    Some(&WORD_PSR_NODE),
    Some(&WORD_PSS_NODE),
    None,
    Some(&WORD_PSU_NODE),
    None,
    None,
    None,
    Some(&WORD_PSY_NODE),
    None,
];

static WORD_PSY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PSY_CHILDREN),
    value: None,
};

pub static WORD_PSY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("chadelic"),
        dictgen::InsensitiveStr::Ascii("chaitric"),
        dictgen::InsensitiveStr::Ascii("chaitrist"),
        dictgen::InsensitiveStr::Ascii("chaitrists"),
        dictgen::InsensitiveStr::Ascii("chedelicious"),
        dictgen::InsensitiveStr::Ascii("chedelicness"),
        dictgen::InsensitiveStr::Ascii("chedellic"),
        dictgen::InsensitiveStr::Ascii("chedellics"),
        dictgen::InsensitiveStr::Ascii("chedilic"),
        dictgen::InsensitiveStr::Ascii("chedilics"),
        dictgen::InsensitiveStr::Ascii("chedleic"),
        dictgen::InsensitiveStr::Ascii("chedlic"),
        dictgen::InsensitiveStr::Ascii("chemedics"),
        dictgen::InsensitiveStr::Ascii("chiatic"),
        dictgen::InsensitiveStr::Ascii("chiatirst"),
        dictgen::InsensitiveStr::Ascii("chiatist"),
        dictgen::InsensitiveStr::Ascii("chiatrics"),
        dictgen::InsensitiveStr::Ascii("chiatrict"),
        dictgen::InsensitiveStr::Ascii("chiatrisch"),
        dictgen::InsensitiveStr::Ascii("chiatrits"),
        dictgen::InsensitiveStr::Ascii("chidelic"),
        dictgen::InsensitiveStr::Ascii("chistrist"),
        dictgen::InsensitiveStr::Ascii("chodelic"),
        dictgen::InsensitiveStr::Ascii("chodelics"),
        dictgen::InsensitiveStr::Ascii("choligical"),
        dictgen::InsensitiveStr::Ascii("choligically"),
        dictgen::InsensitiveStr::Ascii("choligist"),
        dictgen::InsensitiveStr::Ascii("choligists"),
        dictgen::InsensitiveStr::Ascii("chologial"),
        dictgen::InsensitiveStr::Ascii("chologicaly"),
        dictgen::InsensitiveStr::Ascii("chologits"),
        dictgen::InsensitiveStr::Ascii("chologycal"),
        dictgen::InsensitiveStr::Ascii("chologyst"),
        dictgen::InsensitiveStr::Ascii("chologysts"),
        dictgen::InsensitiveStr::Ascii("choloog"),
        dictgen::InsensitiveStr::Ascii("chopaat"),
        dictgen::InsensitiveStr::Ascii("chopants"),
        dictgen::InsensitiveStr::Ascii("chopatch"),
        dictgen::InsensitiveStr::Ascii("chopathes"),
        dictgen::InsensitiveStr::Ascii("chopathische"),
        dictgen::InsensitiveStr::Ascii("chopatic"),
        dictgen::InsensitiveStr::Ascii("chopats"),
        dictgen::InsensitiveStr::Ascii("chotisch"),
        dictgen::InsensitiveStr::Ascii("chriatic"),
        dictgen::InsensitiveStr::Ascii("chyatrist"),
        dictgen::InsensitiveStr::Ascii("chyatrists"),
        dictgen::InsensitiveStr::Ascii("cology"),
        dictgen::InsensitiveStr::Ascii("cothic"),
        dictgen::InsensitiveStr::Ascii("donym"),
        dictgen::InsensitiveStr::Ascii("donymity"),
        dictgen::InsensitiveStr::Ascii("donymous"),
        dictgen::InsensitiveStr::Ascii("donyms"),
        dictgen::InsensitiveStr::Ascii("hic"),
        dictgen::InsensitiveStr::Ascii("siological"),
    ],
    values: &[
        &["psychedelic"],
        &["psychiatric"],
        &["psychiatrist"],
        &["psychiatrists"],
        &["psychedelics"],
        &["psychedelics"],
        &["psychedelic"],
        &["psychedelics"],
        &["psychedelic"],
        &["psychedelics"],
        &["psychedelics"],
        &["psychedelic"],
        &["psychedelics"],
        &["psychiatric"],
        &["psychiatrists"],
        &["psychiatrist"],
        &["psychiatrist"],
        &["psychiatrist"],
        &["psychiatric"],
        &["psychiatrists"],
        &["psychedelic"],
        &["psychiatrist"],
        &["psychedelic"],
        &["psychedelics"],
        &["psychological"],
        &["psychologically"],
        &["psychologist"],
        &["psychologists"],
        &["psychological"],
        &["psychologically"],
        &["psychologists"],
        &["psychologically"],
        &["psychologist"],
        &["psychologists"],
        &["psychology"],
        &["psychopath"],
        &["psychopaths"],
        &["psychopath"],
        &["psychopaths"],
        &["psychopathic"],
        &["psychopathic"],
        &["psychopaths"],
        &["psychotic"],
        &["psychiatric"],
        &["psychiatrist"],
        &["psychiatrists"],
        &["psychology"],
        &["psychotic"],
        &["pseudonym"],
        &["pseudonymity"],
        &["pseudonymous"],
        &["pseudonyms"],
        &["psychic"],
        &["physiological"],
    ],
    range: 3..=12,
};

static WORD_PSU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PSU_CHILDREN),
    value: None,
};

pub static WORD_PSU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("do"),
        dictgen::InsensitiveStr::Ascii("docode"),
        dictgen::InsensitiveStr::Ascii("doinverse"),
        dictgen::InsensitiveStr::Ascii("donym"),
        dictgen::InsensitiveStr::Ascii("donymity"),
        dictgen::InsensitiveStr::Ascii("donymous"),
        dictgen::InsensitiveStr::Ascii("donyms"),
        dictgen::InsensitiveStr::Ascii("doterminal"),
        dictgen::InsensitiveStr::Ascii("edo"),
        dictgen::InsensitiveStr::Ascii("edocode"),
        dictgen::InsensitiveStr::Ascii("edoinverse"),
        dictgen::InsensitiveStr::Ascii("edolayer"),
        dictgen::InsensitiveStr::Ascii("edoterminal"),
        dictgen::InsensitiveStr::Ascii("eudo"),
        dictgen::InsensitiveStr::Ascii("h"),
    ],
    values: &[
        &["pseudo"],
        &["pseudocode"],
        &["pseudoinverse"],
        &["pseudonym"],
        &["pseudonymity"],
        &["pseudonymous"],
        &["pseudonyms"],
        &["pseudoterminal"],
        &["pseudo"],
        &["pseudocode"],
        &["pseudoinverse"],
        &["pseudolayer"],
        &["pseudoterminal"],
        &["pseudo"],
        &["push"],
    ],
    range: 1..=11,
};

static WORD_PSS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PSS_CHILDREN),
    value: None,
};

pub static WORD_PSS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("ibility"),
    ],
    values: &[&["passed"], &["possibility"]],
    range: 2..=7,
};

static WORD_PSR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PSR_CHILDREN),
    value: None,
};

pub static WORD_PSR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ameter")],
    values: &[&["parameter"]],
    range: 6..=6,
};

static WORD_PSO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PSO_CHILDREN),
    value: None,
};

pub static WORD_PSO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("ts"),
    ],
    values: &[&["post"], &["posts"]],
    range: 1..=2,
};

static WORD_PSI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PSI_CHILDREN),
    value: None,
};

pub static WORD_PSI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("chological"),
        dictgen::InsensitiveStr::Ascii("chologically"),
        dictgen::InsensitiveStr::Ascii("chologist"),
        dictgen::InsensitiveStr::Ascii("toin"),
        dictgen::InsensitiveStr::Ascii("toined"),
        dictgen::InsensitiveStr::Ascii("toins"),
    ],
    values: &[
        &["psychological"],
        &["psychologically"],
        &["psychologist"],
        &["position"],
        &["positioned"],
        &["positions"],
    ],
    range: 4..=12,
};

static WORD_PSH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PSH_CHILDREN),
    value: None,
};

pub static WORD_PSH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("yciatric"),
        dictgen::InsensitiveStr::Ascii("yciatrist"),
        dictgen::InsensitiveStr::Ascii("ycological"),
        dictgen::InsensitiveStr::Ascii("ycologically"),
        dictgen::InsensitiveStr::Ascii("ycologist"),
        dictgen::InsensitiveStr::Ascii("ycologists"),
        dictgen::InsensitiveStr::Ascii("ycology"),
        dictgen::InsensitiveStr::Ascii("ycopath"),
        dictgen::InsensitiveStr::Ascii("ycopathic"),
        dictgen::InsensitiveStr::Ascii("ycopaths"),
        dictgen::InsensitiveStr::Ascii("ycosis"),
        dictgen::InsensitiveStr::Ascii("ycotic"),
    ],
    values: &[
        &["psychiatric"],
        &["psychiatrist"],
        &["psychological"],
        &["psychologically"],
        &["psychologist"],
        &["psychologists"],
        &["psychology"],
        &["psychopath"],
        &["psychopathic"],
        &["psychopaths"],
        &["psychosis"],
        &["psychotic"],
    ],
    range: 6..=12,
};

static WORD_PSE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PSE_CHILDREN),
    value: None,
};

pub static WORD_PSE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("duo"),
        dictgen::InsensitiveStr::Ascii("ude"),
        dictgen::InsensitiveStr::Ascii("udononymous"),
        dictgen::InsensitiveStr::Ascii("udonyn"),
        dictgen::InsensitiveStr::Ascii("udopoential"),
        dictgen::InsensitiveStr::Ascii("udopoentials"),
        dictgen::InsensitiveStr::Ascii("udorinverse"),
    ],
    values: &[
        &["pseudo"],
        &["pseudo"],
        &["pseudonymous"],
        &["pseudonym"],
        &["pseudopotential"],
        &["pseudopotentials"],
        &["pseudoinverse"],
    ],
    range: 3..=12,
};

static WORD_PSC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PSC_CHILDREN),
    value: None,
};

pub static WORD_PSC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("yhed"),
        dictgen::InsensitiveStr::Ascii("yhedelic"),
        dictgen::InsensitiveStr::Ascii("yhiatric"),
        dictgen::InsensitiveStr::Ascii("yhiatrists"),
        dictgen::InsensitiveStr::Ascii("yhological"),
        dictgen::InsensitiveStr::Ascii("yhologically"),
        dictgen::InsensitiveStr::Ascii("yhologist"),
        dictgen::InsensitiveStr::Ascii("yhologists"),
        dictgen::InsensitiveStr::Ascii("yhology"),
        dictgen::InsensitiveStr::Ascii("yhopath"),
        dictgen::InsensitiveStr::Ascii("yhopathic"),
        dictgen::InsensitiveStr::Ascii("yhopaths"),
        dictgen::InsensitiveStr::Ascii("yhotic"),
    ],
    values: &[
        &["psyched"],
        &["psychedelic"],
        &["psychiatric"],
        &["psychiatrists"],
        &["psychological"],
        &["psychologically"],
        &["psychologist"],
        &["psychologists"],
        &["psychology"],
        &["psychopath"],
        &["psychopathic"],
        &["psychopaths"],
        &["psychotic"],
    ],
    range: 4..=12,
};

static WORD_PSA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PSA_CHILDREN),
    value: None,
};

pub static WORD_PSA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ce"),
        dictgen::InsensitiveStr::Ascii("ced"),
        dictgen::InsensitiveStr::Ascii("ces"),
        dictgen::InsensitiveStr::Ascii("cing"),
        dictgen::InsensitiveStr::Ascii("swd"),
    ],
    values: &[
        &["space", "pace"],
        &["paced", "spaced"],
        &["spaces", "paces"],
        &["pacing", "spacing"],
        &["passwd"],
    ],
    range: 2..=4,
};

static WORD_PR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_PR_CHILDREN),
    value: None,
};

static WORD_PR_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_PRA_NODE),
    None,
    Some(&WORD_PRC_NODE),
    Some(&WORD_PRD_NODE),
    Some(&WORD_PRE_NODE),
    Some(&WORD_PRF_NODE),
    Some(&WORD_PRG_NODE),
    None,
    Some(&WORD_PRI_NODE),
    Some(&WORD_PRJ_NODE),
    None,
    None,
    Some(&WORD_PRM_NODE),
    None,
    Some(&WORD_PRO_NODE),
    Some(&WORD_PRP_NODE),
    None,
    Some(&WORD_PRR_NODE),
    Some(&WORD_PRS_NODE),
    Some(&WORD_PRT_NODE),
    Some(&WORD_PRU_NODE),
    Some(&WORD_PRV_NODE),
    None,
    None,
    Some(&WORD_PRY_NODE),
    None,
];

static WORD_PRY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PRY_CHILDREN),
    value: None,
};

pub static WORD_PRY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("amid"),
        dictgen::InsensitiveStr::Ascii("amids"),
    ],
    values: &[&["pyramid"], &["pyramids"]],
    range: 4..=5,
};

static WORD_PRV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PRV_CHILDREN),
    value: None,
};

pub static WORD_PRV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("iate"),
        dictgen::InsensitiveStr::Ascii("ode"),
    ],
    values: &[&["private"], &["provide"]],
    range: 3..=4,
};

static WORD_PRU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PRU_CHILDREN),
    value: None,
};

pub static WORD_PRU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("chase"),
        dictgen::InsensitiveStr::Ascii("chased"),
        dictgen::InsensitiveStr::Ascii("chases"),
        dictgen::InsensitiveStr::Ascii("fe"),
        dictgen::InsensitiveStr::Ascii("gatory"),
        dictgen::InsensitiveStr::Ascii("posefully"),
        dictgen::InsensitiveStr::Ascii("posely"),
        dictgen::InsensitiveStr::Ascii("suit"),
    ],
    values: &[
        &["purchase"],
        &["purchased"],
        &["purchases"],
        &["proof"],
        &["purgatory"],
        &["purposefully"],
        &["purposely"],
        &["pursuit"],
    ],
    range: 2..=9,
};

static WORD_PRT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PRT_CHILDREN),
    value: None,
};

pub static WORD_PRT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("inf")],
    values: &[&["printf"]],
    range: 3..=3,
};

static WORD_PRS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PRS_CHILDREN),
    value: None,
};

pub static WORD_PRS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("et"),
        dictgen::InsensitiveStr::Ascii("ets"),
    ],
    values: &[&["preset"], &["presets"]],
    range: 2..=3,
};

static WORD_PRR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PRR_CHILDREN),
    value: None,
};

pub static WORD_PRR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cision"),
        dictgen::InsensitiveStr::Ascii("ottypes"),
    ],
    values: &[&["precision"], &["prototypes"]],
    range: 6..=7,
};

static WORD_PRP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PRP_CHILDREN),
    value: None,
};

pub static WORD_PRP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eparations"),
        dictgen::InsensitiveStr::Ascii("ose"),
        dictgen::InsensitiveStr::Ascii("osed"),
        dictgen::InsensitiveStr::Ascii("oser"),
        dictgen::InsensitiveStr::Ascii("osers"),
        dictgen::InsensitiveStr::Ascii("oses"),
        dictgen::InsensitiveStr::Ascii("osiing"),
    ],
    values: &[
        &["preparations"],
        &["propose"],
        &["proposed"],
        &["proposer"],
        &["proposers"],
        &["proposes"],
        &["proposing"],
    ],
    range: 3..=10,
};

static WORD_PRO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_PRO_CHILDREN),
    value: None,
};

static WORD_PRO_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_PROA_NODE),
    Some(&WORD_PROB_NODE),
    Some(&WORD_PROC_NODE),
    Some(&WORD_PROD_NODE),
    Some(&WORD_PROE_NODE),
    Some(&WORD_PROF_NODE),
    Some(&WORD_PROG_NODE),
    Some(&WORD_PROH_NODE),
    Some(&WORD_PROI_NODE),
    Some(&WORD_PROJ_NODE),
    Some(&WORD_PROK_NODE),
    Some(&WORD_PROL_NODE),
    Some(&WORD_PROM_NODE),
    Some(&WORD_PRON_NODE),
    Some(&WORD_PROO_NODE),
    Some(&WORD_PROP_NODE),
    None,
    Some(&WORD_PROR_NODE),
    Some(&WORD_PROS_NODE),
    Some(&WORD_PROT_NODE),
    Some(&WORD_PROU_NODE),
    Some(&WORD_PROV_NODE),
    None,
    Some(&WORD_PROX_NODE),
    Some(&WORD_PROY_NODE),
    Some(&WORD_PROZ_NODE),
];

static WORD_PROZ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PROZ_CHILDREN),
    value: None,
};

pub static WORD_PROZ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ess")],
    values: &[&["process"]],
    range: 3..=3,
};

static WORD_PROY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PROY_CHILDREN),
    value: None,
};

pub static WORD_PROY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ect"),
        dictgen::InsensitiveStr::Ascii("ected"),
        dictgen::InsensitiveStr::Ascii("ecting"),
        dictgen::InsensitiveStr::Ascii("ection"),
        dictgen::InsensitiveStr::Ascii("ections"),
        dictgen::InsensitiveStr::Ascii("ects"),
    ],
    values: &[
        &["project", "protect"],
        &["projected", "protected"],
        &["projecting", "protecting"],
        &["projection", "protection"],
        &["projections", "protections"],
        &["projects", "protects"],
    ],
    range: 3..=7,
};

static WORD_PROX_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PROX_CHILDREN),
    value: None,
};

pub static WORD_PROX_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("imty")],
    values: &[&["proximity"]],
    range: 4..=4,
};

static WORD_PROV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_PROV_CHILDREN),
    value: None,
};

static WORD_PROV_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_PROVA_NODE),
    None,
    None,
    Some(&WORD_PROVD_NODE),
    Some(&WORD_PROVE_NODE),
    None,
    None,
    None,
    Some(&WORD_PROVI_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_PROVO_NODE),
    None,
    None,
    None,
    Some(&WORD_PROVS_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_PROVS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PROVS_CHILDREN),
    value: None,
};

pub static WORD_PROVS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ioning")],
    values: &[&["provisioning"]],
    range: 6..=6,
};

static WORD_PROVO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PROVO_CHILDREN),
    value: None,
};

pub static WORD_PROVO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("active"),
        dictgen::InsensitiveStr::Ascii("catie"),
        dictgen::InsensitiveStr::Ascii("catief"),
        dictgen::InsensitiveStr::Ascii("cativley"),
        dictgen::InsensitiveStr::Ascii("citive"),
        dictgen::InsensitiveStr::Ascii("cotive"),
        dictgen::InsensitiveStr::Ascii("de"),
        dictgen::InsensitiveStr::Ascii("ded"),
        dictgen::InsensitiveStr::Ascii("der"),
        dictgen::InsensitiveStr::Ascii("des"),
        dictgen::InsensitiveStr::Ascii("ding"),
        dictgen::InsensitiveStr::Ascii("ds"),
        dictgen::InsensitiveStr::Ascii("kative"),
    ],
    values: &[
        &["provocative"],
        &["provocative"],
        &["provocative"],
        &["provocative"],
        &["provocative"],
        &["provocative"],
        &["provide"],
        &["provided"],
        &["provider"],
        &["provides"],
        &["providing"],
        &["provides"],
        &["provocative"],
    ],
    range: 2..=8,
};

static WORD_PROVI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PROVI_CHILDREN),
    value: None,
};

pub static WORD_PROVI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cative"),
        dictgen::InsensitiveStr::Ascii("cde"),
        dictgen::InsensitiveStr::Ascii("cded"),
        dictgen::InsensitiveStr::Ascii("cdes"),
        dictgen::InsensitiveStr::Ascii("ce"),
        dictgen::InsensitiveStr::Ascii("cial"),
        dictgen::InsensitiveStr::Ascii("d"),
        dictgen::InsensitiveStr::Ascii("dance"),
        dictgen::InsensitiveStr::Ascii("dee"),
        dictgen::InsensitiveStr::Ascii("dencie"),
        dictgen::InsensitiveStr::Ascii("deres"),
        dictgen::InsensitiveStr::Ascii("dewd"),
        dictgen::InsensitiveStr::Ascii("dfers"),
        dictgen::InsensitiveStr::Ascii("dince"),
        dictgen::InsensitiveStr::Ascii("dor"),
        dictgen::InsensitiveStr::Ascii("dors"),
        dictgen::InsensitiveStr::Ascii("ds"),
        dictgen::InsensitiveStr::Ascii("dse"),
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("eded"),
        dictgen::InsensitiveStr::Ascii("edes"),
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("nciaal"),
        dictgen::InsensitiveStr::Ascii("nciae"),
        dictgen::InsensitiveStr::Ascii("ncie"),
        dictgen::InsensitiveStr::Ascii("ncies"),
        dictgen::InsensitiveStr::Ascii("ncija"),
        dictgen::InsensitiveStr::Ascii("ne"),
        dictgen::InsensitiveStr::Ascii("nence"),
        dictgen::InsensitiveStr::Ascii("nical"),
        dictgen::InsensitiveStr::Ascii("nicial"),
        dictgen::InsensitiveStr::Ascii("ntial"),
        dictgen::InsensitiveStr::Ascii("nvial"),
        dictgen::InsensitiveStr::Ascii("sioing"),
        dictgen::InsensitiveStr::Ascii("siones"),
        dictgen::InsensitiveStr::Ascii("siong"),
        dictgen::InsensitiveStr::Ascii("sionging"),
        dictgen::InsensitiveStr::Ascii("sios"),
        dictgen::InsensitiveStr::Ascii("siosn"),
        dictgen::InsensitiveStr::Ascii("sonal"),
        dictgen::InsensitiveStr::Ascii("ve"),
        dictgen::InsensitiveStr::Ascii("ved"),
        dictgen::InsensitiveStr::Ascii("ves"),
        dictgen::InsensitiveStr::Ascii("ving"),
    ],
    values: &[
        &["provocative"],
        &["provide"],
        &["provided"],
        &["provides"],
        &["provide", "province"],
        &["provincial"],
        &["provide", "prove", "proved", "proves"],
        &["providence"],
        &["providence"],
        &["providence"],
        &["providers"],
        &["provided"],
        &["providers"],
        &["providence"],
        &["provider", "providore"],
        &["providers", "providores"],
        &["provides", "proves"],
        &["provides", "provide"],
        &["provide", "prove"],
        &["provide", "provided", "proved"],
        &["provided"],
        &["provides"],
        &["provides", "proves"],
        &["provincial"],
        &["province"],
        &["province"],
        &["province"],
        &["provincial"],
        &["province"],
        &["providence"],
        &["provincial"],
        &["provincial"],
        &["provincial"],
        &["provincial"],
        &["provisioning"],
        &["provisions"],
        &["provisioning"],
        &["provisioning"],
        &["provisions"],
        &["provision"],
        &["provisional"],
        &["provide"],
        &["provided"],
        &["provides"],
        &["providing"],
    ],
    range: 1..=8,
};

static WORD_PROVE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PROVE_CHILDREN),
    value: None,
};

pub static WORD_PROVE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("dd"),
        dictgen::InsensitiveStr::Ascii("nces"),
        dictgen::InsensitiveStr::Ascii("ncial"),
        dictgen::InsensitiveStr::Ascii("rai"),
        dictgen::InsensitiveStr::Ascii("ribal"),
        dictgen::InsensitiveStr::Ascii("rvial"),
    ],
    values: &[
        &["proved", "provided"],
        &["provinces"],
        &["provincial"],
        &["proverbial"],
        &["proverbial"],
        &["proverbial"],
    ],
    range: 2..=5,
};

static WORD_PROVD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PROVD_CHILDREN),
    value: None,
};

pub static WORD_PROVD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("er"),
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("ided"),
        dictgen::InsensitiveStr::Ascii("idet"),
        dictgen::InsensitiveStr::Ascii("ie"),
        dictgen::InsensitiveStr::Ascii("ied"),
        dictgen::InsensitiveStr::Ascii("ies"),
        dictgen::InsensitiveStr::Ascii("ing"),
    ],
    values: &[
        &["provided"],
        &["provider"],
        &["provides"],
        &["provided"],
        &["provided", "provider", "provident"],
        &["provide"],
        &["provided"],
        &["provides"],
        &["providing"],
    ],
    range: 2..=4,
};

static WORD_PROVA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PROVA_CHILDREN),
    value: None,
};

pub static WORD_PROVA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cative"),
        dictgen::InsensitiveStr::Ascii("cotive"),
        dictgen::InsensitiveStr::Ascii("te"),
    ],
    values: &[&["provocative"], &["provocative"], &["private", "provide"]],
    range: 2..=6,
};

static WORD_PROU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PROU_CHILDREN),
    value: None,
};

pub static WORD_PROU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ldy"),
        dictgen::InsensitiveStr::Ascii("ncements"),
    ],
    values: &[&["proudly"], &["pronouncements"]],
    range: 3..=8,
};

static WORD_PROT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_PROT_CHILDREN),
    value: None,
};

static WORD_PROT_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_PROTA_NODE),
    None,
    Some(&WORD_PROTC_NODE),
    None,
    Some(&WORD_PROTE_NODE),
    Some(&WORD_PROTF_NODE),
    None,
    Some(&WORD_PROTH_NODE),
    Some(&WORD_PROTI_NODE),
    None,
    None,
    Some(&WORD_PROTL_NODE),
    None,
    None,
    Some(&WORD_PROTO_NODE),
    None,
    None,
    Some(&WORD_PROTR_NODE),
    None,
    None,
    Some(&WORD_PROTU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_PROTU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PROTU_CHILDREN),
    value: None,
};

pub static WORD_PROTU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("gal"),
        dictgen::InsensitiveStr::Ascii("guese"),
    ],
    values: &[&["portugal"], &["portuguese"]],
    range: 3..=5,
};

static WORD_PROTR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PROTR_CHILDREN),
    value: None,
};

pub static WORD_PROTR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ait"),
        dictgen::InsensitiveStr::Ascii("aits"),
        dictgen::InsensitiveStr::Ascii("ay"),
        dictgen::InsensitiveStr::Ascii("ayal"),
        dictgen::InsensitiveStr::Ascii("ayed"),
        dictgen::InsensitiveStr::Ascii("aying"),
        dictgen::InsensitiveStr::Ascii("ays"),
        dictgen::InsensitiveStr::Ascii("uberance"),
        dictgen::InsensitiveStr::Ascii("uberances"),
    ],
    values: &[
        &["portrait"],
        &["portraits"],
        &["portray"],
        &["portrayal"],
        &["portrayed"],
        &["portraying"],
        &["portrays"],
        &["protuberance"],
        &["protuberances"],
    ],
    range: 2..=9,
};

static WORD_PROTO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PROTO_CHILDREN),
    value: None,
};

pub static WORD_PROTO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cal"),
        dictgen::InsensitiveStr::Ascii("call"),
        dictgen::InsensitiveStr::Ascii("calls"),
        dictgen::InsensitiveStr::Ascii("cals"),
        dictgen::InsensitiveStr::Ascii("cl"),
        dictgen::InsensitiveStr::Ascii("cls"),
        dictgen::InsensitiveStr::Ascii("co"),
        dictgen::InsensitiveStr::Ascii("coles"),
        dictgen::InsensitiveStr::Ascii("coll"),
        dictgen::InsensitiveStr::Ascii("colls"),
        dictgen::InsensitiveStr::Ascii("colos"),
        dictgen::InsensitiveStr::Ascii("cool"),
        dictgen::InsensitiveStr::Ascii("cools"),
        dictgen::InsensitiveStr::Ascii("cos"),
        dictgen::InsensitiveStr::Ascii("ganist"),
        dictgen::InsensitiveStr::Ascii("ganists"),
        dictgen::InsensitiveStr::Ascii("ge"),
        dictgen::InsensitiveStr::Ascii("gonist"),
        dictgen::InsensitiveStr::Ascii("hypes"),
        dictgen::InsensitiveStr::Ascii("l"),
        dictgen::InsensitiveStr::Ascii("ls"),
        dictgen::InsensitiveStr::Ascii("stant"),
        dictgen::InsensitiveStr::Ascii("stants"),
        dictgen::InsensitiveStr::Ascii("tipes"),
        dictgen::InsensitiveStr::Ascii("totype"),
        dictgen::InsensitiveStr::Ascii("tpye"),
        dictgen::InsensitiveStr::Ascii("tpyes"),
        dictgen::InsensitiveStr::Ascii("tye"),
        dictgen::InsensitiveStr::Ascii("tyes"),
        dictgen::InsensitiveStr::Ascii("typs"),
        dictgen::InsensitiveStr::Ascii("ype"),
        dictgen::InsensitiveStr::Ascii("yped"),
        dictgen::InsensitiveStr::Ascii("ypes"),
        dictgen::InsensitiveStr::Ascii("yping"),
        dictgen::InsensitiveStr::Ascii("ytpe"),
        dictgen::InsensitiveStr::Ascii("ytpes"),
    ],
    values: &[
        &["protocol"],
        &["protocol"],
        &["protocols"],
        &["protocols"],
        &["protocol"],
        &["protocols"],
        &["protocol"],
        &["protocols"],
        &["protocol"],
        &["protocols"],
        &["protocols"],
        &["protocol"],
        &["protocols"],
        &["protocols"],
        &["protagonist"],
        &["protagonists"],
        &["protege"],
        &["protagonist"],
        &["prototypes"],
        &["protocol"],
        &["protocols"],
        &["protestant"],
        &["protestants"],
        &["prototypes"],
        &["prototype"],
        &["prototype"],
        &["prototypes"],
        &["prototype"],
        &["prototypes"],
        &["prototypes"],
        &["prototype"],
        &["prototyped"],
        &["prototypes"],
        &["prototyping"],
        &["prototype"],
        &["prototypes"],
    ],
    range: 1..=7,
};

static WORD_PROTL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PROTL_CHILDREN),
    value: None,
};

pub static WORD_PROTL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("et"),
        dictgen::InsensitiveStr::Ascii("ets"),
    ],
    values: &[&["portlet"], &["portlets"]],
    range: 2..=3,
};

static WORD_PROTI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PROTI_CHILDREN),
    value: None,
};

pub static WORD_PROTI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ens"),
        dictgen::InsensitiveStr::Ascii("nes"),
        dictgen::InsensitiveStr::Ascii("stant"),
        dictgen::InsensitiveStr::Ascii("stants"),
    ],
    values: &[
        &["proteins"],
        &["proteins"],
        &["protestant"],
        &["protestants"],
    ],
    range: 3..=6,
};

static WORD_PROTH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PROTH_CHILDREN),
    value: None,
};

pub static WORD_PROTH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("setic")],
    values: &[&["prosthetic"]],
    range: 5..=5,
};

static WORD_PROTF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PROTF_CHILDREN),
    value: None,
};

pub static WORD_PROTF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("olio")],
    values: &[&["portfolio"]],
    range: 4..=4,
};

static WORD_PROTE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PROTE_CHILDREN),
    value: None,
};

pub static WORD_PROTE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ccion"),
        dictgen::InsensitiveStr::Ascii("cion"),
        dictgen::InsensitiveStr::Ascii("citon"),
        dictgen::InsensitiveStr::Ascii("cs"),
        dictgen::InsensitiveStr::Ascii("cte"),
        dictgen::InsensitiveStr::Ascii("ctes"),
        dictgen::InsensitiveStr::Ascii("ctice"),
        dictgen::InsensitiveStr::Ascii("ctie"),
        dictgen::InsensitiveStr::Ascii("ctiei"),
        dictgen::InsensitiveStr::Ascii("ctings"),
        dictgen::InsensitiveStr::Ascii("ctiv"),
        dictgen::InsensitiveStr::Ascii("ctoin"),
        dictgen::InsensitiveStr::Ascii("ctons"),
        dictgen::InsensitiveStr::Ascii("ctoras"),
        dictgen::InsensitiveStr::Ascii("ctores"),
        dictgen::InsensitiveStr::Ascii("ctos"),
        dictgen::InsensitiveStr::Ascii("ctron"),
        dictgen::InsensitiveStr::Ascii("ctrons"),
        dictgen::InsensitiveStr::Ascii("dcted"),
        dictgen::InsensitiveStr::Ascii("en"),
        dictgen::InsensitiveStr::Ascii("inas"),
        dictgen::InsensitiveStr::Ascii("ines"),
        dictgen::InsensitiveStr::Ascii("lariat"),
        dictgen::InsensitiveStr::Ascii("ntial"),
        dictgen::InsensitiveStr::Ascii("ss"),
        dictgen::InsensitiveStr::Ascii("stans"),
        dictgen::InsensitiveStr::Ascii("stantes"),
        dictgen::InsensitiveStr::Ascii("stantisk"),
        dictgen::InsensitiveStr::Ascii("stare"),
        dictgen::InsensitiveStr::Ascii("stas"),
        dictgen::InsensitiveStr::Ascii("stat"),
        dictgen::InsensitiveStr::Ascii("stato"),
        dictgen::InsensitiveStr::Ascii("stent"),
        dictgen::InsensitiveStr::Ascii("stents"),
        dictgen::InsensitiveStr::Ascii("stes"),
        dictgen::InsensitiveStr::Ascii("stina"),
        dictgen::InsensitiveStr::Ascii("stos"),
        dictgen::InsensitiveStr::Ascii("xt"),
    ],
    values: &[
        &["protection"],
        &["protection"],
        &["protections"],
        &["protects"],
        &["protective", "protected", "protect"],
        &["protects"],
        &["protective"],
        &["protective"],
        &["protective"],
        &["protections"],
        &["protective"],
        &["protections", "protection"],
        &["protectors"],
        &["protectors"],
        &["protectors"],
        &["protectors"],
        &["protection"],
        &["protections"],
        &["protected"],
        &["preteen", "protean", "protein"],
        &["proteins"],
        &["proteins"],
        &["proletariat"],
        &["potential"],
        &["protests"],
        &["protests"],
        &["protestants"],
        &["protestants"],
        &["protesters"],
        &["protests"],
        &["protestant"],
        &["protestant"],
        &["protestant"],
        &["protestants"],
        &["protests"],
        &["protestant"],
        &["protests"],
        &["protect"],
    ],
    range: 2..=8,
};

static WORD_PROTC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PROTC_CHILDREN),
    value: None,
};

pub static WORD_PROTC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ol"),
        dictgen::InsensitiveStr::Ascii("ols"),
        dictgen::InsensitiveStr::Ascii("ool"),
        dictgen::InsensitiveStr::Ascii("ools"),
        dictgen::InsensitiveStr::Ascii("ted"),
    ],
    values: &[
        &["protocol"],
        &["protocols"],
        &["protocol"],
        &["protocols"],
        &["protected"],
    ],
    range: 2..=4,
};

static WORD_PROTA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PROTA_CHILDREN),
    value: None,
};

pub static WORD_PROTA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("bility"),
        dictgen::InsensitiveStr::Ascii("ble"),
        dictgen::InsensitiveStr::Ascii("ganist"),
        dictgen::InsensitiveStr::Ascii("ganists"),
        dictgen::InsensitiveStr::Ascii("ginist"),
        dictgen::InsensitiveStr::Ascii("ginists"),
        dictgen::InsensitiveStr::Ascii("ginst"),
        dictgen::InsensitiveStr::Ascii("gnoist"),
        dictgen::InsensitiveStr::Ascii("gnoists"),
        dictgen::InsensitiveStr::Ascii("goinst"),
        dictgen::InsensitiveStr::Ascii("gonistas"),
        dictgen::InsensitiveStr::Ascii("gonistes"),
        dictgen::InsensitiveStr::Ascii("gonits"),
        dictgen::InsensitiveStr::Ascii("gonsit"),
        dictgen::InsensitiveStr::Ascii("ls"),
        dictgen::InsensitiveStr::Ascii("stant"),
    ],
    values: &[
        &["portability", "probability"],
        &["portable"],
        &["protagonist"],
        &["protagonists"],
        &["protagonist"],
        &["protagonists"],
        &["protagonist"],
        &["protagonist"],
        &["protagonists"],
        &["protagonists"],
        &["protagonists"],
        &["protagonists"],
        &["protagonists"],
        &["protagonists"],
        &["portals"],
        &["protestant"],
    ],
    range: 2..=8,
};

static WORD_PROS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PROS_CHILDREN),
    value: None,
};

pub static WORD_PROS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cratination"),
        dictgen::InsensitiveStr::Ascii("ectued"),
        dictgen::InsensitiveStr::Ascii("ectuion"),
        dictgen::InsensitiveStr::Ascii("ectuor"),
        dictgen::InsensitiveStr::Ascii("ectuors"),
        dictgen::InsensitiveStr::Ascii("ecuter"),
        dictgen::InsensitiveStr::Ascii("ecuters"),
        dictgen::InsensitiveStr::Ascii("ecutie"),
        dictgen::InsensitiveStr::Ascii("eletyzing"),
        dictgen::InsensitiveStr::Ascii("epct"),
        dictgen::InsensitiveStr::Ascii("ess"),
        dictgen::InsensitiveStr::Ascii("essor"),
        dictgen::InsensitiveStr::Ascii("icuted"),
        dictgen::InsensitiveStr::Ascii("icution"),
        dictgen::InsensitiveStr::Ascii("icutor"),
        dictgen::InsensitiveStr::Ascii("ocuted"),
        dictgen::InsensitiveStr::Ascii("ocution"),
        dictgen::InsensitiveStr::Ascii("parity"),
        dictgen::InsensitiveStr::Ascii("pectos"),
        dictgen::InsensitiveStr::Ascii("perety"),
        dictgen::InsensitiveStr::Ascii("perious"),
        dictgen::InsensitiveStr::Ascii("peros"),
        dictgen::InsensitiveStr::Ascii("pertity"),
        dictgen::InsensitiveStr::Ascii("pertiy"),
        dictgen::InsensitiveStr::Ascii("pettive"),
        dictgen::InsensitiveStr::Ascii("phetic"),
        dictgen::InsensitiveStr::Ascii("porous"),
        dictgen::InsensitiveStr::Ascii("seses"),
        dictgen::InsensitiveStr::Ascii("tehtic"),
        dictgen::InsensitiveStr::Ascii("terity"),
        dictgen::InsensitiveStr::Ascii("tethic"),
        dictgen::InsensitiveStr::Ascii("tethics"),
        dictgen::InsensitiveStr::Ascii("tetution"),
        dictgen::InsensitiveStr::Ascii("thethic"),
        dictgen::InsensitiveStr::Ascii("tite"),
        dictgen::InsensitiveStr::Ascii("titite"),
        dictgen::InsensitiveStr::Ascii("titites"),
        dictgen::InsensitiveStr::Ascii("titition"),
        dictgen::InsensitiveStr::Ascii("titiute"),
        dictgen::InsensitiveStr::Ascii("tituate"),
        dictgen::InsensitiveStr::Ascii("titucion"),
        dictgen::InsensitiveStr::Ascii("titude"),
        dictgen::InsensitiveStr::Ascii("titudes"),
        dictgen::InsensitiveStr::Ascii("titue"),
        dictgen::InsensitiveStr::Ascii("tituee"),
        dictgen::InsensitiveStr::Ascii("tituees"),
        dictgen::InsensitiveStr::Ascii("tituer"),
        dictgen::InsensitiveStr::Ascii("titues"),
        dictgen::InsensitiveStr::Ascii("tituion"),
        dictgen::InsensitiveStr::Ascii("tituiton"),
        dictgen::InsensitiveStr::Ascii("titure"),
        dictgen::InsensitiveStr::Ascii("titures"),
        dictgen::InsensitiveStr::Ascii("titutas"),
        dictgen::InsensitiveStr::Ascii("titutie"),
        dictgen::InsensitiveStr::Ascii("titutiei"),
        dictgen::InsensitiveStr::Ascii("titutin"),
        dictgen::InsensitiveStr::Ascii("titutke"),
        dictgen::InsensitiveStr::Ascii("tituto"),
        dictgen::InsensitiveStr::Ascii("tituton"),
        dictgen::InsensitiveStr::Ascii("titutos"),
        dictgen::InsensitiveStr::Ascii("tituye"),
    ],
    values: &[
        &["procrastination"],
        &["prosecuted"],
        &["prosecution"],
        &["prosecutor"],
        &["prosecutors"],
        &["prosecutor"],
        &["prosecutors"],
        &["prosecuted"],
        &["proselytizing"],
        &["prospect"],
        &["process"],
        &["processor"],
        &["prosecuted"],
        &["prosecution"],
        &["prosecutor"],
        &["prosecuted"],
        &["prosecution"],
        &["prosperity"],
        &["prospects"],
        &["prosperity"],
        &["prosperous"],
        &["prosperous"],
        &["prosperity"],
        &["prosperity"],
        &["prospective"],
        &["prosthetic"],
        &["prosperous"],
        &["processes", "possesses"],
        &["prosthetic"],
        &["prosperity"],
        &["prosthetic"],
        &["prosthetic"],
        &["prostitution"],
        &["prosthetic"],
        &["prostitute"],
        &["prostitute"],
        &["prostitutes"],
        &["prostitution"],
        &["prostitute"],
        &["prostitute"],
        &["prostitution"],
        &["prostitute"],
        &["prostitutes"],
        &["prostitute"],
        &["prostitute"],
        &["prostitutes"],
        &["prostitute"],
        &["prostitutes"],
        &["prostitution"],
        &["prostitution"],
        &["prostitute"],
        &["prostitutes"],
        &["prostitutes"],
        &["prostitute"],
        &["prostitute"],
        &["prostitution"],
        &["prostitutes"],
        &["prostitution"],
        &["prostitution"],
        &["prostitutes"],
        &["prostitute"],
    ],
    range: 3..=11,
};

static WORD_PROR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PROR_CHILDREN),
    value: None,
};

pub static WORD_PROR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ity"),
        dictgen::InsensitiveStr::Ascii("otype"),
    ],
    values: &[&["priority"], &["prototype"]],
    range: 3..=5,
};

static WORD_PROP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_PROP_CHILDREN),
    value: None,
};

static WORD_PROP_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_PROPA_NODE),
    Some(&WORD_PROPB_NODE),
    None,
    None,
    Some(&WORD_PROPE_NODE),
    None,
    Some(&WORD_PROPG_NODE),
    Some(&WORD_PROPH_NODE),
    Some(&WORD_PROPI_NODE),
    None,
    None,
    Some(&WORD_PROPL_NODE),
    Some(&WORD_PROPM_NODE),
    None,
    Some(&WORD_PROPO_NODE),
    Some(&WORD_PROPP_NODE),
    None,
    Some(&WORD_PROPR_NODE),
    Some(&WORD_PROPS_NODE),
    Some(&WORD_PROPT_NODE),
    Some(&WORD_PROPU_NODE),
    Some(&WORD_PROPV_NODE),
    None,
    None,
    None,
    None,
];

static WORD_PROPV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PROPV_CHILDREN),
    value: None,
};

pub static WORD_PROPV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ider")],
    values: &[&["provider"]],
    range: 4..=4,
};

static WORD_PROPU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PROPU_CHILDREN),
    value: None,
};

pub static WORD_PROPU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("laios"),
        dictgen::InsensitiveStr::Ascii("lsing"),
        dictgen::InsensitiveStr::Ascii("lstion"),
        dictgen::InsensitiveStr::Ascii("ltion"),
        dictgen::InsensitiveStr::Ascii("slion"),
    ],
    values: &[
        &["propulsion"],
        &["propulsion"],
        &["propulsion"],
        &["propulsion"],
        &["propulsion"],
    ],
    range: 5..=6,
};

static WORD_PROPT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PROPT_CHILDREN),
    value: Some(&["prompt"]),
};

pub static WORD_PROPT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eries"),
        dictgen::InsensitiveStr::Ascii("erties"),
        dictgen::InsensitiveStr::Ascii("erty"),
    ],
    values: &[&["properties"], &["properties"], &["property"]],
    range: 4..=6,
};

static WORD_PROPS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PROPS_CHILDREN),
    value: None,
};

pub static WORD_PROPS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("ect"),
        dictgen::InsensitiveStr::Ascii("ective"),
        dictgen::InsensitiveStr::Ascii("ects"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("erity"),
        dictgen::InsensitiveStr::Ascii("erous"),
    ],
    values: &[
        &["propose"],
        &["prospect"],
        &["prospective"],
        &["prospects"],
        &["proposed"],
        &["prosperity"],
        &["prosperous"],
    ],
    range: 1..=6,
};

static WORD_PROPR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PROPR_CHILDREN),
    value: None,
};

pub static WORD_PROPR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eitary"),
        dictgen::InsensitiveStr::Ascii("ely"),
        dictgen::InsensitiveStr::Ascii("eties"),
        dictgen::InsensitiveStr::Ascii("ety"),
        dictgen::InsensitiveStr::Ascii("iatary"),
        dictgen::InsensitiveStr::Ascii("iatery"),
        dictgen::InsensitiveStr::Ascii("iatory"),
        dictgen::InsensitiveStr::Ascii("ieter"),
        dictgen::InsensitiveStr::Ascii("ieters"),
        dictgen::InsensitiveStr::Ascii("ietery"),
        dictgen::InsensitiveStr::Ascii("ietory"),
        dictgen::InsensitiveStr::Ascii("ietry"),
        dictgen::InsensitiveStr::Ascii("iotary"),
        dictgen::InsensitiveStr::Ascii("oable"),
        dictgen::InsensitiveStr::Ascii("oably"),
        dictgen::InsensitiveStr::Ascii("ocessed"),
        dictgen::InsensitiveStr::Ascii("ogate"),
        dictgen::InsensitiveStr::Ascii("ogated"),
        dictgen::InsensitiveStr::Ascii("ogates"),
        dictgen::InsensitiveStr::Ascii("ogating"),
        dictgen::InsensitiveStr::Ascii("ogation"),
        dictgen::InsensitiveStr::Ascii("ogations"),
        dictgen::InsensitiveStr::Ascii("ogator"),
        dictgen::InsensitiveStr::Ascii("ogators"),
        dictgen::InsensitiveStr::Ascii("oties"),
        dictgen::InsensitiveStr::Ascii("otion"),
        dictgen::InsensitiveStr::Ascii("otional"),
        dictgen::InsensitiveStr::Ascii("otionally"),
        dictgen::InsensitiveStr::Ascii("otions"),
        dictgen::InsensitiveStr::Ascii("ties"),
        dictgen::InsensitiveStr::Ascii("ty"),
    ],
    values: &[
        &["proprietary"],
        &["properly"],
        &["properties"],
        &["property"],
        &["proprietary"],
        &["proprietary"],
        &["proprietary"],
        &["proprietor"],
        &["proprietors"],
        &["proprietary"],
        &["proprietary"],
        &["proprietary"],
        &["proprietary"],
        &["probable"],
        &["probably"],
        &["preprocessed"],
        &["propagate"],
        &["propagated"],
        &["propagates"],
        &["propagating"],
        &["propagation"],
        &["propagations"],
        &["propagator"],
        &["propagators"],
        &["properties"],
        &["proportion"],
        &["proportional"],
        &["proportionally"],
        &["proportions"],
        &["properties"],
        &["property"],
    ],
    range: 2..=9,
};

static WORD_PROPP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PROPP_CHILDREN),
    value: None,
};

pub static WORD_PROPP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ely"),
        dictgen::InsensitiveStr::Ascii("er"),
        dictgen::InsensitiveStr::Ascii("erly"),
        dictgen::InsensitiveStr::Ascii("erties"),
        dictgen::InsensitiveStr::Ascii("erty"),
    ],
    values: &[
        &["properly"],
        &["proper"],
        &["properly"],
        &["properties"],
        &["property"],
    ],
    range: 2..=6,
};

static WORD_PROPO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PROPO_CHILDREN),
    value: None,
};

pub static WORD_PROPO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("agate"),
        dictgen::InsensitiveStr::Ascii("erties"),
        dictgen::InsensitiveStr::Ascii("erty"),
        dictgen::InsensitiveStr::Ascii("ganda"),
        dictgen::InsensitiveStr::Ascii("gate"),
        dictgen::InsensitiveStr::Ascii("gated"),
        dictgen::InsensitiveStr::Ascii("gates"),
        dictgen::InsensitiveStr::Ascii("gating"),
        dictgen::InsensitiveStr::Ascii("gation"),
        dictgen::InsensitiveStr::Ascii("lsion"),
        dictgen::InsensitiveStr::Ascii("nants"),
        dictgen::InsensitiveStr::Ascii("nenet"),
        dictgen::InsensitiveStr::Ascii("nenets"),
        dictgen::InsensitiveStr::Ascii("nentes"),
        dictgen::InsensitiveStr::Ascii("net"),
        dictgen::InsensitiveStr::Ascii("rcion"),
        dictgen::InsensitiveStr::Ascii("rition"),
        dictgen::InsensitiveStr::Ascii("rpotion"),
        dictgen::InsensitiveStr::Ascii("rpotional"),
        dictgen::InsensitiveStr::Ascii("rtianal"),
        dictgen::InsensitiveStr::Ascii("rtianally"),
        dictgen::InsensitiveStr::Ascii("rtians"),
        dictgen::InsensitiveStr::Ascii("rties"),
        dictgen::InsensitiveStr::Ascii("rtinal"),
        dictgen::InsensitiveStr::Ascii("rting"),
        dictgen::InsensitiveStr::Ascii("rtionallity"),
        dictgen::InsensitiveStr::Ascii("rtionallly"),
        dictgen::InsensitiveStr::Ascii("rtionalty"),
        dictgen::InsensitiveStr::Ascii("rtionaly"),
        dictgen::InsensitiveStr::Ascii("rtionel"),
        dictgen::InsensitiveStr::Ascii("rtionella"),
        dictgen::InsensitiveStr::Ascii("rtionnal"),
        dictgen::InsensitiveStr::Ascii("rty"),
        dictgen::InsensitiveStr::Ascii("sels"),
        dictgen::InsensitiveStr::Ascii("sicion"),
        dictgen::InsensitiveStr::Ascii("sitivo"),
        dictgen::InsensitiveStr::Ascii("sito"),
        dictgen::InsensitiveStr::Ascii("siton"),
        dictgen::InsensitiveStr::Ascii("sse"),
        dictgen::InsensitiveStr::Ascii("ste"),
        dictgen::InsensitiveStr::Ascii("sterous"),
        dictgen::InsensitiveStr::Ascii("stion"),
        dictgen::InsensitiveStr::Ascii("stions"),
        dictgen::InsensitiveStr::Ascii("tion"),
        dictgen::InsensitiveStr::Ascii("tional"),
        dictgen::InsensitiveStr::Ascii("tions"),
    ],
    values: &[
        &["propagate"],
        &["properties"],
        &["property"],
        &["propaganda"],
        &["propagate"],
        &["propagated"],
        &["propagates"],
        &["propagating"],
        &["propagation"],
        &["propulsion"],
        &["proponents"],
        &["proponent"],
        &["proponents"],
        &["proponents"],
        &["proponents"],
        &["proportion"],
        &["proposition"],
        &["proportion"],
        &["proportional"],
        &["proportional"],
        &["proportionally"],
        &["proportions"],
        &["properties"],
        &["proportional"],
        &["proportion"],
        &["proportionally"],
        &["proportionally"],
        &["proportionally"],
        &["proportionally"],
        &["proportional"],
        &["proportionally"],
        &["proportional"],
        &["property"],
        &["proposes"],
        &["proposition"],
        &["proposition"],
        &["proposition"],
        &["proposition"],
        &["proposes"],
        &["propose"],
        &["preposterous"],
        &["proposition"],
        &["proportions"],
        &["proportion", "promotion"],
        &["proportional", "promotional"],
        &["proportions", "promotions"],
    ],
    range: 3..=11,
};

static WORD_PROPM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PROPM_CHILDREN),
    value: None,
};

pub static WORD_PROPM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("pt"),
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("ted"),
        dictgen::InsensitiveStr::Ascii("ter"),
        dictgen::InsensitiveStr::Ascii("tly"),
        dictgen::InsensitiveStr::Ascii("ts"),
    ],
    values: &[
        &["prompt"],
        &["prompt"],
        &["prompted"],
        &["prompter"],
        &["promptly"],
        &["prompts"],
    ],
    range: 1..=3,
};

static WORD_PROPL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PROPL_CHILDREN),
    value: None,
};

pub static WORD_PROPL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("em"),
        dictgen::InsensitiveStr::Ascii("usion"),
    ],
    values: &[&["problem"], &["propulsion"]],
    range: 2..=5,
};

static WORD_PROPI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PROPI_CHILDREN),
    value: None,
};

pub static WORD_PROPI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ertary"),
        dictgen::InsensitiveStr::Ascii("etary"),
        dictgen::InsensitiveStr::Ascii("etries"),
        dictgen::InsensitiveStr::Ascii("etry"),
        dictgen::InsensitiveStr::Ascii("gate"),
        dictgen::InsensitiveStr::Ascii("gation"),
    ],
    values: &[
        &["proprietary"],
        &["proprietary"],
        &["proprietaries"],
        &["proprietary"],
        &["propagate"],
        &["propagation"],
    ],
    range: 4..=6,
};

static WORD_PROPH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PROPH_CHILDREN),
    value: None,
};

pub static WORD_PROPH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("acies"),
        dictgen::InsensitiveStr::Ascii("acy"),
        dictgen::InsensitiveStr::Ascii("echies"),
        dictgen::InsensitiveStr::Ascii("esie"),
        dictgen::InsensitiveStr::Ascii("etes"),
        dictgen::InsensitiveStr::Ascii("ey"),
        dictgen::InsensitiveStr::Ascii("ocies"),
    ],
    values: &[
        &["prophecies"],
        &["prophecy"],
        &["prophecies"],
        &["prophecies"],
        &["prophets"],
        &["prophecy"],
        &["prophecies"],
    ],
    range: 2..=6,
};

static WORD_PROPG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PROPG_CHILDREN),
    value: None,
};

pub static WORD_PROPG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ated"),
        dictgen::InsensitiveStr::Ascii("ating"),
    ],
    values: &[&["propagated"], &["propagating"]],
    range: 4..=5,
};

static WORD_PROPE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PROPE_CHILDREN),
    value: None,
};

pub static WORD_PROPE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("chies"),
        dictgen::InsensitiveStr::Ascii("chy"),
        dictgen::InsensitiveStr::Ascii("ct"),
        dictgen::InsensitiveStr::Ascii("ctable"),
        dictgen::InsensitiveStr::Ascii("cted"),
        dictgen::InsensitiveStr::Ascii("cting"),
        dictgen::InsensitiveStr::Ascii("ction"),
        dictgen::InsensitiveStr::Ascii("ctive"),
        dictgen::InsensitiveStr::Ascii("ctively"),
        dictgen::InsensitiveStr::Ascii("ctless"),
        dictgen::InsensitiveStr::Ascii("ctor"),
        dictgen::InsensitiveStr::Ascii("cts"),
        dictgen::InsensitiveStr::Ascii("ctus"),
        dictgen::InsensitiveStr::Ascii("ctuses"),
        dictgen::InsensitiveStr::Ascii("hcy"),
        dictgen::InsensitiveStr::Ascii("ht"),
        dictgen::InsensitiveStr::Ascii("hts"),
        dictgen::InsensitiveStr::Ascii("ly"),
        dictgen::InsensitiveStr::Ascii("ncity"),
        dictgen::InsensitiveStr::Ascii("nents"),
        dictgen::InsensitiveStr::Ascii("operties"),
        dictgen::InsensitiveStr::Ascii("reties"),
        dictgen::InsensitiveStr::Ascii("rety"),
        dictgen::InsensitiveStr::Ascii("ries"),
        dictgen::InsensitiveStr::Ascii("ritary"),
        dictgen::InsensitiveStr::Ascii("rites"),
        dictgen::InsensitiveStr::Ascii("rities"),
        dictgen::InsensitiveStr::Ascii("rity"),
        dictgen::InsensitiveStr::Ascii("rlty"),
        dictgen::InsensitiveStr::Ascii("rries"),
        dictgen::InsensitiveStr::Ascii("rrt"),
        dictgen::InsensitiveStr::Ascii("rry"),
        dictgen::InsensitiveStr::Ascii("rrys"),
        dictgen::InsensitiveStr::Ascii("rsity"),
        dictgen::InsensitiveStr::Ascii("rt"),
        dictgen::InsensitiveStr::Ascii("rteis"),
        dictgen::InsensitiveStr::Ascii("rtery"),
        dictgen::InsensitiveStr::Ascii("rtes"),
        dictgen::InsensitiveStr::Ascii("rtiary"),
        dictgen::InsensitiveStr::Ascii("rtie"),
        dictgen::InsensitiveStr::Ascii("rtiees"),
        dictgen::InsensitiveStr::Ascii("rtiies"),
        dictgen::InsensitiveStr::Ascii("rtion"),
        dictgen::InsensitiveStr::Ascii("rtional"),
        dictgen::InsensitiveStr::Ascii("rtions"),
        dictgen::InsensitiveStr::Ascii("rtise"),
        dictgen::InsensitiveStr::Ascii("rtius"),
        dictgen::InsensitiveStr::Ascii("rtly"),
        dictgen::InsensitiveStr::Ascii("rtu"),
        dictgen::InsensitiveStr::Ascii("rtus"),
        dictgen::InsensitiveStr::Ascii("rtyn"),
        dictgen::InsensitiveStr::Ascii("rtys"),
        dictgen::InsensitiveStr::Ascii("rtyst"),
        dictgen::InsensitiveStr::Ascii("ry"),
        dictgen::InsensitiveStr::Ascii("sterous"),
        dictgen::InsensitiveStr::Ascii("ties"),
        dictgen::InsensitiveStr::Ascii("try"),
        dictgen::InsensitiveStr::Ascii("trys"),
        dictgen::InsensitiveStr::Ascii("ty"),
        dictgen::InsensitiveStr::Ascii("tys"),
    ],
    values: &[
        &["prophecies"],
        &["prophecy"],
        &["project", "prospect", "protect"],
        &["projectable", "protectable"],
        &["projected", "prospected", "protected"],
        &["projecting", "prospecting", "protecting"],
        &["projection", "prospection", "protection"],
        &["projective", "prospective", "protective"],
        &["projectively", "prospectively", "protectively"],
        &["prospectless"],
        &["projector", "prospector", "protector"],
        &["projects", "prospects", "protects"],
        &["prospectus"],
        &["prospectuses"],
        &["prophecy"],
        &["prophet"],
        &["prophets"],
        &["properly"],
        &["propensity"],
        &["proponents"],
        &["properties"],
        &["properties"],
        &["property"],
        &["properties"],
        &["proprietary"],
        &["properties"],
        &["properties"],
        &["property", "proprietary"],
        &["properly", "property"],
        &["properties"],
        &["property"],
        &["property", "properly"],
        &["properties"],
        &["propensity"],
        &["property"],
        &["properties"],
        &["property"],
        &["properties"],
        &["proprietary"],
        &["property", "properties"],
        &["properties"],
        &["properties"],
        &["proportion"],
        &["proportional"],
        &["proportions"],
        &["properties"],
        &["properties"],
        &["property", "properly"],
        &["property"],
        &["properties"],
        &["property"],
        &["properties"],
        &["properties"],
        &["property", "properly"],
        &["preposterous"],
        &["properties"],
        &["property"],
        &["properties"],
        &["property"],
        &["properties"],
    ],
    range: 2..=8,
};

static WORD_PROPB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PROPB_CHILDREN),
    value: None,
};

pub static WORD_PROPB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ably")],
    values: &[&["probably"]],
    range: 4..=4,
};

static WORD_PROPA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PROPA_CHILDREN),
    value: None,
};

pub static WORD_PROPA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("bilities"),
        dictgen::InsensitiveStr::Ascii("bly"),
        dictgen::InsensitiveStr::Ascii("gana"),
        dictgen::InsensitiveStr::Ascii("ganada"),
        dictgen::InsensitiveStr::Ascii("ge"),
        dictgen::InsensitiveStr::Ascii("gtion"),
        dictgen::InsensitiveStr::Ascii("tagion"),
        dictgen::InsensitiveStr::Ascii("tor"),
        dictgen::InsensitiveStr::Ascii("tors"),
    ],
    values: &[
        &["probabilities"],
        &["probably"],
        &["propaganda"],
        &["propaganda"],
        &["propagate"],
        &["propagation"],
        &["propagation"],
        &["propagator"],
        &["propagators"],
    ],
    range: 2..=8,
};

static WORD_PROO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PROO_CHILDREN),
    value: None,
};

pub static WORD_PROO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cecure"),
        dictgen::InsensitiveStr::Ascii("cecures"),
        dictgen::InsensitiveStr::Ascii("cedure"),
        dictgen::InsensitiveStr::Ascii("cedures"),
        dictgen::InsensitiveStr::Ascii("cess"),
        dictgen::InsensitiveStr::Ascii("cessed"),
        dictgen::InsensitiveStr::Ascii("cesses"),
        dictgen::InsensitiveStr::Ascii("cessing"),
        dictgen::InsensitiveStr::Ascii("col"),
        dictgen::InsensitiveStr::Ascii("cols"),
        dictgen::InsensitiveStr::Ascii("duce"),
        dictgen::InsensitiveStr::Ascii("duced"),
        dictgen::InsensitiveStr::Ascii("duces"),
        dictgen::InsensitiveStr::Ascii("duct"),
        dictgen::InsensitiveStr::Ascii("erties"),
        dictgen::InsensitiveStr::Ascii("erty"),
        dictgen::InsensitiveStr::Ascii("l"),
        dictgen::InsensitiveStr::Ascii("of"),
        dictgen::InsensitiveStr::Ascii("per"),
        dictgen::InsensitiveStr::Ascii("perly"),
        dictgen::InsensitiveStr::Ascii("perties"),
        dictgen::InsensitiveStr::Ascii("perty"),
        dictgen::InsensitiveStr::Ascii("se"),
        dictgen::InsensitiveStr::Ascii("sed"),
        dictgen::InsensitiveStr::Ascii("ses"),
        dictgen::InsensitiveStr::Ascii("ve"),
        dictgen::InsensitiveStr::Ascii("ved"),
        dictgen::InsensitiveStr::Ascii("ven"),
        dictgen::InsensitiveStr::Ascii("ves"),
        dictgen::InsensitiveStr::Ascii("ving"),
        dictgen::InsensitiveStr::Ascii("vread"),
        dictgen::InsensitiveStr::Ascii("xies"),
        dictgen::InsensitiveStr::Ascii("xy"),
    ],
    values: &[
        &["procedure"],
        &["procedures"],
        &["procedure"],
        &["procedures"],
        &["process"],
        &["processed"],
        &["processes"],
        &["processing"],
        &["protocol"],
        &["protocols"],
        &["produce"],
        &["produced"],
        &["produces"],
        &["product"],
        &["properties"],
        &["property"],
        &["pool"],
        &["proof"],
        &["proper"],
        &["properly"],
        &["properties"],
        &["property"],
        &["propose"],
        &["proposed"],
        &["proposes"],
        &["prove"],
        &["proved"],
        &["proven"],
        &["proves"],
        &["proving"],
        &["proofread"],
        &["proxies"],
        &["proxy"],
    ],
    range: 1..=7,
};

static WORD_PRON_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PRON_CHILDREN),
    value: None,
};

pub static WORD_PRON_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("nounced"),
        dictgen::InsensitiveStr::Ascii("ography"),
        dictgen::InsensitiveStr::Ascii("omial"),
        dictgen::InsensitiveStr::Ascii("onciation"),
        dictgen::InsensitiveStr::Ascii("ouce"),
        dictgen::InsensitiveStr::Ascii("ouced"),
        dictgen::InsensitiveStr::Ascii("ouciation"),
        dictgen::InsensitiveStr::Ascii("oucned"),
        dictgen::InsensitiveStr::Ascii("oucning"),
        dictgen::InsensitiveStr::Ascii("ounceing"),
        dictgen::InsensitiveStr::Ascii("ounched"),
        dictgen::InsensitiveStr::Ascii("ounciation"),
        dictgen::InsensitiveStr::Ascii("ounds"),
        dictgen::InsensitiveStr::Ascii("oune"),
        dictgen::InsensitiveStr::Ascii("ounes"),
        dictgen::InsensitiveStr::Ascii("ouning"),
        dictgen::InsensitiveStr::Ascii("ous"),
        dictgen::InsensitiveStr::Ascii("unce"),
        dictgen::InsensitiveStr::Ascii("unciacion"),
        dictgen::InsensitiveStr::Ascii("unciating"),
        dictgen::InsensitiveStr::Ascii("unciato"),
        dictgen::InsensitiveStr::Ascii("unciaton"),
        dictgen::InsensitiveStr::Ascii("uncuation"),
        dictgen::InsensitiveStr::Ascii("unication"),
        dictgen::InsensitiveStr::Ascii("untiation"),
    ],
    values: &[
        &["pronounced"],
        &["pornography"],
        &["pronominal"],
        &["pronunciation"],
        &["pronounce"],
        &["pronounced"],
        &["pronunciation"],
        &["pronounced"],
        &["pronouncing"],
        &["pronouncing"],
        &["pronounced"],
        &["pronunciation"],
        &["pronouns"],
        &["pronounced"],
        &["pronouns"],
        &["pronouncing"],
        &["pronouns"],
        &["pronounce"],
        &["pronunciation"],
        &["pronunciation"],
        &["pronunciation"],
        &["pronunciation"],
        &["pronunciation"],
        &["pronunciation"],
        &["pronunciation"],
    ],
    range: 3..=10,
};

static WORD_PROM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PROM_CHILDREN),
    value: None,
};

pub static WORD_PROM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("atory"),
        dictgen::InsensitiveStr::Ascii("enantly"),
        dictgen::InsensitiveStr::Ascii("enently"),
        dictgen::InsensitiveStr::Ascii("etheas"),
        dictgen::InsensitiveStr::Ascii("etheius"),
        dictgen::InsensitiveStr::Ascii("etheous"),
        dictgen::InsensitiveStr::Ascii("ethese"),
        dictgen::InsensitiveStr::Ascii("ethesus"),
        dictgen::InsensitiveStr::Ascii("etheyus"),
        dictgen::InsensitiveStr::Ascii("ethius"),
        dictgen::InsensitiveStr::Ascii("ethous"),
        dictgen::InsensitiveStr::Ascii("ethues"),
        dictgen::InsensitiveStr::Ascii("imently"),
        dictgen::InsensitiveStr::Ascii("inance"),
        dictgen::InsensitiveStr::Ascii("inant"),
        dictgen::InsensitiveStr::Ascii("inantely"),
        dictgen::InsensitiveStr::Ascii("inantly"),
        dictgen::InsensitiveStr::Ascii("inately"),
        dictgen::InsensitiveStr::Ascii("inenty"),
        dictgen::InsensitiveStr::Ascii("inetly"),
        dictgen::InsensitiveStr::Ascii("is"),
        dictgen::InsensitiveStr::Ascii("iscious"),
        dictgen::InsensitiveStr::Ascii("iscous"),
        dictgen::InsensitiveStr::Ascii("iscuious"),
        dictgen::InsensitiveStr::Ascii("isculous"),
        dictgen::InsensitiveStr::Ascii("iscuos"),
        dictgen::InsensitiveStr::Ascii("iscus"),
        dictgen::InsensitiveStr::Ascii("iss"),
        dictgen::InsensitiveStr::Ascii("isse"),
        dictgen::InsensitiveStr::Ascii("issed"),
        dictgen::InsensitiveStr::Ascii("isses"),
        dictgen::InsensitiveStr::Ascii("issing"),
        dictgen::InsensitiveStr::Ascii("itives"),
        dictgen::InsensitiveStr::Ascii("ixity"),
        dictgen::InsensitiveStr::Ascii("mpt"),
        dictgen::InsensitiveStr::Ascii("mpts"),
        dictgen::InsensitiveStr::Ascii("ocional"),
        dictgen::InsensitiveStr::Ascii("ordials"),
        dictgen::InsensitiveStr::Ascii("ose"),
        dictgen::InsensitiveStr::Ascii("oteurs"),
        dictgen::InsensitiveStr::Ascii("otheus"),
        dictgen::InsensitiveStr::Ascii("otinal"),
        dictgen::InsensitiveStr::Ascii("otionnal"),
        dictgen::InsensitiveStr::Ascii("ots"),
        dictgen::InsensitiveStr::Ascii("otted"),
        dictgen::InsensitiveStr::Ascii("plty"),
        dictgen::InsensitiveStr::Ascii("prted"),
        dictgen::InsensitiveStr::Ascii("ps"),
        dictgen::InsensitiveStr::Ascii("ptes"),
        dictgen::InsensitiveStr::Ascii("ptus"),
        dictgen::InsensitiveStr::Ascii("pty"),
        dictgen::InsensitiveStr::Ascii("sicuous"),
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("ted"),
        dictgen::InsensitiveStr::Ascii("ter"),
        dictgen::InsensitiveStr::Ascii("ters"),
        dictgen::InsensitiveStr::Ascii("ting"),
        dictgen::InsensitiveStr::Ascii("tp"),
        dictgen::InsensitiveStr::Ascii("tped"),
        dictgen::InsensitiveStr::Ascii("tping"),
        dictgen::InsensitiveStr::Ascii("tply"),
        dictgen::InsensitiveStr::Ascii("tps"),
        dictgen::InsensitiveStr::Ascii("ts"),
    ],
    values: &[
        &["promontory"],
        &["prominently"],
        &["prominently"],
        &["prometheus"],
        &["prometheus"],
        &["prometheus"],
        &["prometheus"],
        &["prometheus"],
        &["prometheus"],
        &["prometheus"],
        &["prometheus"],
        &["prometheus"],
        &["prominently"],
        &["prominence"],
        &["prominent"],
        &["prominently"],
        &["prominently"],
        &["prominently", "predominately"],
        &["prominently"],
        &["prominently"],
        &["promise"],
        &["promiscuous"],
        &["promiscuous"],
        &["promiscuous"],
        &["promiscuous"],
        &["promiscuous"],
        &["promiscuous"],
        &["promise"],
        &["promise", "promises", "promised"],
        &["promised"],
        &["promises"],
        &["promising"],
        &["primitives"],
        &["proximity"],
        &["prompt"],
        &["prompts"],
        &["promotional"],
        &["primordials"],
        &["promotes"],
        &["promotes"],
        &["prometheus"],
        &["promotional"],
        &["promotional"],
        &["promotes"],
        &["promoted"],
        &["promptly"],
        &["prompted"],
        &["prompts"],
        &["prompts"],
        &["prompts"],
        &["promptly"],
        &["promiscuous"],
        &["prompt"],
        &["prompted", "promoted"],
        &["promoter", "prompter"],
        &["promoters", "prompters"],
        &["promoting", "prompting"],
        &["prompt"],
        &["prompted"],
        &["prompting"],
        &["promptly"],
        &["prompts"],
        &["prompts"],
    ],
    range: 1..=8,
};

static WORD_PROL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PROL_CHILDREN),
    value: None,
};

pub static WORD_PROL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ateriat"),
        dictgen::InsensitiveStr::Ascii("bems"),
        dictgen::InsensitiveStr::Ascii("em"),
        dictgen::InsensitiveStr::Ascii("ematic"),
        dictgen::InsensitiveStr::Ascii("ems"),
        dictgen::InsensitiveStr::Ascii("etariaat"),
        dictgen::InsensitiveStr::Ascii("etariant"),
        dictgen::InsensitiveStr::Ascii("etaricat"),
        dictgen::InsensitiveStr::Ascii("etariet"),
        dictgen::InsensitiveStr::Ascii("etariot"),
        dictgen::InsensitiveStr::Ascii("etaryat"),
        dictgen::InsensitiveStr::Ascii("eteriat"),
        dictgen::InsensitiveStr::Ascii("icks"),
        dictgen::InsensitiveStr::Ascii("itariat"),
        dictgen::InsensitiveStr::Ascii("oge"),
        dictgen::InsensitiveStr::Ascii("ogomena"),
        dictgen::InsensitiveStr::Ascii("ouge"),
    ],
    values: &[
        &["proletariat"],
        &["problems"],
        &["problem"],
        &["problematic"],
        &["problems"],
        &["proletariat"],
        &["proletariat"],
        &["proletariat"],
        &["proletariat"],
        &["proletariat"],
        &["proletariat"],
        &["proletariat"],
        &["prolix"],
        &["proletariat"],
        &["prologue"],
        &["prolegomena"],
        &["prologue"],
    ],
    range: 2..=8,
};

static WORD_PROK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PROK_CHILDREN),
    value: None,
};

pub static WORD_PROK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("rastination")],
    values: &[&["procrastination"]],
    range: 11..=11,
};

static WORD_PROJ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PROJ_CHILDREN),
    value: None,
};

pub static WORD_PROJ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cet"),
        dictgen::InsensitiveStr::Ascii("cets"),
        dictgen::InsensitiveStr::Ascii("ct"),
        dictgen::InsensitiveStr::Ascii("ction"),
        dictgen::InsensitiveStr::Ascii("ctions"),
        dictgen::InsensitiveStr::Ascii("ctor"),
        dictgen::InsensitiveStr::Ascii("ctors"),
        dictgen::InsensitiveStr::Ascii("cts"),
        dictgen::InsensitiveStr::Ascii("ec"),
        dictgen::InsensitiveStr::Ascii("ecitle"),
        dictgen::InsensitiveStr::Ascii("eciton"),
        dictgen::InsensitiveStr::Ascii("ecs"),
        dictgen::InsensitiveStr::Ascii("ectd"),
        dictgen::InsensitiveStr::Ascii("ecte"),
        dictgen::InsensitiveStr::Ascii("ecticle"),
        dictgen::InsensitiveStr::Ascii("ecticles"),
        dictgen::InsensitiveStr::Ascii("ectie"),
        dictgen::InsensitiveStr::Ascii("ectiel"),
        dictgen::InsensitiveStr::Ascii("ecties"),
        dictgen::InsensitiveStr::Ascii("ectils"),
        dictgen::InsensitiveStr::Ascii("ectin"),
        dictgen::InsensitiveStr::Ascii("ectio"),
        dictgen::InsensitiveStr::Ascii("ectives"),
        dictgen::InsensitiveStr::Ascii("ectles"),
        dictgen::InsensitiveStr::Ascii("ectlie"),
        dictgen::InsensitiveStr::Ascii("ectlies"),
        dictgen::InsensitiveStr::Ascii("ecto"),
        dictgen::InsensitiveStr::Ascii("ecttion"),
        dictgen::InsensitiveStr::Ascii("ectyle"),
        dictgen::InsensitiveStr::Ascii("ektile"),
        dictgen::InsensitiveStr::Ascii("ektion"),
        dictgen::InsensitiveStr::Ascii("et"),
        dictgen::InsensitiveStr::Ascii("etction"),
        dictgen::InsensitiveStr::Ascii("eted"),
        dictgen::InsensitiveStr::Ascii("eting"),
        dictgen::InsensitiveStr::Ascii("ets"),
    ],
    values: &[
        &["project"],
        &["projects"],
        &["project"],
        &["projection"],
        &["projections"],
        &["projector"],
        &["projectors"],
        &["projects"],
        &["project"],
        &["projectiles"],
        &["projection"],
        &["projects"],
        &["projected"],
        &["projectile"],
        &["projectile"],
        &["projectiles"],
        &["projectile"],
        &["projectiles"],
        &["projectiles"],
        &["projectiles"],
        &["projection"],
        &["projection"],
        &["projectiles"],
        &["projectiles"],
        &["projectiles"],
        &["projectiles"],
        &["projection"],
        &["projection"],
        &["projectile"],
        &["projectile"],
        &["projection"],
        &["project"],
        &["projection"],
        &["projected"],
        &["projecting"],
        &["projects"],
    ],
    range: 2..=8,
};

static WORD_PROI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PROI_CHILDREN),
    value: None,
};

pub static WORD_PROI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("rity"),
        dictgen::InsensitiveStr::Ascii("vded"),
    ],
    values: &[&["priority"], &["provided"]],
    range: 4..=4,
};

static WORD_PROH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PROH_CHILDREN),
    value: None,
};

pub static WORD_PROH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("abition"),
        dictgen::InsensitiveStr::Ascii("ibation"),
        dictgen::InsensitiveStr::Ascii("ibative"),
        dictgen::InsensitiveStr::Ascii("ibicion"),
        dictgen::InsensitiveStr::Ascii("ibirte"),
        dictgen::InsensitiveStr::Ascii("ibis"),
        dictgen::InsensitiveStr::Ascii("ibiteds"),
        dictgen::InsensitiveStr::Ascii("ibites"),
        dictgen::InsensitiveStr::Ascii("ibitied"),
        dictgen::InsensitiveStr::Ascii("ibitifs"),
        dictgen::InsensitiveStr::Ascii("ibitivo"),
        dictgen::InsensitiveStr::Ascii("ibitng"),
        dictgen::InsensitiveStr::Ascii("ibiton"),
        dictgen::InsensitiveStr::Ascii("ibitons"),
        dictgen::InsensitiveStr::Ascii("ibitted"),
        dictgen::InsensitiveStr::Ascii("ibitting"),
        dictgen::InsensitiveStr::Ascii("ibitus"),
        dictgen::InsensitiveStr::Ascii("ibitve"),
        dictgen::InsensitiveStr::Ascii("ibt"),
        dictgen::InsensitiveStr::Ascii("ibted"),
        dictgen::InsensitiveStr::Ascii("ibting"),
        dictgen::InsensitiveStr::Ascii("ibts"),
        dictgen::InsensitiveStr::Ascii("obited"),
        dictgen::InsensitiveStr::Ascii("pecies"),
        dictgen::InsensitiveStr::Ascii("pecy"),
        dictgen::InsensitiveStr::Ascii("pet"),
        dictgen::InsensitiveStr::Ascii("pets"),
    ],
    values: &[
        &["prohibition"],
        &["prohibition"],
        &["prohibitive"],
        &["prohibition"],
        &["prohibit"],
        &["prohibits"],
        &["prohibits"],
        &["prohibits"],
        &["prohibited"],
        &["prohibits"],
        &["prohibition"],
        &["prohibiting"],
        &["prohibition"],
        &["prohibits"],
        &["prohibited"],
        &["prohibiting"],
        &["prohibits"],
        &["prohibited"],
        &["prohibit"],
        &["prohibited"],
        &["prohibiting"],
        &["prohibits"],
        &["prohibited"],
        &["prophecies"],
        &["prophecy"],
        &["prophet"],
        &["prophets"],
    ],
    range: 3..=8,
};

static WORD_PROG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_PROG_CHILDREN),
    value: None,
};

static WORD_PROG_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_PROGA_NODE),
    None,
    None,
    None,
    Some(&WORD_PROGE_NODE),
    None,
    None,
    None,
    Some(&WORD_PROGI_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_PROGR_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_PROGR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_PROGR_CHILDREN),
    value: None,
};

static WORD_PROGR_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_PROGRA_NODE),
    None,
    None,
    None,
    Some(&WORD_PROGRE_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_PROGRM_NODE),
    None,
    Some(&WORD_PROGRO_NODE),
    None,
    None,
    None,
    Some(&WORD_PROGRS_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_PROGRS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PROGRS_CHILDREN),
    value: None,
};

pub static WORD_PROGRS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("s")],
    values: &[&["progress"]],
    range: 1..=1,
};

static WORD_PROGRO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PROGRO_CHILDREN),
    value: None,
};

pub static WORD_PROGRO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("m"),
        dictgen::InsensitiveStr::Ascii("ms"),
    ],
    values: &[&["pogrom", "program"], &["pogroms", "programs"]],
    range: 1..=2,
};

static WORD_PROGRM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PROGRM_CHILDREN),
    value: None,
};

pub static WORD_PROGRM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ae"),
        dictgen::InsensitiveStr::Ascii("mers"),
    ],
    values: &[&["program"], &["programmers"]],
    range: 2..=4,
};

static WORD_PROGRE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PROGRE_CHILDREN),
    value: None,
};

pub static WORD_PROGRE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ess"),
        dictgen::InsensitiveStr::Ascii("s"),
        dictgen::InsensitiveStr::Ascii("sing"),
        dictgen::InsensitiveStr::Ascii("sion"),
        dictgen::InsensitiveStr::Ascii("sison"),
        dictgen::InsensitiveStr::Ascii("sive"),
        dictgen::InsensitiveStr::Ascii("sively"),
        dictgen::InsensitiveStr::Ascii("ssers"),
        dictgen::InsensitiveStr::Ascii("ssie"),
        dictgen::InsensitiveStr::Ascii("ssief"),
        dictgen::InsensitiveStr::Ascii("ssieve"),
        dictgen::InsensitiveStr::Ascii("ssin"),
        dictgen::InsensitiveStr::Ascii("ssino"),
        dictgen::InsensitiveStr::Ascii("ssioin"),
        dictgen::InsensitiveStr::Ascii("ssiong"),
        dictgen::InsensitiveStr::Ascii("ssionists"),
        dictgen::InsensitiveStr::Ascii("ssionwise"),
        dictgen::InsensitiveStr::Ascii("ssisme"),
        dictgen::InsensitiveStr::Ascii("ssiste"),
        dictgen::InsensitiveStr::Ascii("ssivas"),
        dictgen::InsensitiveStr::Ascii("ssivelly"),
        dictgen::InsensitiveStr::Ascii("ssivey"),
        dictgen::InsensitiveStr::Ascii("ssivily"),
        dictgen::InsensitiveStr::Ascii("ssivisme"),
        dictgen::InsensitiveStr::Ascii("ssivley"),
        dictgen::InsensitiveStr::Ascii("ssivly"),
        dictgen::InsensitiveStr::Ascii("ssivo"),
        dictgen::InsensitiveStr::Ascii("ssivsm"),
        dictgen::InsensitiveStr::Ascii("sso"),
        dictgen::InsensitiveStr::Ascii("ssoin"),
        dictgen::InsensitiveStr::Ascii("sson"),
        dictgen::InsensitiveStr::Ascii("ssos"),
        dictgen::InsensitiveStr::Ascii("sss"),
        dictgen::InsensitiveStr::Ascii("sssing"),
        dictgen::InsensitiveStr::Ascii("sssion"),
        dictgen::InsensitiveStr::Ascii("sssive"),
        dictgen::InsensitiveStr::Ascii("ssus"),
        dictgen::InsensitiveStr::Ascii("ssvie"),
        dictgen::InsensitiveStr::Ascii("wss"),
    ],
    values: &[
        &["progress"],
        &["progress"],
        &["progressing"],
        &["progression"],
        &["progressions"],
        &["progressive"],
        &["progressively"],
        &["progresses"],
        &["progressives"],
        &["progressive"],
        &["progressive"],
        &["progression"],
        &["progressions"],
        &["progressions"],
        &["progressing"],
        &["progressions"],
        &["progressions"],
        &["progresses"],
        &["progresses"],
        &["progressives"],
        &["progressively"],
        &["progressively"],
        &["progressively"],
        &["progressives"],
        &["progressively"],
        &["progressively"],
        &["progression"],
        &["progressives"],
        &["progression"],
        &["progressions"],
        &["progression"],
        &["progresses"],
        &["progresses", "progress"],
        &["progressing"],
        &["progressions"],
        &["progressives"],
        &["progresses"],
        &["progressives"],
        &["progress"],
    ],
    range: 1..=9,
};

static WORD_PROGRA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PROGRA_CHILDREN),
    value: None,
};

pub static WORD_PROGRA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("mable"),
        dictgen::InsensitiveStr::Ascii("mas"),
        dictgen::InsensitiveStr::Ascii("matic"),
        dictgen::InsensitiveStr::Ascii("matically"),
        dictgen::InsensitiveStr::Ascii("mattically"),
        dictgen::InsensitiveStr::Ascii("md"),
        dictgen::InsensitiveStr::Ascii("mem"),
        dictgen::InsensitiveStr::Ascii("memer"),
        dictgen::InsensitiveStr::Ascii("memers"),
        dictgen::InsensitiveStr::Ascii("mes"),
        dictgen::InsensitiveStr::Ascii("mm"),
        dictgen::InsensitiveStr::Ascii("mmar"),
        dictgen::InsensitiveStr::Ascii("mmare"),
        dictgen::InsensitiveStr::Ascii("mmars"),
        dictgen::InsensitiveStr::Ascii("mmate"),
        dictgen::InsensitiveStr::Ascii("mmaticaly"),
        dictgen::InsensitiveStr::Ascii("mmd"),
        dictgen::InsensitiveStr::Ascii("mmend"),
        dictgen::InsensitiveStr::Ascii("mmetically"),
        dictgen::InsensitiveStr::Ascii("mmets"),
        dictgen::InsensitiveStr::Ascii("mmeur"),
        dictgen::InsensitiveStr::Ascii("mmeurs"),
        dictgen::InsensitiveStr::Ascii("mmical"),
        dictgen::InsensitiveStr::Ascii("mmier"),
        dictgen::InsensitiveStr::Ascii("mmign"),
        dictgen::InsensitiveStr::Ascii("mmme"),
        dictgen::InsensitiveStr::Ascii("mmmed"),
        dictgen::InsensitiveStr::Ascii("mmmer"),
        dictgen::InsensitiveStr::Ascii("mmming"),
        dictgen::InsensitiveStr::Ascii("mms"),
        dictgen::InsensitiveStr::Ascii("stination"),
    ],
    values: &[
        &["programmable"],
        &["programs"],
        &["programmatic"],
        &["programmatically"],
        &["programmatically"],
        &["programed"],
        &["programme"],
        &["programmer"],
        &["programmers"],
        &["programs"],
        &["program", "programme"],
        &["programmer"],
        &["programmer"],
        &["programmers"],
        &["programme"],
        &["programmatically"],
        &["programmed", "programme"],
        &["programmed"],
        &["programmatically"],
        &["programmers"],
        &["programmer"],
        &["programmer"],
        &["programmatical"],
        &["programmer"],
        &["programming"],
        &["programme"],
        &["programme"],
        &["programme"],
        &["programming"],
        &["programs"],
        &["procrastination"],
    ],
    range: 2..=10,
};

static WORD_PROGI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PROGI_CHILDREN),
    value: None,
};

pub static WORD_PROGI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("dy")],
    values: &[&["prodigy"]],
    range: 2..=2,
};

static WORD_PROGE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PROGE_CHILDREN),
    value: None,
};

pub static WORD_PROGE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("rssion"),
        dictgen::InsensitiveStr::Ascii("rssive"),
        dictgen::InsensitiveStr::Ascii("ss"),
        dictgen::InsensitiveStr::Ascii("ssbar"),
        dictgen::InsensitiveStr::Ascii("ssed"),
        dictgen::InsensitiveStr::Ascii("sses"),
        dictgen::InsensitiveStr::Ascii("ssive"),
        dictgen::InsensitiveStr::Ascii("ssor"),
        dictgen::InsensitiveStr::Ascii("sss"),
        dictgen::InsensitiveStr::Ascii("sssive"),
    ],
    values: &[
        &["progressions"],
        &["progressives"],
        &["progress"],
        &["progressbar"],
        &["progressed"],
        &["progresses"],
        &["progressive"],
        &["progressor"],
        &["progress"],
        &["progressive"],
    ],
    range: 2..=6,
};

static WORD_PROGA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PROGA_CHILDREN),
    value: None,
};

pub static WORD_PROGA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("gate"),
        dictgen::InsensitiveStr::Ascii("gated"),
        dictgen::InsensitiveStr::Ascii("gates"),
        dictgen::InsensitiveStr::Ascii("gating"),
        dictgen::InsensitiveStr::Ascii("gation"),
        dictgen::InsensitiveStr::Ascii("gations"),
        dictgen::InsensitiveStr::Ascii("gator"),
        dictgen::InsensitiveStr::Ascii("gators"),
        dictgen::InsensitiveStr::Ascii("m"),
        dictgen::InsensitiveStr::Ascii("mability"),
        dictgen::InsensitiveStr::Ascii("mable"),
        dictgen::InsensitiveStr::Ascii("matic"),
        dictgen::InsensitiveStr::Ascii("matically"),
        dictgen::InsensitiveStr::Ascii("med"),
        dictgen::InsensitiveStr::Ascii("mer"),
        dictgen::InsensitiveStr::Ascii("mers"),
        dictgen::InsensitiveStr::Ascii("ming"),
        dictgen::InsensitiveStr::Ascii("mm"),
        dictgen::InsensitiveStr::Ascii("mmability"),
        dictgen::InsensitiveStr::Ascii("mmable"),
        dictgen::InsensitiveStr::Ascii("mmatic"),
        dictgen::InsensitiveStr::Ascii("mmatically"),
        dictgen::InsensitiveStr::Ascii("mmed"),
        dictgen::InsensitiveStr::Ascii("mmer"),
        dictgen::InsensitiveStr::Ascii("mmers"),
        dictgen::InsensitiveStr::Ascii("mming"),
        dictgen::InsensitiveStr::Ascii("mms"),
        dictgen::InsensitiveStr::Ascii("ms"),
        dictgen::InsensitiveStr::Ascii("pate"),
        dictgen::InsensitiveStr::Ascii("pated"),
        dictgen::InsensitiveStr::Ascii("pates"),
        dictgen::InsensitiveStr::Ascii("pating"),
        dictgen::InsensitiveStr::Ascii("pation"),
        dictgen::InsensitiveStr::Ascii("pations"),
        dictgen::InsensitiveStr::Ascii("pator"),
        dictgen::InsensitiveStr::Ascii("pators"),
        dictgen::InsensitiveStr::Ascii("ramm"),
        dictgen::InsensitiveStr::Ascii("rammability"),
        dictgen::InsensitiveStr::Ascii("rammable"),
        dictgen::InsensitiveStr::Ascii("rammatic"),
        dictgen::InsensitiveStr::Ascii("rammatically"),
        dictgen::InsensitiveStr::Ascii("rammed"),
        dictgen::InsensitiveStr::Ascii("rammer"),
        dictgen::InsensitiveStr::Ascii("rammers"),
        dictgen::InsensitiveStr::Ascii("ramming"),
        dictgen::InsensitiveStr::Ascii("ramms"),
        dictgen::InsensitiveStr::Ascii("rm"),
        dictgen::InsensitiveStr::Ascii("rmability"),
        dictgen::InsensitiveStr::Ascii("rmable"),
        dictgen::InsensitiveStr::Ascii("rmatic"),
        dictgen::InsensitiveStr::Ascii("rmatically"),
        dictgen::InsensitiveStr::Ascii("rmed"),
        dictgen::InsensitiveStr::Ascii("rmer"),
        dictgen::InsensitiveStr::Ascii("rmers"),
        dictgen::InsensitiveStr::Ascii("rming"),
        dictgen::InsensitiveStr::Ascii("rms"),
        dictgen::InsensitiveStr::Ascii("te"),
        dictgen::InsensitiveStr::Ascii("ted"),
        dictgen::InsensitiveStr::Ascii("tes"),
        dictgen::InsensitiveStr::Ascii("ting"),
        dictgen::InsensitiveStr::Ascii("tion"),
        dictgen::InsensitiveStr::Ascii("tions"),
        dictgen::InsensitiveStr::Ascii("tonists"),
    ],
    values: &[
        &["propagate"],
        &["propagated"],
        &["propagates"],
        &["propagating"],
        &["propagation"],
        &["propagations"],
        &["propagator"],
        &["propagators"],
        &["program"],
        &["programmability"],
        &["programmable"],
        &["programmatic"],
        &["programmatically"],
        &["programed"],
        &["programer"],
        &["programers"],
        &["programing"],
        &["program"],
        &["programmability"],
        &["programmable"],
        &["programmatic"],
        &["programmatically"],
        &["programmed"],
        &["programmer"],
        &["programmers"],
        &["programming"],
        &["programs"],
        &["programs"],
        &["propagate"],
        &["propagated"],
        &["propagates"],
        &["propagating"],
        &["propagation"],
        &["propagations"],
        &["propagator"],
        &["propagators"],
        &["program"],
        &["programmability"],
        &["programmable"],
        &["programmatic"],
        &["programmatically"],
        &["programmed"],
        &["programmer"],
        &["programmers"],
        &["programming"],
        &["programs"],
        &["program"],
        &["programmability"],
        &["programmable"],
        &["programmatic"],
        &["programmatically"],
        &["programmed"],
        &["programmer"],
        &["programmers"],
        &["programming"],
        &["programs"],
        &["propagate"],
        &["propagated"],
        &["propagates"],
        &["propagating"],
        &["propagation"],
        &["propagations"],
        &["protagonists"],
    ],
    range: 1..=12,
};

static WORD_PROF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_PROF_CHILDREN),
    value: None,
};

static WORD_PROF_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    None,
    None,
    Some(&WORD_PROFE_NODE),
    Some(&WORD_PROFF_NODE),
    None,
    None,
    Some(&WORD_PROFI_NODE),
    None,
    None,
    Some(&WORD_PROFL_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_PROFR_NODE),
    None,
    Some(&WORD_PROFT_NODE),
    Some(&WORD_PROFU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_PROFU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PROFU_CHILDREN),
    value: None,
};

pub static WORD_PROFU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("nd"),
        dictgen::InsensitiveStr::Ascii("ndly"),
    ],
    values: &[&["profound"], &["profoundly"]],
    range: 2..=4,
};

static WORD_PROFT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PROFT_CHILDREN),
    value: None,
};

pub static WORD_PROFT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("iable")],
    values: &[&["profitable"]],
    range: 5..=5,
};

static WORD_PROFR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PROFR_CHILDREN),
    value: None,
};

pub static WORD_PROFR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("essions")],
    values: &[&["progressions"]],
    range: 7..=7,
};

static WORD_PROFL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PROFL_CHILDREN),
    value: None,
};

pub static WORD_PROFL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ie"),
        dictgen::InsensitiveStr::Ascii("ied"),
        dictgen::InsensitiveStr::Ascii("ier"),
        dictgen::InsensitiveStr::Ascii("ies"),
        dictgen::InsensitiveStr::Ascii("ing"),
    ],
    values: &[
        &["profile"],
        &["profiled", "profiles"],
        &["profiler"],
        &["profiles"],
        &["profiling"],
    ],
    range: 2..=3,
};

static WORD_PROFI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PROFI_CHILDREN),
    value: None,
};

pub static WORD_PROFI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ceint"),
        dictgen::InsensitiveStr::Ascii("ciancy"),
        dictgen::InsensitiveStr::Ascii("ciant"),
        dictgen::InsensitiveStr::Ascii("cienct"),
        dictgen::InsensitiveStr::Ascii("cientcy"),
        dictgen::InsensitiveStr::Ascii("cienty"),
        dictgen::InsensitiveStr::Ascii("cieny"),
        dictgen::InsensitiveStr::Ascii("cincy"),
        dictgen::InsensitiveStr::Ascii("cinecy"),
        dictgen::InsensitiveStr::Ascii("cit"),
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("er"),
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("lic"),
        dictgen::InsensitiveStr::Ascii("rle"),
        dictgen::InsensitiveStr::Ascii("rled"),
        dictgen::InsensitiveStr::Ascii("rler"),
        dictgen::InsensitiveStr::Ascii("rles"),
        dictgen::InsensitiveStr::Ascii("ssional"),
        dictgen::InsensitiveStr::Ascii("tabel"),
        dictgen::InsensitiveStr::Ascii("tabil"),
        dictgen::InsensitiveStr::Ascii("tabile"),
        dictgen::InsensitiveStr::Ascii("tabiliy"),
        dictgen::InsensitiveStr::Ascii("tabillity"),
        dictgen::InsensitiveStr::Ascii("tabilty"),
        dictgen::InsensitiveStr::Ascii("tiablity"),
        dictgen::InsensitiveStr::Ascii("tibality"),
        dictgen::InsensitiveStr::Ascii("tible"),
    ],
    values: &[
        &["proficient"],
        &["proficiency"],
        &["proficient"],
        &["proficient"],
        &["proficiency"],
        &["proficiency"],
        &["proficiency"],
        &["proficiency"],
        &["proficiency"],
        &["proficient"],
        &["profile"],
        &["profiled"],
        &["profiler"],
        &["profiles"],
        &["prolific"],
        &["profile"],
        &["profiled"],
        &["profiler"],
        &["profiles"],
        &["professional"],
        &["profitable"],
        &["profitable"],
        &["profitable"],
        &["profitability"],
        &["profitability"],
        &["profitability"],
        &["profitability"],
        &["profitability"],
        &["profitable"],
    ],
    range: 1..=9,
};

static WORD_PROFF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PROFF_CHILDREN),
    value: None,
};

pub static WORD_PROFF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("esed"),
        dictgen::InsensitiveStr::Ascii("esion"),
        dictgen::InsensitiveStr::Ascii("esional"),
        dictgen::InsensitiveStr::Ascii("esor"),
        dictgen::InsensitiveStr::Ascii("ession"),
        dictgen::InsensitiveStr::Ascii("essional"),
        dictgen::InsensitiveStr::Ascii("essor"),
    ],
    values: &[
        &["professed"],
        &["profession"],
        &["professional"],
        &["professor"],
        &["profession"],
        &["professional"],
        &["professor"],
    ],
    range: 4..=8,
};

static WORD_PROFE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PROFE_CHILDREN),
    value: None,
};

pub static WORD_PROFE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("sion"),
        dictgen::InsensitiveStr::Ascii("sional"),
        dictgen::InsensitiveStr::Ascii("sionally"),
        dictgen::InsensitiveStr::Ascii("sionals"),
        dictgen::InsensitiveStr::Ascii("sions"),
        dictgen::InsensitiveStr::Ascii("sisonal"),
        dictgen::InsensitiveStr::Ascii("sor"),
        dictgen::InsensitiveStr::Ascii("sser"),
        dictgen::InsensitiveStr::Ascii("ssers"),
        dictgen::InsensitiveStr::Ascii("ssiinal"),
        dictgen::InsensitiveStr::Ascii("ssin"),
        dictgen::InsensitiveStr::Ascii("ssinal"),
        dictgen::InsensitiveStr::Ascii("ssioanl"),
        dictgen::InsensitiveStr::Ascii("ssiomal"),
        dictgen::InsensitiveStr::Ascii("ssionalisim"),
        dictgen::InsensitiveStr::Ascii("ssionalisme"),
        dictgen::InsensitiveStr::Ascii("ssionallism"),
        dictgen::InsensitiveStr::Ascii("ssionalsim"),
        dictgen::InsensitiveStr::Ascii("ssionaly"),
        dictgen::InsensitiveStr::Ascii("ssionel"),
        dictgen::InsensitiveStr::Ascii("ssionials"),
        dictgen::InsensitiveStr::Ascii("ssionl"),
        dictgen::InsensitiveStr::Ascii("ssionnal"),
        dictgen::InsensitiveStr::Ascii("ssionnalism"),
        dictgen::InsensitiveStr::Ascii("ssionnals"),
        dictgen::InsensitiveStr::Ascii("ssionsl"),
        dictgen::InsensitiveStr::Ascii("ssoinal"),
        dictgen::InsensitiveStr::Ascii("ssonial"),
        dictgen::InsensitiveStr::Ascii("ssoras"),
        dictgen::InsensitiveStr::Ascii("ssores"),
        dictgen::InsensitiveStr::Ascii("ssorin"),
        dictgen::InsensitiveStr::Ascii("ssorn"),
        dictgen::InsensitiveStr::Ascii("sssion"),
        dictgen::InsensitiveStr::Ascii("sssor"),
    ],
    values: &[
        &["profusion", "profession"],
        &["professional"],
        &["professionally"],
        &["professionals"],
        &["profession"],
        &["professionals"],
        &["professor"],
        &["professor"],
        &["professors"],
        &["professionalism"],
        &["professions"],
        &["professional"],
        &["professionals"],
        &["professionalism"],
        &["professionalism"],
        &["professionals"],
        &["professionalism"],
        &["professionalism"],
        &["professionally"],
        &["professional"],
        &["professionalism"],
        &["professionals"],
        &["professional"],
        &["professionalism"],
        &["professionals"],
        &["professionalism"],
        &["professionals"],
        &["professionals"],
        &["professors"],
        &["professors"],
        &["profession"],
        &["profession"],
        &["professions"],
        &["professors"],
    ],
    range: 3..=11,
};

static WORD_PROE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PROE_CHILDREN),
    value: None,
};

pub static WORD_PROE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("dural"),
        dictgen::InsensitiveStr::Ascii("dure"),
        dictgen::InsensitiveStr::Ascii("dures"),
        dictgen::InsensitiveStr::Ascii("jct"),
        dictgen::InsensitiveStr::Ascii("jcted"),
        dictgen::InsensitiveStr::Ascii("jcting"),
        dictgen::InsensitiveStr::Ascii("jction"),
        dictgen::InsensitiveStr::Ascii("pr"),
        dictgen::InsensitiveStr::Ascii("prly"),
        dictgen::InsensitiveStr::Ascii("prties"),
        dictgen::InsensitiveStr::Ascii("prty"),
        dictgen::InsensitiveStr::Ascii("rties"),
        dictgen::InsensitiveStr::Ascii("rty"),
        dictgen::InsensitiveStr::Ascii("ssing"),
    ],
    values: &[
        &["procedural"],
        &["procedure"],
        &["procedures"],
        &["project"],
        &["projected"],
        &["projecting"],
        &["projection"],
        &["proper"],
        &["properly"],
        &["properties"],
        &["property"],
        &["properties"],
        &["property", "poetry"],
        &["processing"],
    ],
    range: 2..=6,
};

static WORD_PROD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PROD_CHILDREN),
    value: None,
};

pub static WORD_PROD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ceding"),
        dictgen::InsensitiveStr::Ascii("cution"),
        dictgen::InsensitiveStr::Ascii("cutions"),
        dictgen::InsensitiveStr::Ascii("cuts"),
        dictgen::InsensitiveStr::Ascii("ecural"),
        dictgen::InsensitiveStr::Ascii("ecure"),
        dictgen::InsensitiveStr::Ascii("ecures"),
        dictgen::InsensitiveStr::Ascii("iction"),
        dictgen::InsensitiveStr::Ascii("ictions"),
        dictgen::InsensitiveStr::Ascii("ominantly"),
        dictgen::InsensitiveStr::Ascii("ucable"),
        dictgen::InsensitiveStr::Ascii("ucables"),
        dictgen::InsensitiveStr::Ascii("uccion"),
        dictgen::InsensitiveStr::Ascii("uceds"),
        dictgen::InsensitiveStr::Ascii("uceras"),
        dictgen::InsensitiveStr::Ascii("ucerats"),
        dictgen::InsensitiveStr::Ascii("uceres"),
        dictgen::InsensitiveStr::Ascii("ucirse"),
        dictgen::InsensitiveStr::Ascii("uciton"),
        dictgen::InsensitiveStr::Ascii("ucitons"),
        dictgen::InsensitiveStr::Ascii("ucted"),
        dictgen::InsensitiveStr::Ascii("uctie"),
        dictgen::InsensitiveStr::Ascii("uctin"),
        dictgen::InsensitiveStr::Ascii("ucting"),
        dictgen::InsensitiveStr::Ascii("uctino"),
        dictgen::InsensitiveStr::Ascii("uctioin"),
        dictgen::InsensitiveStr::Ascii("uctiviy"),
        dictgen::InsensitiveStr::Ascii("uctivo"),
        dictgen::InsensitiveStr::Ascii("uctivos"),
        dictgen::InsensitiveStr::Ascii("uctivty"),
        dictgen::InsensitiveStr::Ascii("uctivy"),
        dictgen::InsensitiveStr::Ascii("ucto"),
        dictgen::InsensitiveStr::Ascii("uctoin"),
        dictgen::InsensitiveStr::Ascii("uctos"),
        dictgen::InsensitiveStr::Ascii("ude"),
        dictgen::InsensitiveStr::Ascii("udes"),
        dictgen::InsensitiveStr::Ascii("ukt"),
        dictgen::InsensitiveStr::Ascii("uktion"),
        dictgen::InsensitiveStr::Ascii("uktions"),
        dictgen::InsensitiveStr::Ascii("uktive"),
        dictgen::InsensitiveStr::Ascii("uly"),
        dictgen::InsensitiveStr::Ascii("use"),
        dictgen::InsensitiveStr::Ascii("used"),
        dictgen::InsensitiveStr::Ascii("uses"),
        dictgen::InsensitiveStr::Ascii("utcion"),
    ],
    values: &[
        &["proceeding"],
        &["production"],
        &["productions"],
        &["products"],
        &["procedural"],
        &["procedure"],
        &["procedures"],
        &["production"],
        &["productions"],
        &["predominantly"],
        &["producible"],
        &["producibles", "producible"],
        &["production"],
        &["produces", "produced"],
        &["produces"],
        &["producers"],
        &["produces"],
        &["producers"],
        &["production"],
        &["productions"],
        &["produced"],
        &["productive"],
        &["productions"],
        &["production", "producing"],
        &["productions"],
        &["productions"],
        &["productivity"],
        &["production"],
        &["productions"],
        &["productivity"],
        &["productivity"],
        &["production"],
        &["productions"],
        &["products"],
        &["produce"],
        &["produces"],
        &["product"],
        &["production"],
        &["productions"],
        &["productive"],
        &["proudly"],
        &["produces", "produce"],
        &["produced"],
        &["produces"],
        &["productions"],
    ],
    range: 3..=9,
};

static WORD_PROC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_PROC_CHILDREN),
    value: None,
};

static WORD_PROC_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_PROCA_NODE),
    None,
    Some(&WORD_PROCC_NODE),
    None,
    Some(&WORD_PROCE_NODE),
    None,
    None,
    None,
    Some(&WORD_PROCI_NODE),
    None,
    None,
    Some(&WORD_PROCL_NODE),
    None,
    None,
    Some(&WORD_PROCO_NODE),
    None,
    None,
    Some(&WORD_PROCR_NODE),
    None,
    Some(&WORD_PROCT_NODE),
    Some(&WORD_PROCU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_PROCU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PROCU_CHILDREN),
    value: None,
};

pub static WORD_PROCU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ce"),
        dictgen::InsensitiveStr::Ascii("ced"),
        dictgen::InsensitiveStr::Ascii("cer"),
        dictgen::InsensitiveStr::Ascii("ces"),
        dictgen::InsensitiveStr::Ascii("cing"),
        dictgen::InsensitiveStr::Ascii("de"),
        dictgen::InsensitiveStr::Ascii("ded"),
        dictgen::InsensitiveStr::Ascii("der"),
        dictgen::InsensitiveStr::Ascii("des"),
        dictgen::InsensitiveStr::Ascii("ding"),
        dictgen::InsensitiveStr::Ascii("dures"),
    ],
    values: &[
        &["procure", "produce"],
        &["procured", "produced"],
        &["procurer", "producer"],
        &["procures", "produces"],
        &["procuring", "producing"],
        &["produce"],
        &["produced"],
        &["procurer", "producer"],
        &["procures", "produces"],
        &["procuring", "producing"],
        &["procedures"],
    ],
    range: 2..=5,
};

static WORD_PROCT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PROCT_CHILDREN),
    value: None,
};

pub static WORD_PROCT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ect"),
        dictgen::InsensitiveStr::Ascii("ected"),
        dictgen::InsensitiveStr::Ascii("ecting"),
        dictgen::InsensitiveStr::Ascii("ects"),
        dictgen::InsensitiveStr::Ascii("eted"),
    ],
    values: &[
        &["protect"],
        &["protected"],
        &["protecting"],
        &["protects"],
        &["protected"],
    ],
    range: 3..=6,
};

static WORD_PROCR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PROCR_CHILDREN),
    value: None,
};

pub static WORD_PROCR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ascinating"),
        dictgen::InsensitiveStr::Ascii("astenating"),
        dictgen::InsensitiveStr::Ascii("astiantion"),
        dictgen::InsensitiveStr::Ascii("astibating"),
        dictgen::InsensitiveStr::Ascii("astibation"),
        dictgen::InsensitiveStr::Ascii("astinarting"),
        dictgen::InsensitiveStr::Ascii("astinatin"),
        dictgen::InsensitiveStr::Ascii("astinationg"),
        dictgen::InsensitiveStr::Ascii("astinaton"),
        dictgen::InsensitiveStr::Ascii("astinazione"),
        dictgen::InsensitiveStr::Ascii("astion"),
        dictgen::InsensitiveStr::Ascii("astonating"),
        dictgen::InsensitiveStr::Ascii("astrinate"),
        dictgen::InsensitiveStr::Ascii("astrinated"),
        dictgen::InsensitiveStr::Ascii("astrinates"),
        dictgen::InsensitiveStr::Ascii("astrinating"),
        dictgen::InsensitiveStr::Ascii("eatin"),
        dictgen::InsensitiveStr::Ascii("estinating"),
        dictgen::InsensitiveStr::Ascii("estination"),
        dictgen::InsensitiveStr::Ascii("iation"),
    ],
    values: &[
        &["procrastinating"],
        &["procrastinating"],
        &["procrastination"],
        &["procrastinating"],
        &["procrastination"],
        &["procrastinating"],
        &["procrastination"],
        &["procrastinating"],
        &["procrastination"],
        &["procrastination"],
        &["procreation"],
        &["procrastinating"],
        &["procrastinate"],
        &["procrastinated"],
        &["procrastinates"],
        &["procrastinating"],
        &["procreation"],
        &["procrastinating"],
        &["procrastination"],
        &["procreation"],
    ],
    range: 5..=11,
};

static WORD_PROCO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PROCO_CHILDREN),
    value: None,
};

pub static WORD_PROCO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ess"),
        dictgen::InsensitiveStr::Ascii("essed"),
        dictgen::InsensitiveStr::Ascii("essing"),
        dictgen::InsensitiveStr::Ascii("nceived"),
        dictgen::InsensitiveStr::Ascii("tol"),
        dictgen::InsensitiveStr::Ascii("tols"),
    ],
    values: &[
        &["process"],
        &["processed"],
        &["processing"],
        &["preconceived"],
        &["protocol"],
        &["protocols"],
    ],
    range: 3..=7,
};

static WORD_PROCL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PROCL_CHILDREN),
    value: None,
};

pub static WORD_PROCL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aimation"),
        dictgen::InsensitiveStr::Ascii("am"),
        dictgen::InsensitiveStr::Ascii("amed"),
        dictgen::InsensitiveStr::Ascii("ami"),
        dictgen::InsensitiveStr::Ascii("amied"),
        dictgen::InsensitiveStr::Ascii("aming"),
        dictgen::InsensitiveStr::Ascii("iam"),
        dictgen::InsensitiveStr::Ascii("iamed"),
        dictgen::InsensitiveStr::Ascii("omation"),
    ],
    values: &[
        &["proclamation"],
        &["proclaim"],
        &["proclaimed"],
        &["proclaim"],
        &["proclaimed"],
        &["proclaiming"],
        &["proclaim"],
        &["proclaimed"],
        &["proclamation"],
    ],
    range: 2..=8,
};

static WORD_PROCI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PROCI_CHILDREN),
    value: None,
};

pub static WORD_PROCI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("de"),
        dictgen::InsensitiveStr::Ascii("ded"),
        dictgen::InsensitiveStr::Ascii("des"),
    ],
    values: &[&["provide"], &["provided"], &["provides"]],
    range: 2..=3,
};

static WORD_PROCE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_PROCE_CHILDREN),
    value: None,
};

static WORD_PROCE_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    Some(&WORD_PROCEC_NODE),
    Some(&WORD_PROCED_NODE),
    Some(&WORD_PROCEE_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_PROCEL_NODE),
    None,
    Some(&WORD_PROCEN_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_PROCES_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_PROCES_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PROCES_CHILDREN),
    value: Some(&["process"]),
};

pub static WORD_PROCES_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("d"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("ess"),
        dictgen::InsensitiveStr::Ascii("handler"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("or"),
        dictgen::InsensitiveStr::Ascii("ors"),
        dictgen::InsensitiveStr::Ascii("seed"),
        dictgen::InsensitiveStr::Ascii("sees"),
        dictgen::InsensitiveStr::Ascii("ser"),
        dictgen::InsensitiveStr::Ascii("sers"),
        dictgen::InsensitiveStr::Ascii("sesor"),
        dictgen::InsensitiveStr::Ascii("sess"),
        dictgen::InsensitiveStr::Ascii("sessing"),
        dictgen::InsensitiveStr::Ascii("seurs"),
        dictgen::InsensitiveStr::Ascii("sibg"),
        dictgen::InsensitiveStr::Ascii("sig"),
        dictgen::InsensitiveStr::Ascii("sinf"),
        dictgen::InsensitiveStr::Ascii("sore"),
        dictgen::InsensitiveStr::Ascii("sores"),
        dictgen::InsensitiveStr::Ascii("sos"),
        dictgen::InsensitiveStr::Ascii("spr"),
        dictgen::InsensitiveStr::Ascii("ss"),
        dictgen::InsensitiveStr::Ascii("ssed"),
        dictgen::InsensitiveStr::Ascii("sses"),
        dictgen::InsensitiveStr::Ascii("ssing"),
        dictgen::InsensitiveStr::Ascii("ssor"),
        dictgen::InsensitiveStr::Ascii("ssors"),
        dictgen::InsensitiveStr::Ascii("ure"),
        dictgen::InsensitiveStr::Ascii("ures"),
    ],
    values: &[
        &["proceeds"],
        &["proceeds", "processed"],
        &["processes"],
        &["processes"],
        &["processhandler"],
        &["processing"],
        &["processor"],
        &["processors"],
        &["processed"],
        &["processes"],
        &["processor"],
        &["processors"],
        &["processors"],
        &["processes"],
        &["processing"],
        &["processes"],
        &["processing"],
        &["processing"],
        &["processing"],
        &["processor"],
        &["processors"],
        &["processors"],
        &["processor"],
        &["processes", "process"],
        &["processed"],
        &["processes"],
        &["processing"],
        &["processors", "processor"],
        &["processors"],
        &["procedure"],
        &["procedures"],
    ],
    range: 1..=7,
};

static WORD_PROCEN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PROCEN_CHILDREN),
    value: None,
};

pub static WORD_PROCEN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("tual")],
    values: &[&["percentual"]],
    range: 4..=4,
};

static WORD_PROCEL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PROCEL_CHILDREN),
    value: None,
};

pub static WORD_PROCEL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ain"),
        dictgen::InsensitiveStr::Ascii("ains"),
    ],
    values: &[&["porcelain"], &["porcelains"]],
    range: 3..=4,
};

static WORD_PROCEE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PROCEE_CHILDREN),
    value: None,
};

pub static WORD_PROCEE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("deds"),
        dictgen::InsensitiveStr::Ascii("des"),
        dictgen::InsensitiveStr::Ascii("dure"),
        dictgen::InsensitiveStr::Ascii("dures"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("eded"),
        dictgen::InsensitiveStr::Ascii("eding"),
        dictgen::InsensitiveStr::Ascii("eds"),
        dictgen::InsensitiveStr::Ascii("edures"),
        dictgen::InsensitiveStr::Ascii("s"),
        dictgen::InsensitiveStr::Ascii("sed"),
        dictgen::InsensitiveStr::Ascii("sing"),
        dictgen::InsensitiveStr::Ascii("sor"),
    ],
    values: &[
        &["proceeds"],
        &["proceeds"],
        &["procedure"],
        &["procedures"],
        &["proceed"],
        &["proceeded"],
        &["proceeding"],
        &["proceeds"],
        &["procedures"],
        &["proceeds", "process"],
        &["processed"],
        &["proceeding"],
        &["processor"],
    ],
    range: 1..=6,
};

static WORD_PROCED_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PROCED_CHILDREN),
    value: None,
};

pub static WORD_PROCED_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ding"),
        dictgen::InsensitiveStr::Ascii("dings"),
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("er"),
        dictgen::InsensitiveStr::Ascii("eral"),
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("ger"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("ings"),
        dictgen::InsensitiveStr::Ascii("re"),
        dictgen::InsensitiveStr::Ascii("res"),
        dictgen::InsensitiveStr::Ascii("rual"),
        dictgen::InsensitiveStr::Ascii("ue"),
        dictgen::InsensitiveStr::Ascii("ureal"),
        dictgen::InsensitiveStr::Ascii("urial"),
        dictgen::InsensitiveStr::Ascii("urile"),
    ],
    values: &[
        &["proceeding"],
        &["proceedings"],
        &["proceed", "precede"],
        &["proceeded", "preceded"],
        &["procedure"],
        &["procedural"],
        &["proceeds", "precedes"],
        &["procedure"],
        &["proceeding", "preceding"],
        &["proceedings"],
        &["procedure"],
        &["procedures"],
        &["procedural"],
        &["procedure"],
        &["procedural"],
        &["procedural"],
        &["procedure"],
    ],
    range: 1..=5,
};

static WORD_PROCEC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PROCEC_CHILDREN),
    value: None,
};

pub static WORD_PROCEC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ess"),
        dictgen::InsensitiveStr::Ascii("ure"),
        dictgen::InsensitiveStr::Ascii("ures"),
    ],
    values: &[&["process", "processes"], &["procedure"], &["procedures"]],
    range: 3..=4,
};

static WORD_PROCC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PROCC_CHILDREN),
    value: None,
};

pub static WORD_PROCC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eding"),
        dictgen::InsensitiveStr::Ascii("edings"),
        dictgen::InsensitiveStr::Ascii("eed"),
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("esed"),
        dictgen::InsensitiveStr::Ascii("eses"),
        dictgen::InsensitiveStr::Ascii("esing"),
        dictgen::InsensitiveStr::Ascii("esor"),
        dictgen::InsensitiveStr::Ascii("esors"),
        dictgen::InsensitiveStr::Ascii("ess"),
        dictgen::InsensitiveStr::Ascii("essed"),
        dictgen::InsensitiveStr::Ascii("esses"),
        dictgen::InsensitiveStr::Ascii("essing"),
        dictgen::InsensitiveStr::Ascii("essor"),
        dictgen::InsensitiveStr::Ascii("essors"),
    ],
    values: &[
        &["proceeding"],
        &["proceedings"],
        &["proceed"],
        &["process"],
        &["processed"],
        &["processes"],
        &["processing"],
        &["processor"],
        &["processors"],
        &["process"],
        &["processed"],
        &["processes"],
        &["processing"],
        &["processor"],
        &["processors"],
    ],
    range: 2..=6,
};

static WORD_PROCA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PROCA_CHILDREN),
    value: None,
};

pub static WORD_PROCA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("lim"),
        dictgen::InsensitiveStr::Ascii("limed"),
        dictgen::InsensitiveStr::Ascii("strinating"),
        dictgen::InsensitiveStr::Ascii("strination"),
        dictgen::InsensitiveStr::Ascii("tive"),
    ],
    values: &[
        &["proclaim"],
        &["proclaimed"],
        &["procrastinating"],
        &["procrastination"],
        &["proactive"],
    ],
    range: 3..=10,
};

static WORD_PROB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PROB_CHILDREN),
    value: None,
};

pub static WORD_PROB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("abalistic"),
        dictgen::InsensitiveStr::Ascii("abaly"),
        dictgen::InsensitiveStr::Ascii("abe"),
        dictgen::InsensitiveStr::Ascii("abilaty"),
        dictgen::InsensitiveStr::Ascii("abilisitic"),
        dictgen::InsensitiveStr::Ascii("abiliste"),
        dictgen::InsensitiveStr::Ascii("abilite"),
        dictgen::InsensitiveStr::Ascii("abilites"),
        dictgen::InsensitiveStr::Ascii("abiliy"),
        dictgen::InsensitiveStr::Ascii("abillity"),
        dictgen::InsensitiveStr::Ascii("abilties"),
        dictgen::InsensitiveStr::Ascii("abilty"),
        dictgen::InsensitiveStr::Ascii("abily"),
        dictgen::InsensitiveStr::Ascii("ablay"),
        dictgen::InsensitiveStr::Ascii("ablies"),
        dictgen::InsensitiveStr::Ascii("ablistic"),
        dictgen::InsensitiveStr::Ascii("ablities"),
        dictgen::InsensitiveStr::Ascii("ablity"),
        dictgen::InsensitiveStr::Ascii("ablly"),
        dictgen::InsensitiveStr::Ascii("ablybe"),
        dictgen::InsensitiveStr::Ascii("aby"),
        dictgen::InsensitiveStr::Ascii("alby"),
        dictgen::InsensitiveStr::Ascii("alibity"),
        dictgen::InsensitiveStr::Ascii("aly"),
        dictgen::InsensitiveStr::Ascii("bably"),
        dictgen::InsensitiveStr::Ascii("bailities"),
        dictgen::InsensitiveStr::Ascii("baility"),
        dictgen::InsensitiveStr::Ascii("baly"),
        dictgen::InsensitiveStr::Ascii("bed"),
        dictgen::InsensitiveStr::Ascii("blem"),
        dictgen::InsensitiveStr::Ascii("blems"),
        dictgen::InsensitiveStr::Ascii("blez"),
        dictgen::InsensitiveStr::Ascii("blezs"),
        dictgen::InsensitiveStr::Ascii("bly"),
        dictgen::InsensitiveStr::Ascii("elm"),
        dictgen::InsensitiveStr::Ascii("elmatic"),
        dictgen::InsensitiveStr::Ascii("elms"),
        dictgen::InsensitiveStr::Ascii("em"),
        dictgen::InsensitiveStr::Ascii("erly"),
        dictgen::InsensitiveStr::Ascii("erty"),
        dictgen::InsensitiveStr::Ascii("lably"),
        dictgen::InsensitiveStr::Ascii("laem"),
        dictgen::InsensitiveStr::Ascii("laems"),
        dictgen::InsensitiveStr::Ascii("lamatic"),
        dictgen::InsensitiveStr::Ascii("le"),
        dictgen::InsensitiveStr::Ascii("leem"),
        dictgen::InsensitiveStr::Ascii("lemas"),
        dictgen::InsensitiveStr::Ascii("lematisch"),
        dictgen::InsensitiveStr::Ascii("leme"),
        dictgen::InsensitiveStr::Ascii("lemes"),
        dictgen::InsensitiveStr::Ascii("lemita"),
        dictgen::InsensitiveStr::Ascii("les"),
        dictgen::InsensitiveStr::Ascii("limatic"),
        dictgen::InsensitiveStr::Ascii("lme"),
        dictgen::InsensitiveStr::Ascii("lmes"),
        dictgen::InsensitiveStr::Ascii("lomatic"),
        dictgen::InsensitiveStr::Ascii("ly"),
    ],
    values: &[
        &["probabilistic"],
        &["probably"],
        &["probable"],
        &["probability"],
        &["probabilistic"],
        &["probabilities"],
        &["probabilities"],
        &["probabilities"],
        &["probability"],
        &["probability"],
        &["probabilities"],
        &["probability"],
        &["probability", "probably"],
        &["probably"],
        &["probable"],
        &["probabilistic"],
        &["probabilities"],
        &["probability"],
        &["probably"],
        &["probable"],
        &["probably"],
        &["probably"],
        &["probability"],
        &["probably"],
        &["probably"],
        &["probabilities"],
        &["probability"],
        &["probably"],
        &["probed"],
        &["problem"],
        &["problems"],
        &["problem"],
        &["problems"],
        &["probably"],
        &["problem"],
        &["problematic"],
        &["problems"],
        &["problem"],
        &["properly"],
        &["property", "properly"],
        &["probably"],
        &["problem"],
        &["problems"],
        &["problematic"],
        &["probe", "probably", "problem"],
        &["problem"],
        &["problems"],
        &["problematic"],
        &["problem"],
        &["problems"],
        &["problematic"],
        &["probes", "problems"],
        &["problematic"],
        &["problem"],
        &["problems"],
        &["problematic"],
        &["probably"],
    ],
    range: 2..=10,
};

static WORD_PROA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PROA_CHILDREN),
    value: None,
};

pub static WORD_PROA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ble"),
        dictgen::InsensitiveStr::Ascii("bly"),
        dictgen::InsensitiveStr::Ascii("ctivley"),
    ],
    values: &[&["probable"], &["probably"], &["proactive"]],
    range: 3..=7,
};

static WORD_PRM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PRM_CHILDREN),
    value: None,
};

pub static WORD_PRM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("itive"),
        dictgen::InsensitiveStr::Ascii("itives"),
        dictgen::InsensitiveStr::Ascii("opting"),
    ],
    values: &[&["primitive"], &["primitives"], &["prompting"]],
    range: 5..=6,
};

static WORD_PRJ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PRJ_CHILDREN),
    value: None,
};

pub static WORD_PRJ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ect"),
        dictgen::InsensitiveStr::Ascii("ecting"),
        dictgen::InsensitiveStr::Ascii("ection"),
        dictgen::InsensitiveStr::Ascii("ections"),
        dictgen::InsensitiveStr::Ascii("ects"),
    ],
    values: &[
        &["project"],
        &["projecting"],
        &["projection"],
        &["projections"],
        &["projects"],
    ],
    range: 3..=7,
};

static WORD_PRI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_PRI_CHILDREN),
    value: None,
};

static WORD_PRI_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_PRIA_NODE),
    None,
    Some(&WORD_PRIC_NODE),
    None,
    Some(&WORD_PRIE_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_PRIM_NODE),
    Some(&WORD_PRIN_NODE),
    Some(&WORD_PRIO_NODE),
    None,
    None,
    Some(&WORD_PRIR_NODE),
    Some(&WORD_PRIS_NODE),
    Some(&WORD_PRIT_NODE),
    None,
    Some(&WORD_PRIV_NODE),
    None,
    None,
    None,
    None,
];

static WORD_PRIV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PRIV_CHILDREN),
    value: None,
};

pub static WORD_PRIV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aledge"),
        dictgen::InsensitiveStr::Ascii("alege"),
        dictgen::InsensitiveStr::Ascii("aleged"),
        dictgen::InsensitiveStr::Ascii("aleges"),
        dictgen::InsensitiveStr::Ascii("aticed"),
        dictgen::InsensitiveStr::Ascii("atizied"),
        dictgen::InsensitiveStr::Ascii("aye"),
        dictgen::InsensitiveStr::Ascii("cy"),
        dictgen::InsensitiveStr::Ascii("de"),
        dictgen::InsensitiveStr::Ascii("elaged"),
        dictgen::InsensitiveStr::Ascii("elages"),
        dictgen::InsensitiveStr::Ascii("eldges"),
        dictgen::InsensitiveStr::Ascii("eledge"),
        dictgen::InsensitiveStr::Ascii("eledged"),
        dictgen::InsensitiveStr::Ascii("eledges"),
        dictgen::InsensitiveStr::Ascii("elege"),
        dictgen::InsensitiveStr::Ascii("eleged"),
        dictgen::InsensitiveStr::Ascii("eleges"),
        dictgen::InsensitiveStr::Ascii("elidge"),
        dictgen::InsensitiveStr::Ascii("elige"),
        dictgen::InsensitiveStr::Ascii("eliged"),
        dictgen::InsensitiveStr::Ascii("eliges"),
        dictgen::InsensitiveStr::Ascii("elleges"),
        dictgen::InsensitiveStr::Ascii("etized"),
        dictgen::InsensitiveStr::Ascii("iate"),
        dictgen::InsensitiveStr::Ascii("ide"),
        dictgen::InsensitiveStr::Ascii("ided"),
        dictgen::InsensitiveStr::Ascii("ides"),
        dictgen::InsensitiveStr::Ascii("iding"),
        dictgen::InsensitiveStr::Ascii("iew"),
        dictgen::InsensitiveStr::Ascii("ilage"),
        dictgen::InsensitiveStr::Ascii("ilaged"),
        dictgen::InsensitiveStr::Ascii("ilages"),
        dictgen::InsensitiveStr::Ascii("iledge"),
        dictgen::InsensitiveStr::Ascii("iledged"),
        dictgen::InsensitiveStr::Ascii("iledges"),
        dictgen::InsensitiveStr::Ascii("ilegde"),
        dictgen::InsensitiveStr::Ascii("ilegeds"),
        dictgen::InsensitiveStr::Ascii("ilegie"),
        dictgen::InsensitiveStr::Ascii("ilegied"),
        dictgen::InsensitiveStr::Ascii("ilegien"),
        dictgen::InsensitiveStr::Ascii("ilegier"),
        dictgen::InsensitiveStr::Ascii("ilegies"),
        dictgen::InsensitiveStr::Ascii("ilegs"),
        dictgen::InsensitiveStr::Ascii("ilidge"),
        dictgen::InsensitiveStr::Ascii("ilidged"),
        dictgen::InsensitiveStr::Ascii("ilidges"),
        dictgen::InsensitiveStr::Ascii("ilige"),
        dictgen::InsensitiveStr::Ascii("iliged"),
        dictgen::InsensitiveStr::Ascii("iliges"),
        dictgen::InsensitiveStr::Ascii("ious"),
        dictgen::InsensitiveStr::Ascii("iously"),
        dictgen::InsensitiveStr::Ascii("ision"),
        dictgen::InsensitiveStr::Ascii("isional"),
        dictgen::InsensitiveStr::Ascii("isions"),
        dictgen::InsensitiveStr::Ascii("itazed"),
        dictgen::InsensitiveStr::Ascii("itized"),
        dictgen::InsensitiveStr::Ascii("ledge"),
        dictgen::InsensitiveStr::Ascii("lege"),
        dictgen::InsensitiveStr::Ascii("leged"),
        dictgen::InsensitiveStr::Ascii("leges"),
        dictgen::InsensitiveStr::Ascii("te"),
    ],
    values: &[
        &["privilege"],
        &["privilege"],
        &["privileged"],
        &["privileges"],
        &["privatized"],
        &["privatized"],
        &["private"],
        &["privacy"],
        &["provide"],
        &["privileged"],
        &["privileges"],
        &["privileges"],
        &["privilege"],
        &["privileged"],
        &["privileges"],
        &["privilege"],
        &["privileged"],
        &["privileges"],
        &["privileged"],
        &["privilege"],
        &["privileged"],
        &["privileges"],
        &["privileges"],
        &["privatized"],
        &["private"],
        &["provide"],
        &["provided"],
        &["provides"],
        &["providing"],
        &["preview"],
        &["privilege"],
        &["privileged"],
        &["privileges"],
        &["privilege"],
        &["privileged"],
        &["privileges"],
        &["privileges"],
        &["privileges"],
        &["privilege"],
        &["privileged"],
        &["privilege"],
        &["privilege"],
        &["privilege"],
        &["privileges"],
        &["privilege"],
        &["privileged"],
        &["privileges"],
        &["privilege"],
        &["privileged"],
        &["privileges"],
        &["previous"],
        &["previously"],
        &["provision"],
        &["provisional"],
        &["provisions"],
        &["privatized"],
        &["privatized"],
        &["privilege"],
        &["privilege"],
        &["privileged"],
        &["privileges"],
        &["private"],
    ],
    range: 2..=7,
};

static WORD_PRIT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PRIT_CHILDREN),
    value: None,
};

pub static WORD_PRIT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ing")],
    values: &[&["printing"]],
    range: 3..=3,
};

static WORD_PRIS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PRIS_CHILDREN),
    value: Some(&["prise", "prism"]),
};

pub static WORD_PRIS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("itne"),
        dictgen::InsensitiveStr::Ascii("ten"),
    ],
    values: &[&["pristine"], &["pristine"]],
    range: 3..=4,
};

static WORD_PRIR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PRIR_CHILDREN),
    value: None,
};

pub static WORD_PRIR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ity"),
        dictgen::InsensitiveStr::Ascii("ority"),
    ],
    values: &[&["priority", "privity"], &["priority"]],
    range: 3..=5,
};

static WORD_PRIO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PRIO_CHILDREN),
    value: None,
};

pub static WORD_PRIO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("irties"),
        dictgen::InsensitiveStr::Ascii("irty"),
        dictgen::InsensitiveStr::Ascii("ratize"),
        dictgen::InsensitiveStr::Ascii("retize"),
        dictgen::InsensitiveStr::Ascii("ritice"),
        dictgen::InsensitiveStr::Ascii("ritie"),
        dictgen::InsensitiveStr::Ascii("ritied"),
        dictgen::InsensitiveStr::Ascii("ritities"),
        dictgen::InsensitiveStr::Ascii("ritity"),
        dictgen::InsensitiveStr::Ascii("ritiy"),
        dictgen::InsensitiveStr::Ascii("ritse"),
        dictgen::InsensitiveStr::Ascii("roties"),
        dictgen::InsensitiveStr::Ascii("rotize"),
        dictgen::InsensitiveStr::Ascii("rty"),
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("tise"),
        dictgen::InsensitiveStr::Ascii("tised"),
        dictgen::InsensitiveStr::Ascii("tising"),
        dictgen::InsensitiveStr::Ascii("tities"),
        dictgen::InsensitiveStr::Ascii("titize"),
        dictgen::InsensitiveStr::Ascii("tity"),
        dictgen::InsensitiveStr::Ascii("tized"),
        dictgen::InsensitiveStr::Ascii("tizing"),
        dictgen::InsensitiveStr::Ascii("ts"),
    ],
    values: &[
        &["priorities"],
        &["priority"],
        &["prioritize"],
        &["prioritize"],
        &["prioritize"],
        &["prioritize"],
        &["prioritize"],
        &["priorities"],
        &["priority"],
        &["priority"],
        &["priorities"],
        &["priorities"],
        &["prioritize"],
        &["priority"],
        &["prior"],
        &["prioritise"],
        &["prioritised"],
        &["prioritising"],
        &["priorities"],
        &["prioritize"],
        &["priority"],
        &["prioritized"],
        &["prioritizing"],
        &["priors"],
    ],
    range: 1..=8,
};

static WORD_PRIN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PRIN_CHILDREN),
    value: None,
};

pub static WORD_PRIN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cepals"),
        dictgen::InsensitiveStr::Ascii("ceple"),
        dictgen::InsensitiveStr::Ascii("ceples"),
        dictgen::InsensitiveStr::Ascii("cesas"),
        dictgen::InsensitiveStr::Ascii("ceses"),
        dictgen::InsensitiveStr::Ascii("cesess"),
        dictgen::InsensitiveStr::Ascii("cesss"),
        dictgen::InsensitiveStr::Ascii("cessses"),
        dictgen::InsensitiveStr::Ascii("cible"),
        dictgen::InsensitiveStr::Ascii("cibles"),
        dictgen::InsensitiveStr::Ascii("cila"),
        dictgen::InsensitiveStr::Ascii("cipales"),
        dictgen::InsensitiveStr::Ascii("cipalis"),
        dictgen::InsensitiveStr::Ascii("cipaly"),
        dictgen::InsensitiveStr::Ascii("cipas"),
        dictgen::InsensitiveStr::Ascii("cipels"),
        dictgen::InsensitiveStr::Ascii("cipial"),
        dictgen::InsensitiveStr::Ascii("cipias"),
        dictgen::InsensitiveStr::Ascii("cipielt"),
        dictgen::InsensitiveStr::Ascii("cipl"),
        dictgen::InsensitiveStr::Ascii("ciplaity"),
        dictgen::InsensitiveStr::Ascii("ciplas"),
        dictgen::InsensitiveStr::Ascii("ciply"),
        dictgen::InsensitiveStr::Ascii("cliple"),
        dictgen::InsensitiveStr::Ascii("d"),
        dictgen::InsensitiveStr::Ascii("f"),
        dictgen::InsensitiveStr::Ascii("g"),
        dictgen::InsensitiveStr::Ascii("ging"),
        dictgen::InsensitiveStr::Ascii("icipal"),
        dictgen::InsensitiveStr::Ascii("icpals"),
        dictgen::InsensitiveStr::Ascii("icple"),
        dictgen::InsensitiveStr::Ascii("icples"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("terest"),
        dictgen::InsensitiveStr::Ascii("tes"),
        dictgen::InsensitiveStr::Ascii("tting"),
    ],
    values: &[
        &["principals"],
        &["principle"],
        &["principles"],
        &["princess"],
        &["princess"],
        &["princesses"],
        &["princesses"],
        &["princesses"],
        &["principle"],
        &["principles"],
        &["principals"],
        &["principles"],
        &["principals"],
        &["principality"],
        &["principals"],
        &["principals"],
        &["principal"],
        &["principals"],
        &["principle"],
        &["principals"],
        &["principality"],
        &["principals"],
        &["principally"],
        &["principle"],
        &["print"],
        &["print", "printf", "sprintf"],
        &["print", "bring", "ping", "spring"],
        &["printing", "springing"],
        &["principal"],
        &["principals"],
        &["principle"],
        &["principles"],
        &["printing"],
        &["printers"],
        &["printers"],
        &["printing"],
    ],
    range: 1..=8,
};

static WORD_PRIM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PRIM_CHILDREN),
    value: None,
};

pub static WORD_PRIM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aires"),
        dictgen::InsensitiveStr::Ascii("airly"),
        dictgen::InsensitiveStr::Ascii("aray"),
        dictgen::InsensitiveStr::Ascii("arely"),
        dictgen::InsensitiveStr::Ascii("arilly"),
        dictgen::InsensitiveStr::Ascii("aris"),
        dictgen::InsensitiveStr::Ascii("arliy"),
        dictgen::InsensitiveStr::Ascii("arly"),
        dictgen::InsensitiveStr::Ascii("ative"),
        dictgen::InsensitiveStr::Ascii("atively"),
        dictgen::InsensitiveStr::Ascii("atives"),
        dictgen::InsensitiveStr::Ascii("ay"),
        dictgen::InsensitiveStr::Ascii("eter"),
        dictgen::InsensitiveStr::Ascii("evil"),
        dictgen::InsensitiveStr::Ascii("imitive"),
        dictgen::InsensitiveStr::Ascii("itave"),
        dictgen::InsensitiveStr::Ascii("itiv"),
        dictgen::InsensitiveStr::Ascii("itve"),
        dictgen::InsensitiveStr::Ascii("itves"),
        dictgen::InsensitiveStr::Ascii("ive"),
        dictgen::InsensitiveStr::Ascii("ordal"),
        dictgen::InsensitiveStr::Ascii("tiive"),
        dictgen::InsensitiveStr::Ascii("tive"),
        dictgen::InsensitiveStr::Ascii("tives"),
    ],
    values: &[
        &["primaries"],
        &["primarily"],
        &["primary"],
        &["primarily"],
        &["primarily"],
        &["primaries"],
        &["primarily"],
        &["primarily"],
        &["primitive"],
        &["primitively"],
        &["primitives"],
        &["primary"],
        &["perimeter"],
        &["primeval"],
        &["primitive"],
        &["primitive"],
        &["primitive"],
        &["primitive"],
        &["primitives"],
        &["primitive"],
        &["primordial"],
        &["primitive"],
        &["primitive"],
        &["primitives"],
    ],
    range: 2..=7,
};

static WORD_PRIE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PRIE_CHILDREN),
    value: None,
};

pub static WORD_PRIE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("mere"),
        dictgen::InsensitiveStr::Ascii("stes"),
        dictgen::InsensitiveStr::Ascii("sthod"),
        dictgen::InsensitiveStr::Ascii("stood"),
    ],
    values: &[
        &["premiere"],
        &["priests"],
        &["priesthood"],
        &["priesthood"],
    ],
    range: 4..=5,
};

static WORD_PRIC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PRIC_CHILDREN),
    value: None,
};

pub static WORD_PRIC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("inpals"),
        dictgen::InsensitiveStr::Ascii("ipal"),
        dictgen::InsensitiveStr::Ascii("iple"),
        dictgen::InsensitiveStr::Ascii("iples"),
        dictgen::InsensitiveStr::Ascii("ision"),
    ],
    values: &[
        &["principals"],
        &["principal"],
        &["principle"],
        &["principles"],
        &["precision"],
    ],
    range: 4..=6,
};

static WORD_PRIA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PRIA_CHILDREN),
    value: None,
};

pub static WORD_PRIA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("sed"),
        dictgen::InsensitiveStr::Ascii("ses"),
        dictgen::InsensitiveStr::Ascii("ve"),
    ],
    values: &[&["praised"], &["praises"], &["private"]],
    range: 2..=3,
};

static WORD_PRG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PRG_CHILDREN),
    value: None,
};

pub static WORD_PRG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ram")],
    values: &[&["program"]],
    range: 3..=3,
};

static WORD_PRF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PRF_CHILDREN),
    value: None,
};

pub static WORD_PRF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("er"),
        dictgen::InsensitiveStr::Ascii("erable"),
        dictgen::InsensitiveStr::Ascii("erables"),
        dictgen::InsensitiveStr::Ascii("erence"),
        dictgen::InsensitiveStr::Ascii("erred"),
    ],
    values: &[
        &["prefer"],
        &["preferable"],
        &["preferables", "preferable"],
        &["preference"],
        &["preferred"],
    ],
    range: 2..=7,
};

static WORD_PRE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_PRE_CHILDREN),
    value: None,
};

static WORD_PRE_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_PREA_NODE),
    Some(&WORD_PREB_NODE),
    Some(&WORD_PREC_NODE),
    Some(&WORD_PRED_NODE),
    Some(&WORD_PREE_NODE),
    Some(&WORD_PREF_NODE),
    Some(&WORD_PREG_NODE),
    Some(&WORD_PREH_NODE),
    Some(&WORD_PREI_NODE),
    Some(&WORD_PREJ_NODE),
    None,
    Some(&WORD_PREL_NODE),
    Some(&WORD_PREM_NODE),
    None,
    Some(&WORD_PREO_NODE),
    Some(&WORD_PREP_NODE),
    Some(&WORD_PREQ_NODE),
    Some(&WORD_PRER_NODE),
    Some(&WORD_PRES_NODE),
    Some(&WORD_PRET_NODE),
    None,
    Some(&WORD_PREV_NODE),
    Some(&WORD_PREW_NODE),
    Some(&WORD_PREX_NODE),
    None,
    Some(&WORD_PREZ_NODE),
];

static WORD_PREZ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PREZ_CHILDREN),
    value: None,
};

pub static WORD_PREZ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("idential")],
    values: &[&["presidential"]],
    range: 8..=8,
};

static WORD_PREX_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PREX_CHILDREN),
    value: None,
};

pub static WORD_PREX_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("isting"),
        dictgen::InsensitiveStr::Ascii("ixed"),
    ],
    values: &[&["preexisting"], &["prefixed"]],
    range: 4..=6,
};

static WORD_PREW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PREW_CHILDREN),
    value: None,
};

pub static WORD_PREW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("view")],
    values: &[&["preview"]],
    range: 4..=4,
};

static WORD_PREV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PREV_CHILDREN),
    value: None,
};

pub static WORD_PREV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ailaing"),
        dictgen::InsensitiveStr::Ascii("ailling"),
        dictgen::InsensitiveStr::Ascii("alecen"),
        dictgen::InsensitiveStr::Ascii("alente"),
        dictgen::InsensitiveStr::Ascii("antative"),
        dictgen::InsensitiveStr::Ascii("eiw"),
        dictgen::InsensitiveStr::Ascii("eiwed"),
        dictgen::InsensitiveStr::Ascii("eiwer"),
        dictgen::InsensitiveStr::Ascii("eiwers"),
        dictgen::InsensitiveStr::Ascii("eiwes"),
        dictgen::InsensitiveStr::Ascii("eiws"),
        dictgen::InsensitiveStr::Ascii("elance"),
        dictgen::InsensitiveStr::Ascii("elant"),
        dictgen::InsensitiveStr::Ascii("en"),
        dictgen::InsensitiveStr::Ascii("encion"),
        dictgen::InsensitiveStr::Ascii("end"),
        dictgen::InsensitiveStr::Ascii("entation"),
        dictgen::InsensitiveStr::Ascii("ente"),
        dictgen::InsensitiveStr::Ascii("entetive"),
        dictgen::InsensitiveStr::Ascii("entin"),
        dictgen::InsensitiveStr::Ascii("entitive"),
        dictgen::InsensitiveStr::Ascii("entitve"),
        dictgen::InsensitiveStr::Ascii("entivno"),
        dictgen::InsensitiveStr::Ascii("entivo"),
        dictgen::InsensitiveStr::Ascii("entors"),
        dictgen::InsensitiveStr::Ascii("erse"),
        dictgen::InsensitiveStr::Ascii("erses"),
        dictgen::InsensitiveStr::Ascii("ert"),
        dictgen::InsensitiveStr::Ascii("erve"),
        dictgen::InsensitiveStr::Ascii("erved"),
        dictgen::InsensitiveStr::Ascii("et"),
        dictgen::InsensitiveStr::Ascii("ew"),
        dictgen::InsensitiveStr::Ascii("ews"),
        dictgen::InsensitiveStr::Ascii("ial"),
        dictgen::InsensitiveStr::Ascii("ialing"),
        dictgen::InsensitiveStr::Ascii("ies"),
        dictgen::InsensitiveStr::Ascii("iewd"),
        dictgen::InsensitiveStr::Ascii("iious"),
        dictgen::InsensitiveStr::Ascii("ilege"),
        dictgen::InsensitiveStr::Ascii("ioous"),
        dictgen::InsensitiveStr::Ascii("ios"),
        dictgen::InsensitiveStr::Ascii("iosly"),
        dictgen::InsensitiveStr::Ascii("iosu"),
        dictgen::InsensitiveStr::Ascii("iosuly"),
        dictgen::InsensitiveStr::Ascii("iou"),
        dictgen::InsensitiveStr::Ascii("iouls"),
        dictgen::InsensitiveStr::Ascii("ioulsy"),
        dictgen::InsensitiveStr::Ascii("iouly"),
        dictgen::InsensitiveStr::Ascii("iouse"),
        dictgen::InsensitiveStr::Ascii("iousl"),
        dictgen::InsensitiveStr::Ascii("iousy"),
        dictgen::InsensitiveStr::Ascii("isou"),
        dictgen::InsensitiveStr::Ascii("isouly"),
        dictgen::InsensitiveStr::Ascii("isously"),
        dictgen::InsensitiveStr::Ascii("iuous"),
        dictgen::InsensitiveStr::Ascii("ius"),
        dictgen::InsensitiveStr::Ascii("ivous"),
        dictgen::InsensitiveStr::Ascii("iwes"),
        dictgen::InsensitiveStr::Ascii("oius"),
        dictgen::InsensitiveStr::Ascii("olence"),
        dictgen::InsensitiveStr::Ascii("ous"),
        dictgen::InsensitiveStr::Ascii("ously"),
    ],
    values: &[
        &["prevailing"],
        &["prevailing"],
        &["prevalence"],
        &["prevalence"],
        &["preventative"],
        &["preview"],
        &["previewed"],
        &["previewer"],
        &["previewers"],
        &["previews", "previewers"],
        &["previews"],
        &["prevalence"],
        &["prevalent"],
        &["prevent"],
        &["prevention"],
        &["prevent"],
        &["presentation"],
        &["prevented", "prevent"],
        &["preventative"],
        &["prevention"],
        &["preventative"],
        &["preventative"],
        &["prevention"],
        &["prevention"],
        &["prevents"],
        &["perverse"],
        &["preserves"],
        &["pervert"],
        &["preserve"],
        &["preserved"],
        &["prevent"],
        &["preview"],
        &["previews"],
        &["prevail"],
        &["prevailing"],
        &["previews"],
        &["previewed"],
        &["previous"],
        &["privilege"],
        &["previous"],
        &["previous"],
        &["previously"],
        &["previous"],
        &["previously"],
        &["previous"],
        &["previous"],
        &["previously"],
        &["previously"],
        &["previous"],
        &["previously"],
        &["previously"],
        &["previous"],
        &["previously"],
        &["previously"],
        &["previous"],
        &["previous"],
        &["previous"],
        &["previews"],
        &["previous"],
        &["prevalence"],
        &["previous"],
        &["previously"],
    ],
    range: 2..=8,
};

static WORD_PRET_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PRET_CHILDREN),
    value: None,
};

pub static WORD_PRET_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ador"),
        dictgen::InsensitiveStr::Ascii("aining"),
        dictgen::InsensitiveStr::Ascii("ains"),
        dictgen::InsensitiveStr::Ascii("ect"),
        dictgen::InsensitiveStr::Ascii("ected"),
        dictgen::InsensitiveStr::Ascii("ecting"),
        dictgen::InsensitiveStr::Ascii("ection"),
        dictgen::InsensitiveStr::Ascii("ects"),
        dictgen::InsensitiveStr::Ascii("edermined"),
        dictgen::InsensitiveStr::Ascii("encious"),
        dictgen::InsensitiveStr::Ascii("endas"),
        dictgen::InsensitiveStr::Ascii("endend"),
        dictgen::InsensitiveStr::Ascii("endendo"),
        dictgen::InsensitiveStr::Ascii("endias"),
        dictgen::InsensitiveStr::Ascii("ene"),
        dictgen::InsensitiveStr::Ascii("ens"),
        dictgen::InsensitiveStr::Ascii("ensious"),
        dictgen::InsensitiveStr::Ascii("ensje"),
        dictgen::InsensitiveStr::Ascii("entieus"),
        dictgen::InsensitiveStr::Ascii("entios"),
        dictgen::InsensitiveStr::Ascii("entous"),
        dictgen::InsensitiveStr::Ascii("inent"),
    ],
    values: &[
        &["predator"],
        &["pertaining"],
        &["pertains"],
        &["protect"],
        &["protected"],
        &["protecting"],
        &["protection"],
        &["protects"],
        &["predetermined"],
        &["pretentious"],
        &["pretends"],
        &["pretended"],
        &["pretended"],
        &["pretends"],
        &["pretense"],
        &["pretends"],
        &["pretentious"],
        &["pretense"],
        &["pretentious"],
        &["pretentious"],
        &["pretentious"],
        &["pertinent"],
    ],
    range: 3..=9,
};

static WORD_PRES_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_PRES_CHILDREN),
    value: None,
};

static WORD_PRES_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_PRESA_NODE),
    Some(&WORD_PRESB_NODE),
    Some(&WORD_PRESC_NODE),
    None,
    Some(&WORD_PRESE_NODE),
    None,
    None,
    Some(&WORD_PRESH_NODE),
    Some(&WORD_PRESI_NODE),
    None,
    None,
    None,
    Some(&WORD_PRESM_NODE),
    Some(&WORD_PRESN_NODE),
    Some(&WORD_PRESO_NODE),
    Some(&WORD_PRESP_NODE),
    None,
    Some(&WORD_PRESR_NODE),
    Some(&WORD_PRESS_NODE),
    Some(&WORD_PREST_NODE),
    Some(&WORD_PRESU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_PRESU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PRESU_CHILDREN),
    value: None,
};

pub static WORD_PRESU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ade"),
        dictgen::InsensitiveStr::Ascii("aded"),
        dictgen::InsensitiveStr::Ascii("ambly"),
        dictgen::InsensitiveStr::Ascii("asion"),
        dictgen::InsensitiveStr::Ascii("asive"),
        dictgen::InsensitiveStr::Ascii("de"),
        dictgen::InsensitiveStr::Ascii("mabely"),
        dictgen::InsensitiveStr::Ascii("mabley"),
        dictgen::InsensitiveStr::Ascii("maby"),
        dictgen::InsensitiveStr::Ascii("meably"),
        dictgen::InsensitiveStr::Ascii("mebly"),
        dictgen::InsensitiveStr::Ascii("mely"),
        dictgen::InsensitiveStr::Ascii("mendo"),
        dictgen::InsensitiveStr::Ascii("mibly"),
        dictgen::InsensitiveStr::Ascii("mpteous"),
        dictgen::InsensitiveStr::Ascii("mpton"),
        dictgen::InsensitiveStr::Ascii("mptous"),
        dictgen::InsensitiveStr::Ascii("mptuious"),
        dictgen::InsensitiveStr::Ascii("mptuos"),
        dictgen::InsensitiveStr::Ascii("mputous"),
    ],
    values: &[
        &["persuade"],
        &["persuaded"],
        &["presumably"],
        &["persuasion"],
        &["persuasive"],
        &["presumed"],
        &["presumably"],
        &["presumably"],
        &["presumably"],
        &["presumably"],
        &["presumably"],
        &["presumably"],
        &["presumed"],
        &["presumably"],
        &["presumptuous"],
        &["presumption"],
        &["presumptuous"],
        &["presumptuous"],
        &["presumptuous"],
        &["presumptuous"],
    ],
    range: 2..=8,
};

static WORD_PREST_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PREST_CHILDREN),
    value: None,
};

pub static WORD_PREST_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("egious"),
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("igeous"),
        dictgen::InsensitiveStr::Ascii("igieus"),
        dictgen::InsensitiveStr::Ascii("igios"),
        dictgen::InsensitiveStr::Ascii("igiosa"),
        dictgen::InsensitiveStr::Ascii("igiose"),
        dictgen::InsensitiveStr::Ascii("igiosi"),
        dictgen::InsensitiveStr::Ascii("igioso"),
        dictgen::InsensitiveStr::Ascii("igiu"),
        dictgen::InsensitiveStr::Ascii("igous"),
        dictgen::InsensitiveStr::Ascii("igue"),
        dictgen::InsensitiveStr::Ascii("iguous"),
    ],
    values: &[
        &["prestigious"],
        &["presets"],
        &["prestigious"],
        &["prestigious"],
        &["prestigious"],
        &["prestigious"],
        &["prestigious"],
        &["prestigious"],
        &["prestigious"],
        &["prestigious"],
        &["prestigious"],
        &["prestige"],
        &["prestigious"],
    ],
    range: 2..=6,
};

static WORD_PRESS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PRESS_CHILDREN),
    value: None,
};

pub static WORD_PRESS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("ent"),
        dictgen::InsensitiveStr::Ascii("entation"),
        dictgen::InsensitiveStr::Ascii("ented"),
        dictgen::InsensitiveStr::Ascii("ious"),
        dictgen::InsensitiveStr::Ascii("iously"),
        dictgen::InsensitiveStr::Ascii("iuos"),
        dictgen::InsensitiveStr::Ascii("iuosly"),
        dictgen::InsensitiveStr::Ascii("re"),
        dictgen::InsensitiveStr::Ascii("s"),
        dictgen::InsensitiveStr::Ascii("ue"),
        dictgen::InsensitiveStr::Ascii("ues"),
        dictgen::InsensitiveStr::Ascii("uming"),
        dictgen::InsensitiveStr::Ascii("ureing"),
    ],
    values: &[
        &["pressed", "press"],
        &["present"],
        &["presentation"],
        &["presented"],
        &["precious"],
        &["preciously"],
        &["precious"],
        &["preciously"],
        &["pressure"],
        &["press", "presses"],
        &["pressure"],
        &["pressures"],
        &["pressuring"],
        &["pressuring"],
    ],
    range: 1..=8,
};

static WORD_PRESR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PRESR_CHILDREN),
    value: None,
};

pub static WORD_PRESR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ciption"),
        dictgen::InsensitiveStr::Ascii("eved"),
    ],
    values: &[&["prescriptions"], &["preserved"]],
    range: 4..=7,
};

static WORD_PRESP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PRESP_CHILDREN),
    value: None,
};

pub static WORD_PRESP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ective"),
        dictgen::InsensitiveStr::Ascii("ectives"),
    ],
    values: &[&["perspective"], &["perspectives"]],
    range: 6..=7,
};

static WORD_PRESO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PRESO_CHILDREN),
    value: None,
};

pub static WORD_PRESO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("mption"),
        dictgen::InsensitiveStr::Ascii("nalized"),
        dictgen::InsensitiveStr::Ascii("nally"),
        dictgen::InsensitiveStr::Ascii("nas"),
        dictgen::InsensitiveStr::Ascii("nhood"),
    ],
    values: &[
        &["presumption"],
        &["personalized"],
        &["personally"],
        &["personas"],
        &["personhood"],
    ],
    range: 3..=7,
};

static WORD_PRESN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PRESN_CHILDREN),
    value: None,
};

pub static WORD_PRESN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("etation"),
        dictgen::InsensitiveStr::Ascii("tation"),
        dictgen::InsensitiveStr::Ascii("tations"),
    ],
    values: &[&["presentations"], &["presentation"], &["presentations"]],
    range: 6..=7,
};

static WORD_PRESM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PRESM_CHILDREN),
    value: None,
};

pub static WORD_PRESM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("issions")],
    values: &[&["permissions"]],
    range: 7..=7,
};

static WORD_PRESI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PRESI_CHILDREN),
    value: None,
};

pub static WORD_PRESI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cely"),
        dictgen::InsensitiveStr::Ascii("cion"),
        dictgen::InsensitiveStr::Ascii("dancy"),
        dictgen::InsensitiveStr::Ascii("dante"),
        dictgen::InsensitiveStr::Ascii("dencey"),
        dictgen::InsensitiveStr::Ascii("dencial"),
        dictgen::InsensitiveStr::Ascii("denital"),
        dictgen::InsensitiveStr::Ascii("denta"),
        dictgen::InsensitiveStr::Ascii("dentail"),
        dictgen::InsensitiveStr::Ascii("dental"),
        dictgen::InsensitiveStr::Ascii("dentcy"),
        dictgen::InsensitiveStr::Ascii("denty"),
        dictgen::InsensitiveStr::Ascii("deny"),
        dictgen::InsensitiveStr::Ascii("det"),
        dictgen::InsensitiveStr::Ascii("dunce"),
        dictgen::InsensitiveStr::Ascii("st"),
        dictgen::InsensitiveStr::Ascii("stable"),
        dictgen::InsensitiveStr::Ascii("stance"),
        dictgen::InsensitiveStr::Ascii("stant"),
        dictgen::InsensitiveStr::Ascii("stantly"),
        dictgen::InsensitiveStr::Ascii("sted"),
        dictgen::InsensitiveStr::Ascii("stence"),
        dictgen::InsensitiveStr::Ascii("stency"),
        dictgen::InsensitiveStr::Ascii("stent"),
        dictgen::InsensitiveStr::Ascii("stently"),
        dictgen::InsensitiveStr::Ascii("sting"),
        dictgen::InsensitiveStr::Ascii("stion"),
        dictgen::InsensitiveStr::Ascii("sts"),
        dictgen::InsensitiveStr::Ascii("tge"),
        dictgen::InsensitiveStr::Ascii("tgious"),
        dictgen::InsensitiveStr::Ascii("tigous"),
    ],
    values: &[
        &["precisely"],
        &["precision"],
        &["presidency"],
        &["presidents"],
        &["presidency"],
        &["presidential"],
        &["presidential"],
        &["presidential"],
        &["presidential"],
        &["presidential"],
        &["presidency"],
        &["presidency"],
        &["presidency"],
        &["presidents"],
        &["presidency"],
        &["persist"],
        &["persistable"],
        &["persistence"],
        &["persistent"],
        &["persistently"],
        &["persisted"],
        &["persistence"],
        &["persistency"],
        &["persistent"],
        &["persistently"],
        &["persisting"],
        &["precision"],
        &["persists"],
        &["prestige"],
        &["prestigious"],
        &["prestigious"],
    ],
    range: 2..=7,
};

static WORD_PRESH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PRESH_CHILDREN),
    value: None,
};

pub static WORD_PRESH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("is"),
        dictgen::InsensitiveStr::Ascii("isly"),
        dictgen::InsensitiveStr::Ascii("us"),
        dictgen::InsensitiveStr::Ascii("usly"),
    ],
    values: &[
        &["precious"],
        &["preciously"],
        &["precious"],
        &["preciously"],
    ],
    range: 2..=4,
};

static WORD_PRESE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PRESE_CHILDREN),
    value: None,
};

pub static WORD_PRESE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aring"),
        dictgen::InsensitiveStr::Ascii("arvation"),
        dictgen::InsensitiveStr::Ascii("arvations"),
        dictgen::InsensitiveStr::Ascii("arve"),
        dictgen::InsensitiveStr::Ascii("arved"),
        dictgen::InsensitiveStr::Ascii("arver"),
        dictgen::InsensitiveStr::Ascii("arves"),
        dictgen::InsensitiveStr::Ascii("arving"),
        dictgen::InsensitiveStr::Ascii("cuted"),
        dictgen::InsensitiveStr::Ascii("cution"),
        dictgen::InsensitiveStr::Ascii("d"),
        dictgen::InsensitiveStr::Ascii("dency"),
        dictgen::InsensitiveStr::Ascii("dential"),
        dictgen::InsensitiveStr::Ascii("dents"),
        dictgen::InsensitiveStr::Ascii("dintia"),
        dictgen::InsensitiveStr::Ascii("nece"),
        dictgen::InsensitiveStr::Ascii("ner"),
        dictgen::InsensitiveStr::Ascii("nning"),
        dictgen::InsensitiveStr::Ascii("ns"),
        dictgen::InsensitiveStr::Ascii("nse"),
        dictgen::InsensitiveStr::Ascii("nst"),
        dictgen::InsensitiveStr::Ascii("ntacion"),
        dictgen::InsensitiveStr::Ascii("ntaion"),
        dictgen::InsensitiveStr::Ascii("ntaional"),
        dictgen::InsensitiveStr::Ascii("ntaions"),
        dictgen::InsensitiveStr::Ascii("ntaiton"),
        dictgen::InsensitiveStr::Ascii("ntas"),
        dictgen::InsensitiveStr::Ascii("ntase"),
        dictgen::InsensitiveStr::Ascii("ntated"),
        dictgen::InsensitiveStr::Ascii("ntatin"),
        dictgen::InsensitiveStr::Ascii("ntato"),
        dictgen::InsensitiveStr::Ascii("ntatuion"),
        dictgen::InsensitiveStr::Ascii("ntes"),
        dictgen::InsensitiveStr::Ascii("ntion"),
        dictgen::InsensitiveStr::Ascii("ntors"),
        dictgen::InsensitiveStr::Ascii("rnt"),
        dictgen::InsensitiveStr::Ascii("rrved"),
        dictgen::InsensitiveStr::Ascii("rv"),
        dictgen::InsensitiveStr::Ascii("rvacion"),
        dictgen::InsensitiveStr::Ascii("rvare"),
        dictgen::InsensitiveStr::Ascii("rvating"),
        dictgen::InsensitiveStr::Ascii("rvativo"),
        dictgen::InsensitiveStr::Ascii("rvato"),
        dictgen::InsensitiveStr::Ascii("rvaton"),
        dictgen::InsensitiveStr::Ascii("rverd"),
        dictgen::InsensitiveStr::Ascii("rvered"),
        dictgen::InsensitiveStr::Ascii("st"),
        dictgen::InsensitiveStr::Ascii("tation"),
        dictgen::InsensitiveStr::Ascii("ve"),
        dictgen::InsensitiveStr::Ascii("ved"),
        dictgen::InsensitiveStr::Ascii("verance"),
        dictgen::InsensitiveStr::Ascii("verence"),
        dictgen::InsensitiveStr::Ascii("ves"),
        dictgen::InsensitiveStr::Ascii("ving"),
    ],
    values: &[
        &["preserving"],
        &["preservation"],
        &["preservations"],
        &["preserve"],
        &["preserved"],
        &["preserver"],
        &["preserves"],
        &["preserving"],
        &["persecuted"],
        &["persecution"],
        &["preset", "pressed"],
        &["presidency"],
        &["presidential"],
        &["presidents"],
        &["presidential"],
        &["presence"],
        &["presenter"],
        &["presenting"],
        &["presents"],
        &["presence"],
        &["presets"],
        &["presentation"],
        &["presentation"],
        &["presentational"],
        &["presentations"],
        &["presentations"],
        &["presents"],
        &["presents"],
        &["presented"],
        &["presentations"],
        &["presentation"],
        &["presentation"],
        &["presents"],
        &["presenting"],
        &["presents"],
        &["present"],
        &["preserved"],
        &["preserve"],
        &["preservation"],
        &["preserve"],
        &["preservation"],
        &["preservation"],
        &["preservation"],
        &["preservation"],
        &["preserved"],
        &["preserved"],
        &["presets"],
        &["presentation"],
        &["preserve"],
        &["preserved"],
        &["perseverance"],
        &["perseverance"],
        &["preserves"],
        &["preserving"],
    ],
    range: 1..=9,
};

static WORD_PRESC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PRESC_CHILDREN),
    value: None,
};

pub static WORD_PRESC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ients"),
        dictgen::InsensitiveStr::Ascii("irbed"),
        dictgen::InsensitiveStr::Ascii("irption"),
        dictgen::InsensitiveStr::Ascii("iuos"),
        dictgen::InsensitiveStr::Ascii("iuosly"),
        dictgen::InsensitiveStr::Ascii("ius"),
        dictgen::InsensitiveStr::Ascii("iusly"),
        dictgen::InsensitiveStr::Ascii("ribtion"),
        dictgen::InsensitiveStr::Ascii("ribtions"),
        dictgen::InsensitiveStr::Ascii("rie"),
        dictgen::InsensitiveStr::Ascii("ripcion"),
        dictgen::InsensitiveStr::Ascii("ripe"),
        dictgen::InsensitiveStr::Ascii("riped"),
        dictgen::InsensitiveStr::Ascii("riptionists"),
        dictgen::InsensitiveStr::Ascii("ripton"),
        dictgen::InsensitiveStr::Ascii("riptons"),
        dictgen::InsensitiveStr::Ascii("rition"),
        dictgen::InsensitiveStr::Ascii("ritions"),
        dictgen::InsensitiveStr::Ascii("ritpion"),
    ],
    values: &[
        &["presidents"],
        &["prescribed"],
        &["prescriptions"],
        &["precious"],
        &["preciously"],
        &["precious"],
        &["preciously"],
        &["prescription"],
        &["prescriptions"],
        &["prescribed"],
        &["prescription"],
        &["prescribe"],
        &["prescribed"],
        &["prescriptions"],
        &["prescription"],
        &["prescriptions"],
        &["prescription"],
        &["prescriptions"],
        &["prescriptions"],
    ],
    range: 3..=11,
};

static WORD_PRESB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PRESB_CHILDREN),
    value: None,
};

pub static WORD_PRESB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aterian"),
        dictgen::InsensitiveStr::Ascii("aterians"),
        dictgen::InsensitiveStr::Ascii("aterien"),
        dictgen::InsensitiveStr::Ascii("ateriens"),
    ],
    values: &[
        &["presbyterian"],
        &["presbyterians"],
        &["presbyterian"],
        &["presbyterians"],
    ],
    range: 7..=8,
};

static WORD_PRESA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PRESA_CHILDREN),
    value: None,
};

pub static WORD_PRESA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("nce")],
    values: &[&["presence"]],
    range: 3..=3,
};

static WORD_PRER_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PRER_CHILDREN),
    value: None,
};

pub static WORD_PRER_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("equesit"),
        dictgen::InsensitiveStr::Ascii("equesite"),
        dictgen::InsensitiveStr::Ascii("equesites"),
        dictgen::InsensitiveStr::Ascii("equisets"),
        dictgen::InsensitiveStr::Ascii("equisit"),
        dictgen::InsensitiveStr::Ascii("equisities"),
        dictgen::InsensitiveStr::Ascii("equisits"),
        dictgen::InsensitiveStr::Ascii("equiste"),
        dictgen::InsensitiveStr::Ascii("equisties"),
        dictgen::InsensitiveStr::Ascii("equistite"),
        dictgen::InsensitiveStr::Ascii("equites"),
        dictgen::InsensitiveStr::Ascii("equsite"),
        dictgen::InsensitiveStr::Ascii("equsites"),
        dictgen::InsensitiveStr::Ascii("iod"),
        dictgen::InsensitiveStr::Ascii("iodic"),
        dictgen::InsensitiveStr::Ascii("ogitive"),
        dictgen::InsensitiveStr::Ascii("ogotive"),
        dictgen::InsensitiveStr::Ascii("sistent"),
    ],
    values: &[
        &["prerequisite"],
        &["prerequisite"],
        &["prerequisites"],
        &["prerequisite"],
        &["prerequisite"],
        &["prerequisite", "prerequisites"],
        &["prerequisites"],
        &["prerequisite"],
        &["prerequisite"],
        &["prerequisite"],
        &["prerequisite"],
        &["prerequisite"],
        &["prerequisites"],
        &["period"],
        &["periodic"],
        &["prerogative"],
        &["prerogative"],
        &["persistent"],
    ],
    range: 3..=10,
};

static WORD_PREQ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PREQ_CHILDREN),
    value: None,
};

pub static WORD_PREQ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("euls"),
        dictgen::InsensitiveStr::Ascii("uisite"),
        dictgen::InsensitiveStr::Ascii("uisites"),
        dictgen::InsensitiveStr::Ascii("ules"),
    ],
    values: &[
        &["prequels"],
        &["prerequisite"],
        &["prerequisites"],
        &["prequels"],
    ],
    range: 4..=7,
};

static WORD_PREP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PREP_CHILDREN),
    value: None,
};

pub static WORD_PREP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("air"),
        dictgen::InsensitiveStr::Ascii("aird"),
        dictgen::InsensitiveStr::Ascii("aired"),
        dictgen::InsensitiveStr::Ascii("and"),
        dictgen::InsensitiveStr::Ascii("ar"),
        dictgen::InsensitiveStr::Ascii("aracion"),
        dictgen::InsensitiveStr::Ascii("arato"),
        dictgen::InsensitiveStr::Ascii("aretion"),
        dictgen::InsensitiveStr::Ascii("aretions"),
        dictgen::InsensitiveStr::Ascii("artion"),
        dictgen::InsensitiveStr::Ascii("artions"),
        dictgen::InsensitiveStr::Ascii("ate"),
        dictgen::InsensitiveStr::Ascii("ated"),
        dictgen::InsensitiveStr::Ascii("ates"),
        dictgen::InsensitiveStr::Ascii("atory"),
        dictgen::InsensitiveStr::Ascii("endet"),
        dictgen::InsensitiveStr::Ascii("endicular"),
        dictgen::InsensitiveStr::Ascii("ented"),
        dictgen::InsensitiveStr::Ascii("eration"),
        dictgen::InsensitiveStr::Ascii("erations"),
        dictgen::InsensitiveStr::Ascii("etrated"),
        dictgen::InsensitiveStr::Ascii("etrator"),
        dictgen::InsensitiveStr::Ascii("etrators"),
        dictgen::InsensitiveStr::Ascii("etually"),
        dictgen::InsensitiveStr::Ascii("etuate"),
        dictgen::InsensitiveStr::Ascii("etuated"),
        dictgen::InsensitiveStr::Ascii("etuates"),
        dictgen::InsensitiveStr::Ascii("etuating"),
        dictgen::InsensitiveStr::Ascii("onderence"),
        dictgen::InsensitiveStr::Ascii("oration"),
        dictgen::InsensitiveStr::Ascii("osterious"),
        dictgen::InsensitiveStr::Ascii("osters"),
        dictgen::InsensitiveStr::Ascii("osterus"),
        dictgen::InsensitiveStr::Ascii("ostorous"),
        dictgen::InsensitiveStr::Ascii("osturous"),
        dictgen::InsensitiveStr::Ascii("pend"),
        dictgen::InsensitiveStr::Ascii("pended"),
        dictgen::InsensitiveStr::Ascii("pendet"),
        dictgen::InsensitiveStr::Ascii("pent"),
        dictgen::InsensitiveStr::Ascii("pented"),
        dictgen::InsensitiveStr::Ascii("rare"),
        dictgen::InsensitiveStr::Ascii("rared"),
        dictgen::InsensitiveStr::Ascii("rares"),
        dictgen::InsensitiveStr::Ascii("raring"),
        dictgen::InsensitiveStr::Ascii("rend"),
        dictgen::InsensitiveStr::Ascii("rended"),
        dictgen::InsensitiveStr::Ascii("resent"),
        dictgen::InsensitiveStr::Ascii("resented"),
        dictgen::InsensitiveStr::Ascii("resents"),
        dictgen::InsensitiveStr::Ascii("roces"),
        dictgen::InsensitiveStr::Ascii("rocesing"),
        dictgen::InsensitiveStr::Ascii("rocesor"),
        dictgen::InsensitiveStr::Ascii("rocesser"),
        dictgen::InsensitiveStr::Ascii("rocessers"),
        dictgen::InsensitiveStr::Ascii("rocesssing"),
    ],
    values: &[
        &["prepare"],
        &["prepaid"],
        &["prepared"],
        &["prepend"],
        &["prepare"],
        &["preparation"],
        &["preparation"],
        &["preparation"],
        &["preparations"],
        &["preparation"],
        &["preparations"],
        &["prepare"],
        &["prepared"],
        &["prepares"],
        &["preparatory"],
        &["prepended"],
        &["perpendicular"],
        &["prepended"],
        &["preparation"],
        &["preparations"],
        &["perpetrated"],
        &["perpetrator"],
        &["perpetrators"],
        &["perpetually"],
        &["perpetuate"],
        &["perpetuated"],
        &["perpetuates"],
        &["perpetuating"],
        &["preponderance"],
        &["preparation"],
        &["preposterous"],
        &["preposterous"],
        &["preposterous"],
        &["preposterous"],
        &["preposterous"],
        &["prepend"],
        &["prepended"],
        &["prepended"],
        &["prepend", "preprent"],
        &["prepended"],
        &["prepare"],
        &["prepared"],
        &["prepares"],
        &["preparing"],
        &["prepend"],
        &["prepended"],
        &["represent"],
        &["represented"],
        &["represents"],
        &["preprocess"],
        &["preprocessing"],
        &["preprocessor"],
        &["preprocessor"],
        &["preprocessors"],
        &["preprocessing"],
    ],
    range: 2..=10,
};

static WORD_PREO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PREO_CHILDREN),
    value: None,
};

pub static WORD_PREO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cess"),
        dictgen::InsensitiveStr::Ascii("cessing"),
        dictgen::InsensitiveStr::Ascii("cupation"),
        dictgen::InsensitiveStr::Ascii("perty"),
        dictgen::InsensitiveStr::Ascii("rded"),
        dictgen::InsensitiveStr::Ascii("rderd"),
        dictgen::InsensitiveStr::Ascii("rderded"),
        dictgen::InsensitiveStr::Ascii("rderers"),
        dictgen::InsensitiveStr::Ascii("rderes"),
        dictgen::InsensitiveStr::Ascii("rdes"),
        dictgen::InsensitiveStr::Ascii("xide"),
    ],
    values: &[
        &["process"],
        &["processing", "preprocessing"],
        &["preoccupation"],
        &["property"],
        &["preordered"],
        &["preordered"],
        &["preordered"],
        &["preorders"],
        &["preorders"],
        &["preorders"],
        &["peroxide"],
    ],
    range: 4..=8,
};

static WORD_PREM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PREM_CHILDREN),
    value: None,
};

pub static WORD_PREM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("anent"),
        dictgen::InsensitiveStr::Ascii("anently"),
        dictgen::InsensitiveStr::Ascii("aturaly"),
        dictgen::InsensitiveStr::Ascii("aturelly"),
        dictgen::InsensitiveStr::Ascii("aturily"),
        dictgen::InsensitiveStr::Ascii("aturley"),
        dictgen::InsensitiveStr::Ascii("aturly"),
        dictgen::InsensitiveStr::Ascii("eir"),
        dictgen::InsensitiveStr::Ascii("eire"),
        dictgen::InsensitiveStr::Ascii("eired"),
        dictgen::InsensitiveStr::Ascii("esis"),
        dictgen::InsensitiveStr::Ascii("iare"),
        dictgen::InsensitiveStr::Ascii("iee"),
        dictgen::InsensitiveStr::Ascii("ilinary"),
        dictgen::InsensitiveStr::Ascii("illenial"),
        dictgen::InsensitiveStr::Ascii("inence"),
        dictgen::InsensitiveStr::Ascii("ines"),
        dictgen::InsensitiveStr::Ascii("ire"),
        dictgen::InsensitiveStr::Ascii("issible"),
        dictgen::InsensitiveStr::Ascii("ission"),
        dictgen::InsensitiveStr::Ascii("issions"),
        dictgen::InsensitiveStr::Ascii("it"),
        dictgen::InsensitiveStr::Ascii("its"),
        dictgen::InsensitiveStr::Ascii("ius"),
        dictgen::InsensitiveStr::Ascii("onasterians"),
        dictgen::InsensitiveStr::Ascii("ption"),
        dictgen::InsensitiveStr::Ascii("ptive"),
        dictgen::InsensitiveStr::Ascii("ptively"),
        dictgen::InsensitiveStr::Ascii("uim"),
        dictgen::InsensitiveStr::Ascii("uims"),
    ],
    values: &[
        &["permanent"],
        &["permanently"],
        &["prematurely"],
        &["prematurely"],
        &["prematurely"],
        &["prematurely"],
        &["prematurely"],
        &["premier"],
        &["premiere"],
        &["premiered"],
        &["premises"],
        &["premier"],
        &["premiere"],
        &["preliminary"],
        &["premillennial"],
        &["preeminence"],
        &["premise"],
        &["premier"],
        &["permissible"],
        &["permission"],
        &["permissions"],
        &["permit"],
        &["permits"],
        &["premiums"],
        &["premonstratensians"],
        &["preemption"],
        &["preemptive"],
        &["preemptively"],
        &["premium"],
        &["premiums"],
    ],
    range: 2..=11,
};

static WORD_PREL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PREL_CHILDREN),
    value: None,
};

pub static WORD_PREL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ayed"),
        dictgen::InsensitiveStr::Ascii("eminary"),
        dictgen::InsensitiveStr::Ascii("iferation"),
        dictgen::InsensitiveStr::Ascii("imanary"),
        dictgen::InsensitiveStr::Ascii("imenary"),
        dictgen::InsensitiveStr::Ascii("imiary"),
        dictgen::InsensitiveStr::Ascii("iminarly"),
        dictgen::InsensitiveStr::Ascii("imitary"),
    ],
    values: &[
        &["replayed"],
        &["preliminary"],
        &["proliferation"],
        &["preliminary"],
        &["preliminary"],
        &["preliminary"],
        &["preliminary"],
        &["preliminary"],
    ],
    range: 4..=9,
};

static WORD_PREJ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PREJ_CHILDREN),
    value: None,
};

pub static WORD_PREJ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ect"),
        dictgen::InsensitiveStr::Ascii("ected"),
        dictgen::InsensitiveStr::Ascii("ection"),
        dictgen::InsensitiveStr::Ascii("ections"),
        dictgen::InsensitiveStr::Ascii("ects"),
        dictgen::InsensitiveStr::Ascii("educed"),
        dictgen::InsensitiveStr::Ascii("educes"),
        dictgen::InsensitiveStr::Ascii("iduce"),
        dictgen::InsensitiveStr::Ascii("iduced"),
        dictgen::InsensitiveStr::Ascii("iduces"),
        dictgen::InsensitiveStr::Ascii("ucide"),
        dictgen::InsensitiveStr::Ascii("ucided"),
        dictgen::InsensitiveStr::Ascii("ucides"),
        dictgen::InsensitiveStr::Ascii("udgudice"),
        dictgen::InsensitiveStr::Ascii("udgudiced"),
        dictgen::InsensitiveStr::Ascii("udgudices"),
        dictgen::InsensitiveStr::Ascii("udgudicing"),
        dictgen::InsensitiveStr::Ascii("udicies"),
        dictgen::InsensitiveStr::Ascii("udis"),
        dictgen::InsensitiveStr::Ascii("uduced"),
        dictgen::InsensitiveStr::Ascii("uduces"),
    ],
    values: &[
        &["prefect", "project"],
        &["projected"],
        &["projection"],
        &["projections"],
        &["prefects", "projects"],
        &["prejudiced"],
        &["prejudices"],
        &["prejudice"],
        &["prejudiced"],
        &["prejudices"],
        &["prejudice"],
        &["prejudiced"],
        &["prejudices"],
        &["prejudice"],
        &["prejudiced"],
        &["prejudices"],
        &["prejudicing"],
        &["prejudice"],
        &["prejudices"],
        &["prejudiced"],
        &["prejudices"],
    ],
    range: 3..=10,
};

static WORD_PREI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PREI_CHILDREN),
    value: None,
};

pub static WORD_PREI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("mer"),
        dictgen::InsensitiveStr::Ascii("mere"),
        dictgen::InsensitiveStr::Ascii("meter"),
        dictgen::InsensitiveStr::Ascii("mum"),
        dictgen::InsensitiveStr::Ascii("mums"),
        dictgen::InsensitiveStr::Ascii("nitalization"),
        dictgen::InsensitiveStr::Ascii("nitalize"),
        dictgen::InsensitiveStr::Ascii("nitalized"),
        dictgen::InsensitiveStr::Ascii("nitalizes"),
        dictgen::InsensitiveStr::Ascii("nitalizing"),
        dictgen::InsensitiveStr::Ascii("nted"),
        dictgen::InsensitiveStr::Ascii("od"),
        dictgen::InsensitiveStr::Ascii("odic"),
        dictgen::InsensitiveStr::Ascii("pheral"),
        dictgen::InsensitiveStr::Ascii("pherals"),
        dictgen::InsensitiveStr::Ascii("sdents"),
        dictgen::InsensitiveStr::Ascii("sthood"),
        dictgen::InsensitiveStr::Ascii("sts"),
        dictgen::InsensitiveStr::Ascii("vew"),
        dictgen::InsensitiveStr::Ascii("vews"),
        dictgen::InsensitiveStr::Ascii("vous"),
    ],
    values: &[
        &["premier"],
        &["premiere"],
        &["perimeter"],
        &["premium"],
        &["premiums"],
        &["preinitialization"],
        &["preinitialize"],
        &["preinitialized"],
        &["preinitializes"],
        &["preinitializing"],
        &["printed"],
        &["period"],
        &["periodic"],
        &["peripheral"],
        &["peripherals"],
        &["presidents"],
        &["priesthood"],
        &["priests"],
        &["preview"],
        &["previews"],
        &["previous"],
    ],
    range: 2..=12,
};

static WORD_PREH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PREH_CHILDREN),
    value: None,
};

pub static WORD_PREH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("aps")],
    values: &[&["perhaps"]],
    range: 3..=3,
};

static WORD_PREG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PREG_CHILDREN),
    value: None,
};

pub static WORD_PREG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ancies"),
        dictgen::InsensitiveStr::Ascii("nance"),
        dictgen::InsensitiveStr::Ascii("nanices"),
        dictgen::InsensitiveStr::Ascii("nanies"),
        dictgen::InsensitiveStr::Ascii("nencies"),
        dictgen::InsensitiveStr::Ascii("orative"),
        dictgen::InsensitiveStr::Ascii("ressively"),
    ],
    values: &[
        &["pregnancies"],
        &["pregnancies"],
        &["pregnancies"],
        &["pregnancies"],
        &["pregnancies"],
        &["prerogative"],
        &["progressively"],
    ],
    range: 5..=9,
};

static WORD_PREF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_PREF_CHILDREN),
    value: None,
};

static WORD_PREF_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_PREFA_NODE),
    None,
    None,
    None,
    Some(&WORD_PREFE_NODE),
    Some(&WORD_PREFF_NODE),
    None,
    None,
    Some(&WORD_PREFI_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_PREFO_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_PREFO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PREFO_CHILDREN),
    value: None,
};

pub static WORD_PREFO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("rmance"),
        dictgen::InsensitiveStr::Ascii("rmances"),
        dictgen::InsensitiveStr::Ascii("rmer"),
        dictgen::InsensitiveStr::Ascii("rmers"),
    ],
    values: &[
        &["performance"],
        &["performances"],
        &["performer"],
        &["performers"],
    ],
    range: 4..=7,
};

static WORD_PREFI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PREFI_CHILDREN),
    value: None,
};

pub static WORD_PREFI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ces"),
        dictgen::InsensitiveStr::Ascii("ciency"),
        dictgen::InsensitiveStr::Ascii("ciensy"),
        dictgen::InsensitiveStr::Ascii("cient"),
        dictgen::InsensitiveStr::Ascii("ciently"),
        dictgen::InsensitiveStr::Ascii("cientsy"),
        dictgen::InsensitiveStr::Ascii("tler"),
        dictgen::InsensitiveStr::Ascii("tlered"),
        dictgen::InsensitiveStr::Ascii("tlering"),
        dictgen::InsensitiveStr::Ascii("tlers"),
    ],
    values: &[
        &["prefixes"],
        &["proficiency"],
        &["proficiency"],
        &["proficient"],
        &["proficiently"],
        &["proficiency"],
        &["prefilter"],
        &["prefiltered"],
        &["prefiltering"],
        &["prefilters"],
    ],
    range: 3..=7,
};

static WORD_PREFF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PREFF_CHILDREN),
    value: None,
};

pub static WORD_PREFF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("er"),
        dictgen::InsensitiveStr::Ascii("erable"),
        dictgen::InsensitiveStr::Ascii("erably"),
        dictgen::InsensitiveStr::Ascii("ered"),
        dictgen::InsensitiveStr::Ascii("ix"),
        dictgen::InsensitiveStr::Ascii("ixed"),
        dictgen::InsensitiveStr::Ascii("ixes"),
        dictgen::InsensitiveStr::Ascii("ixing"),
    ],
    values: &[
        &["prefer"],
        &["preferable"],
        &["preferably"],
        &["preferred"],
        &["prefix"],
        &["prefixed"],
        &["prefixes"],
        &["prefixing"],
    ],
    range: 2..=6,
};

static WORD_PREFE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PREFE_CHILDREN),
    value: None,
};

pub static WORD_PREFE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ctches"),
        dictgen::InsensitiveStr::Ascii("cth"),
        dictgen::InsensitiveStr::Ascii("ction"),
        dictgen::InsensitiveStr::Ascii("ctly"),
        dictgen::InsensitiveStr::Ascii("nce"),
        dictgen::InsensitiveStr::Ascii("nces"),
        dictgen::InsensitiveStr::Ascii("rabbly"),
        dictgen::InsensitiveStr::Ascii("rabely"),
        dictgen::InsensitiveStr::Ascii("rabley"),
        dictgen::InsensitiveStr::Ascii("rablly"),
        dictgen::InsensitiveStr::Ascii("rance"),
        dictgen::InsensitiveStr::Ascii("rances"),
        dictgen::InsensitiveStr::Ascii("rantial"),
        dictgen::InsensitiveStr::Ascii("ras"),
        dictgen::InsensitiveStr::Ascii("re"),
        dictgen::InsensitiveStr::Ascii("reable"),
        dictgen::InsensitiveStr::Ascii("reably"),
        dictgen::InsensitiveStr::Ascii("reble"),
        dictgen::InsensitiveStr::Ascii("recne"),
        dictgen::InsensitiveStr::Ascii("recnes"),
        dictgen::InsensitiveStr::Ascii("red"),
        dictgen::InsensitiveStr::Ascii("rencfe"),
        dictgen::InsensitiveStr::Ascii("rencfes"),
        dictgen::InsensitiveStr::Ascii("rend"),
        dictgen::InsensitiveStr::Ascii("rens"),
        dictgen::InsensitiveStr::Ascii("renser"),
        dictgen::InsensitiveStr::Ascii("rentail"),
        dictgen::InsensitiveStr::Ascii("rental"),
        dictgen::InsensitiveStr::Ascii("rente"),
        dictgen::InsensitiveStr::Ascii("rentes"),
        dictgen::InsensitiveStr::Ascii("renze"),
        dictgen::InsensitiveStr::Ascii("res"),
        dictgen::InsensitiveStr::Ascii("rible"),
        dictgen::InsensitiveStr::Ascii("ribly"),
        dictgen::InsensitiveStr::Ascii("ring"),
        dictgen::InsensitiveStr::Ascii("ris"),
        dictgen::InsensitiveStr::Ascii("rnce"),
        dictgen::InsensitiveStr::Ascii("rnces"),
        dictgen::InsensitiveStr::Ascii("rnec"),
        dictgen::InsensitiveStr::Ascii("rnece"),
        dictgen::InsensitiveStr::Ascii("rr"),
        dictgen::InsensitiveStr::Ascii("rrable"),
        dictgen::InsensitiveStr::Ascii("rrably"),
        dictgen::InsensitiveStr::Ascii("rrence"),
        dictgen::InsensitiveStr::Ascii("rrences"),
        dictgen::InsensitiveStr::Ascii("rrred"),
        dictgen::InsensitiveStr::Ascii("rrring"),
        dictgen::InsensitiveStr::Ascii("rrs"),
        dictgen::InsensitiveStr::Ascii("ssionalism"),
        dictgen::InsensitiveStr::Ascii("tchs"),
        dictgen::InsensitiveStr::Ascii("x"),
    ],
    values: &[
        &["prefetches"],
        &["prefetch"],
        &["perfection"],
        &["perfectly"],
        &["preference", "presence", "pretence"],
        &["preferences"],
        &["preferably"],
        &["preferable"],
        &["preferably"],
        &["preferably"],
        &["preference"],
        &["preferences"],
        &["preferential"],
        &["prefers"],
        &["prefer", "preferred"],
        &["preferable"],
        &["preferably"],
        &["preferable"],
        &["preference"],
        &["preferences"],
        &["preferred"],
        &["preference"],
        &["preferences"],
        &["preferred", "preference"],
        &["preferences"],
        &["preferences"],
        &["preferential"],
        &["preferential"],
        &["preference"],
        &["preferences"],
        &["preference"],
        &["prefers"],
        &["preferable"],
        &["preferably"],
        &["preferring"],
        &["prefers"],
        &["preference"],
        &["preferences"],
        &["preference"],
        &["preferences"],
        &["prefer"],
        &["preferable"],
        &["preferably"],
        &["preference"],
        &["preferences"],
        &["preferred"],
        &["preferring"],
        &["prefers"],
        &["professionalism"],
        &["prefetches"],
        &["prefix"],
    ],
    range: 1..=10,
};

static WORD_PREFA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PREFA_CHILDREN),
    value: None,
};

pub static WORD_PREFA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("rable"),
        dictgen::InsensitiveStr::Ascii("rably"),
    ],
    values: &[&["preferable"], &["preferably"]],
    range: 5..=5,
};

static WORD_PREE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PREE_CHILDREN),
    value: None,
};

pub static WORD_PREE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ceding"),
        dictgen::InsensitiveStr::Ascii("mptable"),
        dictgen::InsensitiveStr::Ascii("snt"),
        dictgen::InsensitiveStr::Ascii("sts"),
    ],
    values: &[&["preceding"], &["preemptible"], &["present"], &["presets"]],
    range: 3..=7,
};

static WORD_PRED_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_PRED_CHILDREN),
    value: None,
};

static WORD_PRED_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_PREDA_NODE),
    None,
    None,
    None,
    Some(&WORD_PREDE_NODE),
    Some(&WORD_PREDF_NODE),
    None,
    None,
    Some(&WORD_PREDI_NODE),
    Some(&WORD_PREDJ_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_PREDO_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_PREDU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_PREDU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PREDU_CHILDREN),
    value: None,
};

pub static WORD_PREDU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ction"),
        dictgen::InsensitiveStr::Ascii("ctive"),
        dictgen::InsensitiveStr::Ascii("jice"),
        dictgen::InsensitiveStr::Ascii("jiced"),
        dictgen::InsensitiveStr::Ascii("jices"),
    ],
    values: &[
        &["prediction"],
        &["predictive"],
        &["prejudice"],
        &["prejudiced"],
        &["prejudices"],
    ],
    range: 4..=5,
};

static WORD_PREDO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PREDO_CHILDREN),
    value: None,
};

pub static WORD_PREDO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cessor"),
        dictgen::InsensitiveStr::Ascii("cessors"),
        dictgen::InsensitiveStr::Ascii("menantly"),
        dictgen::InsensitiveStr::Ascii("miantly"),
        dictgen::InsensitiveStr::Ascii("minantely"),
        dictgen::InsensitiveStr::Ascii("minantley"),
        dictgen::InsensitiveStr::Ascii("minanty"),
        dictgen::InsensitiveStr::Ascii("minatly"),
        dictgen::InsensitiveStr::Ascii("minently"),
    ],
    values: &[
        &["predecessor"],
        &["predecessors"],
        &["predominantly"],
        &["predominately"],
        &["predominantly"],
        &["predominantly"],
        &["predominantly"],
        &["predominantly"],
        &["predominantly"],
    ],
    range: 6..=9,
};

static WORD_PREDJ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PREDJ_CHILDREN),
    value: None,
};

pub static WORD_PREDJ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("uice"),
        dictgen::InsensitiveStr::Ascii("uiced"),
        dictgen::InsensitiveStr::Ascii("uices"),
    ],
    values: &[&["prejudice"], &["prejudiced"], &["prejudices"]],
    range: 4..=5,
};

static WORD_PREDI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PREDI_CHILDREN),
    value: None,
};

pub static WORD_PREDI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cat"),
        dictgen::InsensitiveStr::Ascii("catble"),
        dictgen::InsensitiveStr::Ascii("ccion"),
        dictgen::InsensitiveStr::Ascii("cement"),
        dictgen::InsensitiveStr::Ascii("cessor"),
        dictgen::InsensitiveStr::Ascii("cessors"),
        dictgen::InsensitiveStr::Ascii("ceted"),
        dictgen::InsensitiveStr::Ascii("ciment"),
        dictgen::InsensitiveStr::Ascii("ciotn"),
        dictgen::InsensitiveStr::Ascii("cited"),
        dictgen::InsensitiveStr::Ascii("citng"),
        dictgen::InsensitiveStr::Ascii("citon"),
        dictgen::InsensitiveStr::Ascii("citons"),
        dictgen::InsensitiveStr::Ascii("citve"),
        dictgen::InsensitiveStr::Ascii("ckted"),
        dictgen::InsensitiveStr::Ascii("ctave"),
        dictgen::InsensitiveStr::Ascii("cte"),
        dictgen::InsensitiveStr::Ascii("ctible"),
        dictgen::InsensitiveStr::Ascii("ctie"),
        dictgen::InsensitiveStr::Ascii("ctin"),
        dictgen::InsensitiveStr::Ascii("ctious"),
        dictgen::InsensitiveStr::Ascii("ctivo"),
        dictgen::InsensitiveStr::Ascii("ctment"),
        dictgen::InsensitiveStr::Ascii("ctons"),
        dictgen::InsensitiveStr::Ascii("fined"),
        dictgen::InsensitiveStr::Ascii("sposte"),
        dictgen::InsensitiveStr::Ascii("termined"),
    ],
    values: &[
        &["predict", "predicate"],
        &["predictable"],
        &["prediction"],
        &["predicament"],
        &["predecessor"],
        &["predecessors"],
        &["predicated"],
        &["predicament"],
        &["prediction"],
        &["predicated"],
        &["predicting"],
        &["prediction"],
        &["predictions"],
        &["predictive"],
        &["predicated"],
        &["predictive"],
        &["predictive", "predicted"],
        &["predictable"],
        &["predictive"],
        &["prediction"],
        &["predictions"],
        &["prediction"],
        &["predicament"],
        &["predictions"],
        &["predefined"],
        &["predisposed"],
        &["predetermined"],
    ],
    range: 3..=8,
};

static WORD_PREDF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PREDF_CHILDREN),
    value: None,
};

pub static WORD_PREDF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ined")],
    values: &[&["predefined"]],
    range: 4..=4,
};

static WORD_PREDE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PREDE_CHILDREN),
    value: None,
};

pub static WORD_PREDE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cated"),
        dictgen::InsensitiveStr::Ascii("ccesors"),
        dictgen::InsensitiveStr::Ascii("cence"),
        dictgen::InsensitiveStr::Ascii("cesor"),
        dictgen::InsensitiveStr::Ascii("cesores"),
        dictgen::InsensitiveStr::Ascii("cesors"),
        dictgen::InsensitiveStr::Ascii("cesser"),
        dictgen::InsensitiveStr::Ascii("cessores"),
        dictgen::InsensitiveStr::Ascii("clarnig"),
        dictgen::InsensitiveStr::Ascii("ction"),
        dictgen::InsensitiveStr::Ascii("ctions"),
        dictgen::InsensitiveStr::Ascii("ctive"),
        dictgen::InsensitiveStr::Ascii("dence"),
        dictgen::InsensitiveStr::Ascii("fiend"),
        dictgen::InsensitiveStr::Ascii("fiened"),
        dictgen::InsensitiveStr::Ascii("fiined"),
        dictgen::InsensitiveStr::Ascii("fineds"),
        dictgen::InsensitiveStr::Ascii("scesor"),
        dictgen::InsensitiveStr::Ascii("scesors"),
        dictgen::InsensitiveStr::Ascii("sessor"),
        dictgen::InsensitiveStr::Ascii("sposed"),
        dictgen::InsensitiveStr::Ascii("ssecor"),
        dictgen::InsensitiveStr::Ascii("ssecors"),
        dictgen::InsensitiveStr::Ascii("ssor"),
        dictgen::InsensitiveStr::Ascii("termiend"),
        dictgen::InsensitiveStr::Ascii("termind"),
        dictgen::InsensitiveStr::Ascii("terminded"),
        dictgen::InsensitiveStr::Ascii("tirmined"),
    ],
    values: &[
        &["predicated"],
        &["predecessor"],
        &["precedence"],
        &["predecessor"],
        &["predecessor"],
        &["predecessors"],
        &["predecessor"],
        &["predecessors"],
        &["predeclaring"],
        &["prediction"],
        &["predictions"],
        &["predictive"],
        &["precedence"],
        &["predefined"],
        &["predefined"],
        &["predefined"],
        &["predefined"],
        &["predecessors"],
        &["predecessors"],
        &["predecessors"],
        &["predisposed"],
        &["predecessor"],
        &["predecessors"],
        &["predecessor"],
        &["predetermined"],
        &["predetermined"],
        &["predetermined"],
        &["predetermined"],
    ],
    range: 4..=9,
};

static WORD_PREDA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PREDA_CHILDREN),
    value: None,
};

pub static WORD_PREDA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cessor"),
        dictgen::InsensitiveStr::Ascii("cessors"),
        dictgen::InsensitiveStr::Ascii("tobr"),
    ],
    values: &[&["predecessor"], &["predecessors"], &["predator"]],
    range: 4..=7,
};

static WORD_PREC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_PREC_CHILDREN),
    value: None,
};

static WORD_PREC_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_PRECA_NODE),
    None,
    Some(&WORD_PRECC_NODE),
    Some(&WORD_PRECD_NODE),
    Some(&WORD_PRECE_NODE),
    None,
    None,
    None,
    Some(&WORD_PRECI_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_PRECO_NODE),
    None,
    None,
    Some(&WORD_PRECR_NODE),
    Some(&WORD_PRECS_NODE),
    None,
    Some(&WORD_PRECU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_PRECU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PRECU_CHILDREN),
    value: None,
};

pub static WORD_PRECU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ation"),
        dictgen::InsensitiveStr::Ascii("ations"),
        dictgen::InsensitiveStr::Ascii("lde"),
        dictgen::InsensitiveStr::Ascii("lded"),
        dictgen::InsensitiveStr::Ascii("ldes"),
        dictgen::InsensitiveStr::Ascii("mputed"),
        dictgen::InsensitiveStr::Ascii("rors"),
        dictgen::InsensitiveStr::Ascii("rosr"),
        dictgen::InsensitiveStr::Ascii("rser"),
        dictgen::InsensitiveStr::Ascii("ssion"),
        dictgen::InsensitiveStr::Ascii("ssions"),
    ],
    values: &[
        &["precautions", "precaution"],
        &["precautions"],
        &["preclude"],
        &["precluded"],
        &["precludes"],
        &["precomputed"],
        &["precursor"],
        &["precursor"],
        &["precursor"],
        &["percussion"],
        &["percussions"],
    ],
    range: 3..=6,
};

static WORD_PRECS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PRECS_CHILDREN),
    value: None,
};

pub static WORD_PRECS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ion"),
        dictgen::InsensitiveStr::Ascii("ions"),
    ],
    values: &[&["precision"], &["precisions"]],
    range: 3..=4,
};

static WORD_PRECR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PRECR_CHILDREN),
    value: None,
};

pub static WORD_PRECR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("astination")],
    values: &[&["procrastination"]],
    range: 10..=10,
};

static WORD_PRECO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PRECO_CHILDREN),
    value: None,
};

pub static WORD_PRECO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("muted"),
        dictgen::InsensitiveStr::Ascii("nceieved"),
        dictgen::InsensitiveStr::Ascii("nceved"),
        dictgen::InsensitiveStr::Ascii("ncieve"),
        dictgen::InsensitiveStr::Ascii("nditoner"),
        dictgen::InsensitiveStr::Ascii("nditoners"),
        dictgen::InsensitiveStr::Ascii("ndtion"),
        dictgen::InsensitiveStr::Ascii("ndtioner"),
        dictgen::InsensitiveStr::Ascii("ndtioners"),
        dictgen::InsensitiveStr::Ascii("ndtionner"),
        dictgen::InsensitiveStr::Ascii("ndtionners"),
        dictgen::InsensitiveStr::Ascii("ndtions"),
        dictgen::InsensitiveStr::Ascii("nfiged"),
        dictgen::InsensitiveStr::Ascii("nveived"),
    ],
    values: &[
        &["precomputed"],
        &["preconceived"],
        &["preconceived"],
        &["preconceived"],
        &["preconditioner"],
        &["preconditioners"],
        &["precondition"],
        &["preconditioner"],
        &["preconditioners"],
        &["preconditioner"],
        &["preconditioners"],
        &["preconditions"],
        &["preconfigured"],
        &["preconceived"],
    ],
    range: 5..=10,
};

static WORD_PRECI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PRECI_CHILDREN),
    value: None,
};

pub static WORD_PRECI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ce"),
        dictgen::InsensitiveStr::Ascii("cion"),
        dictgen::InsensitiveStr::Ascii("dence"),
        dictgen::InsensitiveStr::Ascii("ding"),
        dictgen::InsensitiveStr::Ascii("esly"),
        dictgen::InsensitiveStr::Ascii("selly"),
        dictgen::InsensitiveStr::Ascii("sie"),
        dictgen::InsensitiveStr::Ascii("sily"),
        dictgen::InsensitiveStr::Ascii("sionn"),
        dictgen::InsensitiveStr::Ascii("sision"),
        dictgen::InsensitiveStr::Ascii("sley"),
        dictgen::InsensitiveStr::Ascii("sly"),
        dictgen::InsensitiveStr::Ascii("son"),
        dictgen::InsensitiveStr::Ascii("sou"),
        dictgen::InsensitiveStr::Ascii("ssion"),
        dictgen::InsensitiveStr::Ascii("ze"),
    ],
    values: &[
        &["precise"],
        &["precision"],
        &["precedence"],
        &["preceding", "presiding"],
        &["precisely"],
        &["precisely"],
        &["precise"],
        &["precisely"],
        &["precision"],
        &["precision"],
        &["precisely"],
        &["precisely"],
        &["precision"],
        &["precious"],
        &["precision", "percussion", "precession"],
        &["precise"],
    ],
    range: 2..=6,
};

static WORD_PRECE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PRECE_CHILDREN),
    value: None,
};

pub static WORD_PRECE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cessor"),
        dictgen::InsensitiveStr::Ascii("d"),
        dictgen::InsensitiveStr::Ascii("dance"),
        dictgen::InsensitiveStr::Ascii("deed"),
        dictgen::InsensitiveStr::Ascii("dencs"),
        dictgen::InsensitiveStr::Ascii("dense"),
        dictgen::InsensitiveStr::Ascii("dessor"),
        dictgen::InsensitiveStr::Ascii("dessors"),
        dictgen::InsensitiveStr::Ascii("ds"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("eded"),
        dictgen::InsensitiveStr::Ascii("eding"),
        dictgen::InsensitiveStr::Ascii("eds"),
        dictgen::InsensitiveStr::Ascii("ision"),
        dictgen::InsensitiveStr::Ascii("ived"),
        dictgen::InsensitiveStr::Ascii("nce"),
        dictgen::InsensitiveStr::Ascii("ndance"),
        dictgen::InsensitiveStr::Ascii("ndances"),
        dictgen::InsensitiveStr::Ascii("nde"),
        dictgen::InsensitiveStr::Ascii("ndece"),
        dictgen::InsensitiveStr::Ascii("ndeces"),
        dictgen::InsensitiveStr::Ascii("ndence"),
        dictgen::InsensitiveStr::Ascii("ndences"),
        dictgen::InsensitiveStr::Ascii("ndencies"),
        dictgen::InsensitiveStr::Ascii("ndent"),
        dictgen::InsensitiveStr::Ascii("ndes"),
        dictgen::InsensitiveStr::Ascii("nding"),
        dictgen::InsensitiveStr::Ascii("nds"),
        dictgen::InsensitiveStr::Ascii("nence"),
        dictgen::InsensitiveStr::Ascii("nences"),
        dictgen::InsensitiveStr::Ascii("nse"),
        dictgen::InsensitiveStr::Ascii("nt"),
        dictgen::InsensitiveStr::Ascii("ntage"),
        dictgen::InsensitiveStr::Ascii("ntages"),
        dictgen::InsensitiveStr::Ascii("ntile"),
        dictgen::InsensitiveStr::Ascii("ntiles"),
        dictgen::InsensitiveStr::Ascii("sion"),
        dictgen::InsensitiveStr::Ascii("ssing"),
        dictgen::InsensitiveStr::Ascii("ssor"),
    ],
    values: &[
        &["predecessor"],
        &["precede"],
        &["precedence"],
        &["preceded"],
        &["precedence"],
        &["precedence"],
        &["predecessor"],
        &["predecessors"],
        &["precedes"],
        &["precede", "proceed"],
        &["preceded", "proceeded"],
        &["preceding", "proceeding"],
        &["precedes", "proceeds"],
        &["precision"],
        &["perceived"],
        &["presence"],
        &["precedence"],
        &["precedences"],
        &["precedence"],
        &["precedence"],
        &["precedences"],
        &["precedence"],
        &["precedences"],
        &["precedences"],
        &["precedent"],
        &["precedences"],
        &["preceding"],
        &["precedence"],
        &["preference", "precedence"],
        &["preferences"],
        &["presence"],
        &["percent", "prescient"],
        &["percentage"],
        &["percentages"],
        &["percentile"],
        &["percentiles"],
        &["precession", "precision"],
        &["processing"],
        &["predecessor", "processor"],
    ],
    range: 1..=8,
};

static WORD_PRECD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PRECD_CHILDREN),
    value: None,
};

pub static WORD_PRECD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ing")],
    values: &[&["preceding"]],
    range: 3..=3,
};

static WORD_PRECC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PRECC_CHILDREN),
    value: None,
};

pub static WORD_PRECC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("eding")],
    values: &[&["preceding"]],
    range: 5..=5,
};

static WORD_PRECA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PRECA_CHILDREN),
    value: None,
};

pub static WORD_PRECA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cheed"),
        dictgen::InsensitiveStr::Ascii("ucion"),
        dictgen::InsensitiveStr::Ascii("usion"),
        dictgen::InsensitiveStr::Ascii("usions"),
        dictgen::InsensitiveStr::Ascii("utios"),
    ],
    values: &[
        &["precached"],
        &["precaution"],
        &["precaution"],
        &["precautions"],
        &["precautions"],
    ],
    range: 5..=6,
};

static WORD_PREB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PREB_CHILDREN),
    value: None,
};

pub static WORD_PREB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ious")],
    values: &[&["previous"]],
    range: 4..=4,
};

static WORD_PREA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PREA_CHILDREN),
    value: None,
};

pub static WORD_PREA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("dtor"),
        dictgen::InsensitiveStr::Ascii("dtors"),
        dictgen::InsensitiveStr::Ascii("llocationg"),
        dictgen::InsensitiveStr::Ascii("locate"),
        dictgen::InsensitiveStr::Ascii("located"),
        dictgen::InsensitiveStr::Ascii("locates"),
        dictgen::InsensitiveStr::Ascii("locating"),
        dictgen::InsensitiveStr::Ascii("mbule"),
        dictgen::InsensitiveStr::Ascii("mde"),
        dictgen::InsensitiveStr::Ascii("mle"),
        dictgen::InsensitiveStr::Ascii("mple"),
        dictgen::InsensitiveStr::Ascii("orocessing"),
        dictgen::InsensitiveStr::Ascii("pared"),
        dictgen::InsensitiveStr::Ascii("pre"),
        dictgen::InsensitiveStr::Ascii("prooved"),
    ],
    values: &[
        &["predator"],
        &["predators"],
        &["preallocating", "preallocation"],
        &["preallocate"],
        &["preallocated"],
        &["preallocates"],
        &["preallocating"],
        &["preamble"],
        &["premade"],
        &["preamble"],
        &["preamble"],
        &["preprocessing"],
        &["prepared"],
        &["prepare"],
        &["preapproved"],
    ],
    range: 3..=10,
};

static WORD_PRD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PRD_CHILDREN),
    value: None,
};

pub static WORD_PRD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("pagate"),
        dictgen::InsensitiveStr::Ascii("pagated"),
        dictgen::InsensitiveStr::Ascii("pagates"),
        dictgen::InsensitiveStr::Ascii("pagating"),
        dictgen::InsensitiveStr::Ascii("pagation"),
        dictgen::InsensitiveStr::Ascii("pagations"),
        dictgen::InsensitiveStr::Ascii("pagator"),
        dictgen::InsensitiveStr::Ascii("pagators"),
    ],
    values: &[
        &["propagate"],
        &["propagated"],
        &["propagates"],
        &["propagating"],
        &["propagation"],
        &["propagations"],
        &["propagator"],
        &["propagators"],
    ],
    range: 6..=9,
};

static WORD_PRC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PRC_CHILDREN),
    value: None,
};

pub static WORD_PRC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("edure"),
        dictgen::InsensitiveStr::Ascii("eeded"),
        dictgen::InsensitiveStr::Ascii("ess"),
        dictgen::InsensitiveStr::Ascii("esses"),
        dictgen::InsensitiveStr::Ascii("essing"),
        dictgen::InsensitiveStr::Ascii("oess"),
        dictgen::InsensitiveStr::Ascii("oessed"),
        dictgen::InsensitiveStr::Ascii("oesses"),
        dictgen::InsensitiveStr::Ascii("oessing"),
        dictgen::InsensitiveStr::Ascii("tiles"),
    ],
    values: &[
        &["procedure"],
        &["preceded"],
        &["process"],
        &["processes"],
        &["processing"],
        &["process"],
        &["processed"],
        &["processes"],
        &["processing"],
        &["percentiles"],
    ],
    range: 3..=7,
};

static WORD_PRA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PRA_CHILDREN),
    value: None,
};

pub static WORD_PRA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ameter"),
        dictgen::InsensitiveStr::Ascii("ameters"),
        dictgen::InsensitiveStr::Ascii("bability"),
        dictgen::InsensitiveStr::Ascii("bable"),
        dictgen::InsensitiveStr::Ascii("bably"),
        dictgen::InsensitiveStr::Ascii("citcal"),
        dictgen::InsensitiveStr::Ascii("citcally"),
        dictgen::InsensitiveStr::Ascii("citse"),
        dictgen::InsensitiveStr::Ascii("cthett"),
        dictgen::InsensitiveStr::Ascii("ctial"),
        dictgen::InsensitiveStr::Ascii("ctially"),
        dictgen::InsensitiveStr::Ascii("cticallity"),
        dictgen::InsensitiveStr::Ascii("cticaly"),
        dictgen::InsensitiveStr::Ascii("cticarlo"),
        dictgen::InsensitiveStr::Ascii("cticess"),
        dictgen::InsensitiveStr::Ascii("cticianer"),
        dictgen::InsensitiveStr::Ascii("cticianers"),
        dictgen::InsensitiveStr::Ascii("cticioner"),
        dictgen::InsensitiveStr::Ascii("cticioners"),
        dictgen::InsensitiveStr::Ascii("cticlly"),
        dictgen::InsensitiveStr::Ascii("cticly"),
        dictgen::InsensitiveStr::Ascii("ctictitioner"),
        dictgen::InsensitiveStr::Ascii("ctictitioners"),
        dictgen::InsensitiveStr::Ascii("cticval"),
        dictgen::InsensitiveStr::Ascii("ctie"),
        dictgen::InsensitiveStr::Ascii("cties"),
        dictgen::InsensitiveStr::Ascii("ctioner"),
        dictgen::InsensitiveStr::Ascii("ctioners"),
        dictgen::InsensitiveStr::Ascii("ctisioner"),
        dictgen::InsensitiveStr::Ascii("ctisioners"),
        dictgen::InsensitiveStr::Ascii("ctitioneer"),
        dictgen::InsensitiveStr::Ascii("ctitionner"),
        dictgen::InsensitiveStr::Ascii("ctitionners"),
        dictgen::InsensitiveStr::Ascii("ctitions"),
        dictgen::InsensitiveStr::Ascii("ctives"),
        dictgen::InsensitiveStr::Ascii("efix"),
        dictgen::InsensitiveStr::Ascii("gam"),
        dictgen::InsensitiveStr::Ascii("gamtic"),
        dictgen::InsensitiveStr::Ascii("gmatisch"),
        dictgen::InsensitiveStr::Ascii("iry"),
        dictgen::InsensitiveStr::Ascii("isse"),
        dictgen::InsensitiveStr::Ascii("mater"),
        dictgen::InsensitiveStr::Ascii("meter"),
        dictgen::InsensitiveStr::Ascii("meters"),
        dictgen::InsensitiveStr::Ascii("rameter"),
        dictgen::InsensitiveStr::Ascii("rameters"),
        dictgen::InsensitiveStr::Ascii("rie"),
        dictgen::InsensitiveStr::Ascii("ries"),
        dictgen::InsensitiveStr::Ascii("sied"),
        dictgen::InsensitiveStr::Ascii("sies"),
        dictgen::InsensitiveStr::Ascii("tcise"),
        dictgen::InsensitiveStr::Ascii("tical"),
        dictgen::InsensitiveStr::Ascii("tically"),
        dictgen::InsensitiveStr::Ascii("tice"),
        dictgen::InsensitiveStr::Ascii("ticle"),
        dictgen::InsensitiveStr::Ascii("tictioner"),
        dictgen::InsensitiveStr::Ascii("tictioners"),
        dictgen::InsensitiveStr::Ascii("yries"),
        dictgen::InsensitiveStr::Ascii("yry"),
        dictgen::InsensitiveStr::Ascii("yrys"),
    ],
    values: &[
        &["parameter"],
        &["parameters"],
        &["probability"],
        &["probable"],
        &["probably"],
        &["practical"],
        &["practically"],
        &["practise"],
        &["pratchett"],
        &["practical"],
        &["practically"],
        &["practically"],
        &["practically"],
        &["practical"],
        &["practice"],
        &["practitioner"],
        &["practitioners"],
        &["practitioner"],
        &["practitioners"],
        &["practically"],
        &["practically"],
        &["practitioner"],
        &["practitioners"],
        &["practical"],
        &["practise"],
        &["practise"],
        &["practitioner"],
        &["practitioners"],
        &["practitioner"],
        &["practitioners"],
        &["practitioners"],
        &["practitioner"],
        &["practitioners"],
        &["practitioners"],
        &["practise"],
        &["prefix"],
        &["pragma"],
        &["pragmatic"],
        &["pragmatic"],
        &["prairie"],
        &["praises"],
        &["parameter"],
        &["parameter"],
        &["parameters"],
        &["parameter"],
        &["parameters"],
        &["prairie"],
        &["prairies"],
        &["praised"],
        &["praises"],
        &["practise"],
        &["practical"],
        &["practically"],
        &["practice"],
        &["particle"],
        &["practitioners"],
        &["practitioners"],
        &["prairies"],
        &["prairie"],
        &["prairies"],
    ],
    range: 3..=13,
};

static WORD_PP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PP_CHILDREN),
    value: None,
};

pub static WORD_PP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("check"),
        dictgen::InsensitiveStr::Ascii("eline"),
        dictgen::InsensitiveStr::Ascii("elines"),
        dictgen::InsensitiveStr::Ascii("lication"),
        dictgen::InsensitiveStr::Ascii("olygons"),
        dictgen::InsensitiveStr::Ascii("ublisher"),
        dictgen::InsensitiveStr::Ascii("yint"),
    ],
    values: &[
        &["cppcheck"],
        &["pipeline"],
        &["pipelines"],
        &["application"],
        &["polygons"],
        &["publisher"],
        &["pyint"],
    ],
    range: 4..=8,
};

static WORD_PO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_PO_CHILDREN),
    value: None,
};

static WORD_PO_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    Some(&WORD_POB_NODE),
    Some(&WORD_POC_NODE),
    Some(&WORD_POD_NODE),
    Some(&WORD_POE_NODE),
    None,
    Some(&WORD_POG_NODE),
    None,
    Some(&WORD_POI_NODE),
    Some(&WORD_POJ_NODE),
    Some(&WORD_POK_NODE),
    Some(&WORD_POL_NODE),
    Some(&WORD_POM_NODE),
    Some(&WORD_PON_NODE),
    Some(&WORD_POO_NODE),
    Some(&WORD_POP_NODE),
    None,
    Some(&WORD_POR_NODE),
    Some(&WORD_POS_NODE),
    Some(&WORD_POT_NODE),
    Some(&WORD_POU_NODE),
    Some(&WORD_POV_NODE),
    Some(&WORD_POW_NODE),
    None,
    Some(&WORD_POY_NODE),
    Some(&WORD_POZ_NODE),
];

static WORD_POZ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_POZ_CHILDREN),
    value: None,
};

pub static WORD_POZ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("itive"),
        dictgen::InsensitiveStr::Ascii("itively"),
        dictgen::InsensitiveStr::Ascii("itives"),
    ],
    values: &[&["positive"], &["positively"], &["positives"]],
    range: 5..=7,
};

static WORD_POY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_POY_CHILDREN),
    value: None,
};

pub static WORD_POY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("lgon"),
        dictgen::InsensitiveStr::Ascii("lmer"),
    ],
    values: &[&["polygon"], &["polymer"]],
    range: 4..=4,
};

static WORD_POW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_POW_CHILDREN),
    value: None,
};

pub static WORD_POW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("derade"),
        dictgen::InsensitiveStr::Ascii("derd"),
        dictgen::InsensitiveStr::Ascii("eful"),
        dictgen::InsensitiveStr::Ascii("erded"),
        dictgen::InsensitiveStr::Ascii("erfisting"),
        dictgen::InsensitiveStr::Ascii("erfull"),
        dictgen::InsensitiveStr::Ascii("erhorse"),
        dictgen::InsensitiveStr::Ascii("erhosue"),
        dictgen::InsensitiveStr::Ascii("erhours"),
        dictgen::InsensitiveStr::Ascii("erhourse"),
        dictgen::InsensitiveStr::Ascii("erhsell"),
        dictgen::InsensitiveStr::Ascii("erlfiting"),
        dictgen::InsensitiveStr::Ascii("erlifing"),
        dictgen::InsensitiveStr::Ascii("erlifitng"),
        dictgen::InsensitiveStr::Ascii("erliftng"),
        dictgen::InsensitiveStr::Ascii("erlisting"),
        dictgen::InsensitiveStr::Ascii("erpot"),
        dictgen::InsensitiveStr::Ascii("erppc"),
        dictgen::InsensitiveStr::Ascii("erprint"),
        dictgen::InsensitiveStr::Ascii("ersehll"),
        dictgen::InsensitiveStr::Ascii("etlifting"),
        dictgen::InsensitiveStr::Ascii("rrlifting"),
    ],
    values: &[
        &["powdered"],
        &["powdered"],
        &["powerful"],
        &["powdered"],
        &["powerlifting"],
        &["powerful"],
        &["powerhouse"],
        &["powerhouse"],
        &["powerhouse"],
        &["powerhouse"],
        &["powershell"],
        &["powerlifting"],
        &["powerlifting"],
        &["powerlifting"],
        &["powerlifting"],
        &["powerlifting"],
        &["powerpoint"],
        &["powerpc"],
        &["powerpoint"],
        &["powershell"],
        &["powerlifting"],
        &["powerlifting"],
    ],
    range: 4..=9,
};

static WORD_POV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_POV_CHILDREN),
    value: None,
};

pub static WORD_POV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("erful"),
        dictgen::InsensitiveStr::Ascii("ided"),
    ],
    values: &[&["powerful"], &["provided"]],
    range: 4..=5,
};

static WORD_POU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_POU_CHILDREN),
    value: None,
};

pub static WORD_POU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("late"),
        dictgen::InsensitiveStr::Ascii("lations"),
        dictgen::InsensitiveStr::Ascii("nt"),
        dictgen::InsensitiveStr::Ascii("nts"),
        dictgen::InsensitiveStr::Ascii("pular"),
    ],
    values: &[
        &["populate"],
        &["populations"],
        &["point", "pound"],
        &["points"],
        &["popular"],
    ],
    range: 2..=7,
};

static WORD_POT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_POT_CHILDREN),
    value: None,
};

pub static WORD_POT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("atoe"),
        dictgen::InsensitiveStr::Ascii("atos"),
        dictgen::InsensitiveStr::Ascii("encial"),
        dictgen::InsensitiveStr::Ascii("encially"),
        dictgen::InsensitiveStr::Ascii("encials"),
        dictgen::InsensitiveStr::Ascii("enial"),
        dictgen::InsensitiveStr::Ascii("enially"),
        dictgen::InsensitiveStr::Ascii("entail"),
        dictgen::InsensitiveStr::Ascii("entailly"),
        dictgen::InsensitiveStr::Ascii("entails"),
        dictgen::InsensitiveStr::Ascii("ental"),
        dictgen::InsensitiveStr::Ascii("entally"),
        dictgen::InsensitiveStr::Ascii("entatially"),
        dictgen::InsensitiveStr::Ascii("ententially"),
        dictgen::InsensitiveStr::Ascii("entiallly"),
        dictgen::InsensitiveStr::Ascii("entialy"),
        dictgen::InsensitiveStr::Ascii("entiel"),
        dictgen::InsensitiveStr::Ascii("entiomenter"),
        dictgen::InsensitiveStr::Ascii("ical"),
        dictgen::InsensitiveStr::Ascii("ientially"),
        dictgen::InsensitiveStr::Ascii("ition"),
        dictgen::InsensitiveStr::Ascii("ocol"),
        dictgen::InsensitiveStr::Ascii("rait"),
        dictgen::InsensitiveStr::Ascii("rayed"),
    ],
    values: &[
        &["potato"],
        &["potatoes"],
        &["potential"],
        &["potentially"],
        &["potentials"],
        &["potential"],
        &["potentially"],
        &["potential"],
        &["potentially"],
        &["potentials"],
        &["potential"],
        &["potentially"],
        &["potentially"],
        &["potentially"],
        &["potentially"],
        &["potentially"],
        &["potential"],
        &["potentiometer"],
        &["optical"],
        &["potentially"],
        &["position"],
        &["protocol"],
        &["portrait"],
        &["portrayed"],
    ],
    range: 4..=11,
};

static WORD_POS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_POS_CHILDREN),
    value: None,
};

static WORD_POS_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_POSA_NODE),
    None,
    None,
    None,
    Some(&WORD_POSE_NODE),
    None,
    None,
    None,
    Some(&WORD_POSI_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_POSO_NODE),
    Some(&WORD_POSP_NODE),
    None,
    None,
    Some(&WORD_POSS_NODE),
    Some(&WORD_POST_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_POST_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_POST_CHILDREN),
    value: None,
};

pub static WORD_POST_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("condtion"),
        dictgen::InsensitiveStr::Ascii("condtions"),
        dictgen::InsensitiveStr::Ascii("dam"),
        dictgen::InsensitiveStr::Ascii("gress"),
        dictgen::InsensitiveStr::Ascii("gressql"),
        dictgen::InsensitiveStr::Ascii("grsql"),
        dictgen::InsensitiveStr::Ascii("homous"),
        dictgen::InsensitiveStr::Ascii("iional"),
        dictgen::InsensitiveStr::Ascii("iive"),
        dictgen::InsensitiveStr::Ascii("incremend"),
        dictgen::InsensitiveStr::Ascii("ion"),
        dictgen::InsensitiveStr::Ascii("ioned"),
        dictgen::InsensitiveStr::Ascii("ions"),
        dictgen::InsensitiveStr::Ascii("ition"),
        dictgen::InsensitiveStr::Ascii("itive"),
        dictgen::InsensitiveStr::Ascii("itives"),
        dictgen::InsensitiveStr::Ascii("ive"),
        dictgen::InsensitiveStr::Ascii("ives"),
        dictgen::InsensitiveStr::Ascii("mage"),
        dictgen::InsensitiveStr::Ascii("phoned"),
        dictgen::InsensitiveStr::Ascii("pocessing"),
        dictgen::InsensitiveStr::Ascii("poninig"),
        dictgen::InsensitiveStr::Ascii("procesing"),
        dictgen::InsensitiveStr::Ascii("scritp"),
        dictgen::InsensitiveStr::Ascii("ulat"),
        dictgen::InsensitiveStr::Ascii("uminus"),
        dictgen::InsensitiveStr::Ascii("umus"),
    ],
    values: &[
        &["postcondition"],
        &["postconditions"],
        &["potsdam"],
        &["postgresql"],
        &["postgresql"],
        &["postgresql"],
        &["posthumous"],
        &["positional"],
        &["positive"],
        &["postincrement"],
        &["position"],
        &["positioned"],
        &["positions"],
        &["position"],
        &["positive"],
        &["positives"],
        &["positive"],
        &["positives"],
        &["postimage"],
        &["postponed"],
        &["postprocessing"],
        &["postponing"],
        &["postprocessing"],
        &["postscript"],
        &["postulate"],
        &["posthumous"],
        &["posthumous"],
    ],
    range: 3..=9,
};

static WORD_POSS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_POSS_CHILDREN),
    value: None,
};

pub static WORD_POSS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("abilites"),
        dictgen::InsensitiveStr::Ascii("abilities"),
        dictgen::InsensitiveStr::Ascii("ability"),
        dictgen::InsensitiveStr::Ascii("abilties"),
        dictgen::InsensitiveStr::Ascii("abily"),
        dictgen::InsensitiveStr::Ascii("able"),
        dictgen::InsensitiveStr::Ascii("ably"),
        dictgen::InsensitiveStr::Ascii("bile"),
        dictgen::InsensitiveStr::Ascii("bily"),
        dictgen::InsensitiveStr::Ascii("ble"),
        dictgen::InsensitiveStr::Ascii("bly"),
        dictgen::InsensitiveStr::Ascii("eses"),
        dictgen::InsensitiveStr::Ascii("esess"),
        dictgen::InsensitiveStr::Ascii("esing"),
        dictgen::InsensitiveStr::Ascii("esion"),
        dictgen::InsensitiveStr::Ascii("esive"),
        dictgen::InsensitiveStr::Ascii("esives"),
        dictgen::InsensitiveStr::Ascii("esse"),
        dictgen::InsensitiveStr::Ascii("essers"),
        dictgen::InsensitiveStr::Ascii("essess"),
        dictgen::InsensitiveStr::Ascii("esseurs"),
        dictgen::InsensitiveStr::Ascii("essin"),
        dictgen::InsensitiveStr::Ascii("essivize"),
        dictgen::InsensitiveStr::Ascii("esss"),
        dictgen::InsensitiveStr::Ascii("esssion"),
        dictgen::InsensitiveStr::Ascii("estions"),
        dictgen::InsensitiveStr::Ascii("iable"),
        dictgen::InsensitiveStr::Ascii("ibbe"),
        dictgen::InsensitiveStr::Ascii("ibble"),
        dictgen::InsensitiveStr::Ascii("ibe"),
        dictgen::InsensitiveStr::Ascii("ibile"),
        dictgen::InsensitiveStr::Ascii("ibilies"),
        dictgen::InsensitiveStr::Ascii("ibilites"),
        dictgen::InsensitiveStr::Ascii("ibilitities"),
        dictgen::InsensitiveStr::Ascii("ibiliy"),
        dictgen::InsensitiveStr::Ascii("ibillity"),
        dictgen::InsensitiveStr::Ascii("ibilties"),
        dictgen::InsensitiveStr::Ascii("ibilty"),
        dictgen::InsensitiveStr::Ascii("ibily"),
        dictgen::InsensitiveStr::Ascii("ibities"),
        dictgen::InsensitiveStr::Ascii("ibity"),
        dictgen::InsensitiveStr::Ascii("iblble"),
        dictgen::InsensitiveStr::Ascii("iblec"),
        dictgen::InsensitiveStr::Ascii("iblely"),
        dictgen::InsensitiveStr::Ascii("ibley"),
        dictgen::InsensitiveStr::Ascii("iblility"),
        dictgen::InsensitiveStr::Ascii("iblilty"),
        dictgen::InsensitiveStr::Ascii("iblities"),
        dictgen::InsensitiveStr::Ascii("iblity"),
        dictgen::InsensitiveStr::Ascii("iblly"),
        dictgen::InsensitiveStr::Ascii("iby"),
        dictgen::InsensitiveStr::Ascii("iibly"),
        dictgen::InsensitiveStr::Ascii("ilbe"),
        dictgen::InsensitiveStr::Ascii("ily"),
        dictgen::InsensitiveStr::Ascii("issive"),
        dictgen::InsensitiveStr::Ascii("ition"),
        dictgen::InsensitiveStr::Ascii("itive"),
        dictgen::InsensitiveStr::Ascii("itives"),
        dictgen::InsensitiveStr::Ascii("obily"),
        dictgen::InsensitiveStr::Ascii("oble"),
        dictgen::InsensitiveStr::Ascii("obly"),
        dictgen::InsensitiveStr::Ascii("sible"),
    ],
    values: &[
        &["possibilities"],
        &["possibilities"],
        &["possibility"],
        &["possibilities"],
        &["possibly"],
        &["possible"],
        &["possibly"],
        &["possible", "possibly"],
        &["possibly"],
        &["possible"],
        &["possibly"],
        &["possesses"],
        &["possesses"],
        &["possessing"],
        &["possession"],
        &["possessive"],
        &["possessive"],
        &["possessive"],
        &["possesses"],
        &["possesses"],
        &["possesses"],
        &["possessions"],
        &["possessive"],
        &["possesses"],
        &["possessions"],
        &["possessions"],
        &["possible"],
        &["possible"],
        &["possible"],
        &["possible"],
        &["possible"],
        &["possibilities"],
        &["possibilities"],
        &["possibilities"],
        &["possibility", "possibly"],
        &["possibility"],
        &["possibilities"],
        &["possibility"],
        &["possibility", "possibly"],
        &["possibilities"],
        &["possibility"],
        &["possible"],
        &["possible"],
        &["possibly"],
        &["possibly"],
        &["possibility"],
        &["possibility"],
        &["possibilities"],
        &["possibility"],
        &["possibly"],
        &["possibly"],
        &["possibly"],
        &["possible"],
        &["possibly"],
        &["possessive"],
        &["position"],
        &["positive"],
        &["positives"],
        &["possibly"],
        &["possible"],
        &["possibly"],
        &["possible"],
    ],
    range: 3..=11,
};

static WORD_POSP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_POSP_CHILDREN),
    value: None,
};

pub static WORD_POSP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("one"),
        dictgen::InsensitiveStr::Ascii("oned"),
        dictgen::InsensitiveStr::Ascii("tion"),
    ],
    values: &[&["postpone"], &["postponed"], &["position"]],
    range: 3..=4,
};

static WORD_POSO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_POSO_CHILDREN),
    value: None,
};

pub static WORD_POSO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("tion")],
    values: &[&["position"]],
    range: 4..=4,
};

static WORD_POSI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_POSI_CHILDREN),
    value: None,
};

pub static WORD_POSI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("bilities"),
        dictgen::InsensitiveStr::Ascii("bility"),
        dictgen::InsensitiveStr::Ascii("bilties"),
        dictgen::InsensitiveStr::Ascii("ble"),
        dictgen::InsensitiveStr::Ascii("blity"),
        dictgen::InsensitiveStr::Ascii("bly"),
        dictgen::InsensitiveStr::Ascii("cional"),
        dictgen::InsensitiveStr::Ascii("fion"),
        dictgen::InsensitiveStr::Ascii("fions"),
        dictgen::InsensitiveStr::Ascii("itive"),
        dictgen::InsensitiveStr::Ascii("itives"),
        dictgen::InsensitiveStr::Ascii("itivity"),
        dictgen::InsensitiveStr::Ascii("on"),
        dictgen::InsensitiveStr::Ascii("oned"),
        dictgen::InsensitiveStr::Ascii("oning"),
        dictgen::InsensitiveStr::Ascii("ons"),
        dictgen::InsensitiveStr::Ascii("sition"),
        dictgen::InsensitiveStr::Ascii("sitioned"),
        dictgen::InsensitiveStr::Ascii("stion"),
        dictgen::InsensitiveStr::Ascii("tevely"),
        dictgen::InsensitiveStr::Ascii("tioing"),
        dictgen::InsensitiveStr::Ascii("tiond"),
        dictgen::InsensitiveStr::Ascii("tiong"),
        dictgen::InsensitiveStr::Ascii("tionial"),
        dictgen::InsensitiveStr::Ascii("tionl"),
        dictgen::InsensitiveStr::Ascii("tionly"),
        dictgen::InsensitiveStr::Ascii("tionn"),
        dictgen::InsensitiveStr::Ascii("tionnal"),
        dictgen::InsensitiveStr::Ascii("tionne"),
        dictgen::InsensitiveStr::Ascii("tionned"),
        dictgen::InsensitiveStr::Ascii("tionnes"),
        dictgen::InsensitiveStr::Ascii("tionning"),
        dictgen::InsensitiveStr::Ascii("tionns"),
        dictgen::InsensitiveStr::Ascii("tionof"),
        dictgen::InsensitiveStr::Ascii("tiv"),
        dictgen::InsensitiveStr::Ascii("tiveity"),
        dictgen::InsensitiveStr::Ascii("tivie"),
        dictgen::InsensitiveStr::Ascii("tiviely"),
        dictgen::InsensitiveStr::Ascii("tivies"),
        dictgen::InsensitiveStr::Ascii("tivisme"),
        dictgen::InsensitiveStr::Ascii("tivisty"),
        dictgen::InsensitiveStr::Ascii("tivitely"),
        dictgen::InsensitiveStr::Ascii("tivitey"),
        dictgen::InsensitiveStr::Ascii("tivitiy"),
        dictgen::InsensitiveStr::Ascii("tiviy"),
        dictgen::InsensitiveStr::Ascii("tivley"),
        dictgen::InsensitiveStr::Ascii("tivly"),
        dictgen::InsensitiveStr::Ascii("tivs"),
        dictgen::InsensitiveStr::Ascii("tivy"),
        dictgen::InsensitiveStr::Ascii("toin"),
        dictgen::InsensitiveStr::Ascii("toined"),
        dictgen::InsensitiveStr::Ascii("toins"),
        dictgen::InsensitiveStr::Ascii("ton"),
        dictgen::InsensitiveStr::Ascii("tonal"),
        dictgen::InsensitiveStr::Ascii("toned"),
        dictgen::InsensitiveStr::Ascii("toning"),
        dictgen::InsensitiveStr::Ascii("tons"),
        dictgen::InsensitiveStr::Ascii("tve"),
        dictgen::InsensitiveStr::Ascii("tves"),
    ],
    values: &[
        &["possibilities"],
        &["possibility"],
        &["possibilities"],
        &["possible"],
        &["possibility"],
        &["possibly"],
        &["positional"],
        &["position"],
        &["positions"],
        &["positive"],
        &["positives"],
        &["positivity"],
        &["poison", "psion", "position"],
        &["poisoned", "positioned"],
        &["poisoning", "positioning"],
        &["poisons", "positions", "psions"],
        &["position"],
        &["positioned"],
        &["position"],
        &["positively"],
        &["positioning"],
        &["positioned"],
        &["positioning", "position"],
        &["positional"],
        &["positional"],
        &["positional"],
        &["position"],
        &["positional"],
        &["positioned"],
        &["positioned"],
        &["positions"],
        &["positioning"],
        &["positions"],
        &["position"],
        &["positive"],
        &["positivity"],
        &["positive"],
        &["positively"],
        &["positives"],
        &["positives"],
        &["positivity"],
        &["positivity"],
        &["positivity"],
        &["positivity"],
        &["positivity"],
        &["positively"],
        &["positively"],
        &["positives"],
        &["positivity", "positive", "positively"],
        &["position"],
        &["positioned"],
        &["positions"],
        &["position", "positron"],
        &["positional"],
        &["positioned"],
        &["positioning"],
        &["positions", "positrons"],
        &["positive"],
        &["positives"],
    ],
    range: 2..=8,
};

static WORD_POSE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_POSE_CHILDREN),
    value: None,
};

pub static WORD_POSE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("esions"),
        dictgen::InsensitiveStr::Ascii("ss"),
        dictgen::InsensitiveStr::Ascii("ssed"),
        dictgen::InsensitiveStr::Ascii("sses"),
        dictgen::InsensitiveStr::Ascii("ssing"),
        dictgen::InsensitiveStr::Ascii("ssion"),
        dictgen::InsensitiveStr::Ascii("ssions"),
    ],
    values: &[
        &["possessions"],
        &["possess"],
        &["possessed"],
        &["possesses"],
        &["possessing"],
        &["possession"],
        &["possessions"],
    ],
    range: 2..=6,
};

static WORD_POSA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_POSA_CHILDREN),
    value: None,
};

pub static WORD_POSA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("tive"),
        dictgen::InsensitiveStr::Ascii("tives"),
        dictgen::InsensitiveStr::Ascii("tivity"),
    ],
    values: &[&["positive"], &["positives"], &["positivity"]],
    range: 4..=6,
};

static WORD_POR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_POR_CHILDREN),
    value: None,
};

static WORD_POR_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_PORA_NODE),
    Some(&WORD_PORB_NODE),
    Some(&WORD_PORC_NODE),
    Some(&WORD_PORD_NODE),
    Some(&WORD_PORE_NODE),
    Some(&WORD_PORF_NODE),
    Some(&WORD_PORG_NODE),
    None,
    Some(&WORD_PORI_NODE),
    Some(&WORD_PORJ_NODE),
    None,
    Some(&WORD_PORL_NODE),
    Some(&WORD_PORM_NODE),
    Some(&WORD_PORN_NODE),
    Some(&WORD_PORO_NODE),
    Some(&WORD_PORP_NODE),
    None,
    None,
    Some(&WORD_PORS_NODE),
    Some(&WORD_PORT_NODE),
    None,
    Some(&WORD_PORV_NODE),
    None,
    None,
    None,
    None,
];

static WORD_PORV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PORV_CHILDREN),
    value: None,
};

pub static WORD_PORV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("en"),
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("ide"),
        dictgen::InsensitiveStr::Ascii("ided"),
        dictgen::InsensitiveStr::Ascii("ider"),
        dictgen::InsensitiveStr::Ascii("ides"),
        dictgen::InsensitiveStr::Ascii("iding"),
        dictgen::InsensitiveStr::Ascii("ids"),
        dictgen::InsensitiveStr::Ascii("ing"),
    ],
    values: &[
        &["prove"],
        &["proved"],
        &["proven"],
        &["proves"],
        &["provide"],
        &["provided"],
        &["provider"],
        &["provides"],
        &["providing"],
        &["provides"],
        &["proving"],
    ],
    range: 1..=5,
};

static WORD_PORT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PORT_CHILDREN),
    value: None,
};

pub static WORD_PORT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("abel"),
        dictgen::InsensitiveStr::Ascii("abillity"),
        dictgen::InsensitiveStr::Ascii("abilty"),
        dictgen::InsensitiveStr::Ascii("agonists"),
        dictgen::InsensitiveStr::Ascii("ait"),
        dictgen::InsensitiveStr::Ascii("aits"),
        dictgen::InsensitiveStr::Ascii("alis"),
        dictgen::InsensitiveStr::Ascii("alus"),
        dictgen::InsensitiveStr::Ascii("ary"),
        dictgen::InsensitiveStr::Ascii("arying"),
        dictgen::InsensitiveStr::Ascii("ayed"),
        dictgen::InsensitiveStr::Ascii("ected"),
        dictgen::InsensitiveStr::Ascii("estants"),
        dictgen::InsensitiveStr::Ascii("foilo"),
        dictgen::InsensitiveStr::Ascii("gual"),
        dictgen::InsensitiveStr::Ascii("guese"),
        dictgen::InsensitiveStr::Ascii("ioon"),
        dictgen::InsensitiveStr::Ascii("oflio"),
        dictgen::InsensitiveStr::Ascii("oguese"),
        dictgen::InsensitiveStr::Ascii("raiing"),
        dictgen::InsensitiveStr::Ascii("rail"),
        dictgen::InsensitiveStr::Ascii("raing"),
        dictgen::InsensitiveStr::Ascii("rais"),
        dictgen::InsensitiveStr::Ascii("rary"),
        dictgen::InsensitiveStr::Ascii("ras"),
        dictgen::InsensitiveStr::Ascii("rat"),
        dictgen::InsensitiveStr::Ascii("rating"),
        dictgen::InsensitiveStr::Ascii("rayels"),
        dictgen::InsensitiveStr::Ascii("rayes"),
        dictgen::InsensitiveStr::Ascii("rayl"),
        dictgen::InsensitiveStr::Ascii("rayls"),
        dictgen::InsensitiveStr::Ascii("riat"),
        dictgen::InsensitiveStr::Ascii("riats"),
        dictgen::InsensitiveStr::Ascii("ugese"),
        dictgen::InsensitiveStr::Ascii("ugeuse"),
        dictgen::InsensitiveStr::Ascii("uguease"),
        dictgen::InsensitiveStr::Ascii("ugues"),
        dictgen::InsensitiveStr::Ascii("uguesse"),
        dictgen::InsensitiveStr::Ascii("uguise"),
    ],
    values: &[
        &["portable"],
        &["portability"],
        &["portability"],
        &["protagonists"],
        &["portrait"],
        &["portraits"],
        &["portals"],
        &["portals"],
        &["portray"],
        &["portraying"],
        &["portrayed"],
        &["protected"],
        &["protestants"],
        &["portfolio"],
        &["portugal"],
        &["portuguese"],
        &["portion"],
        &["portfolio"],
        &["portuguese"],
        &["portraying"],
        &["portrayal", "portrait"],
        &["portraying"],
        &["portraits"],
        &["portray"],
        &["portrays"],
        &["portrait"],
        &["portraying"],
        &["portrays"],
        &["portrays"],
        &["portrayal"],
        &["portrays"],
        &["portrait"],
        &["portraits"],
        &["portuguese"],
        &["portuguese"],
        &["portuguese"],
        &["portuguese"],
        &["portuguese"],
        &["portuguese"],
    ],
    range: 3..=8,
};

static WORD_PORS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PORS_CHILDREN),
    value: None,
};

pub static WORD_PORS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("alin"),
        dictgen::InsensitiveStr::Ascii("han"),
        dictgen::InsensitiveStr::Ascii("hon"),
    ],
    values: &[&["porcelain"], &["portion"], &["portion"]],
    range: 3..=4,
};

static WORD_PORP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PORP_CHILDREN),
    value: None,
};

pub static WORD_PORP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("erties"),
        dictgen::InsensitiveStr::Ascii("erty"),
        dictgen::InsensitiveStr::Ascii("ortion"),
        dictgen::InsensitiveStr::Ascii("ortional"),
        dictgen::InsensitiveStr::Ascii("ortionally"),
        dictgen::InsensitiveStr::Ascii("ortioning"),
        dictgen::InsensitiveStr::Ascii("ortions"),
        dictgen::InsensitiveStr::Ascii("ose"),
        dictgen::InsensitiveStr::Ascii("oses"),
    ],
    values: &[
        &["properties"],
        &["property"],
        &["proportion"],
        &["proportional"],
        &["proportionally"],
        &["proportioning"],
        &["proportions"],
        &["propose"],
        &["proposes", "purposes"],
    ],
    range: 3..=10,
};

static WORD_PORO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PORO_CHILDREN),
    value: None,
};

pub static WORD_PORO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("tocol"),
        dictgen::InsensitiveStr::Ascii("tocols"),
    ],
    values: &[&["protocol"], &["protocols"]],
    range: 5..=6,
};

static WORD_PORN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PORN_CHILDREN),
    value: None,
};

pub static WORD_PORN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("agraphy"),
        dictgen::InsensitiveStr::Ascii("ograghy"),
        dictgen::InsensitiveStr::Ascii("ograhpy"),
        dictgen::InsensitiveStr::Ascii("ograhy"),
        dictgen::InsensitiveStr::Ascii("ograpghy"),
        dictgen::InsensitiveStr::Ascii("ograpgy"),
        dictgen::InsensitiveStr::Ascii("ograpy"),
        dictgen::InsensitiveStr::Ascii("ogrophy"),
        dictgen::InsensitiveStr::Ascii("ogrpahy"),
        dictgen::InsensitiveStr::Ascii("ogrphy"),
    ],
    values: &[
        &["pornography"],
        &["pornography"],
        &["pornography"],
        &["pornography"],
        &["pornography"],
        &["pornography"],
        &["pornography"],
        &["pornography"],
        &["pornography"],
        &["pornography"],
    ],
    range: 6..=8,
};

static WORD_PORM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PORM_CHILDREN),
    value: None,
};

pub static WORD_PORM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("etheus")],
    values: &[&["prometheus"]],
    range: 6..=6,
};

static WORD_PORL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PORL_CHILDREN),
    value: None,
};

pub static WORD_PORL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("etariat")],
    values: &[&["proletariat"]],
    range: 7..=7,
};

static WORD_PORJ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PORJ_CHILDREN),
    value: None,
};

pub static WORD_PORJ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ect"),
        dictgen::InsensitiveStr::Ascii("ectiles"),
        dictgen::InsensitiveStr::Ascii("ection"),
        dictgen::InsensitiveStr::Ascii("ects"),
    ],
    values: &[
        &["project"],
        &["projectiles"],
        &["projection"],
        &["projects"],
    ],
    range: 3..=7,
};

static WORD_PORI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PORI_CHILDREN),
    value: None,
};

pub static WORD_PORI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("feral"),
        dictgen::InsensitiveStr::Ascii("od"),
    ],
    values: &[&["peripheral"], &["period"]],
    range: 2..=5,
};

static WORD_PORG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PORG_CHILDREN),
    value: None,
};

pub static WORD_PORG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ram"),
        dictgen::InsensitiveStr::Ascii("ramme"),
        dictgen::InsensitiveStr::Ascii("rammeer"),
        dictgen::InsensitiveStr::Ascii("rammeers"),
        dictgen::InsensitiveStr::Ascii("ramming"),
        dictgen::InsensitiveStr::Ascii("rams"),
    ],
    values: &[
        &["program"],
        &["programme"],
        &["programmer"],
        &["programmers"],
        &["programming"],
        &["programs"],
    ],
    range: 3..=8,
};

static WORD_PORF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PORF_CHILDREN),
    value: None,
};

pub static WORD_PORF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("tolio")],
    values: &[&["portfolio"]],
    range: 5..=5,
};

static WORD_PORE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PORE_CHILDREN),
    value: None,
};

pub static WORD_PORE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("clain")],
    values: &[&["porcelain"]],
    range: 5..=5,
};

static WORD_PORD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PORD_CHILDREN),
    value: None,
};

pub static WORD_PORD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("uct")],
    values: &[&["product"]],
    range: 3..=3,
};

static WORD_PORC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PORC_CHILDREN),
    value: None,
};

pub static WORD_PORC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("elan"),
        dictgen::InsensitiveStr::Ascii("elian"),
        dictgen::InsensitiveStr::Ascii("elina"),
        dictgen::InsensitiveStr::Ascii("ess"),
        dictgen::InsensitiveStr::Ascii("essed"),
        dictgen::InsensitiveStr::Ascii("esses"),
        dictgen::InsensitiveStr::Ascii("essing"),
        dictgen::InsensitiveStr::Ascii("essor"),
        dictgen::InsensitiveStr::Ascii("essors"),
    ],
    values: &[
        &["porcelain"],
        &["porcelain"],
        &["porcelain"],
        &["process"],
        &["processed"],
        &["processes"],
        &["processing"],
        &["processor"],
        &["processors"],
    ],
    range: 3..=6,
};

static WORD_PORB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PORB_CHILDREN),
    value: None,
};

pub static WORD_PORB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ably"),
        dictgen::InsensitiveStr::Ascii("lem"),
        dictgen::InsensitiveStr::Ascii("lems"),
    ],
    values: &[&["probably"], &["problem"], &["problems"]],
    range: 3..=4,
};

static WORD_PORA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PORA_CHILDREN),
    value: None,
};

pub static WORD_PORA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("lized")],
    values: &[&["polarized"]],
    range: 5..=5,
};

static WORD_POP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_POP_CHILDREN),
    value: None,
};

pub static WORD_POP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("eree"),
        dictgen::InsensitiveStr::Ascii("erly"),
        dictgen::InsensitiveStr::Ascii("erties"),
        dictgen::InsensitiveStr::Ascii("erty"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("luar"),
        dictgen::InsensitiveStr::Ascii("luations"),
        dictgen::InsensitiveStr::Ascii("oen"),
        dictgen::InsensitiveStr::Ascii("olate"),
        dictgen::InsensitiveStr::Ascii("olated"),
        dictgen::InsensitiveStr::Ascii("olates"),
        dictgen::InsensitiveStr::Ascii("olating"),
        dictgen::InsensitiveStr::Ascii("ortional"),
        dictgen::InsensitiveStr::Ascii("oulation"),
        dictgen::InsensitiveStr::Ascii("oulus"),
        dictgen::InsensitiveStr::Ascii("oup"),
        dictgen::InsensitiveStr::Ascii("pup"),
        dictgen::InsensitiveStr::Ascii("ualtion"),
        dictgen::InsensitiveStr::Ascii("ulair"),
        dictgen::InsensitiveStr::Ascii("ulairty"),
        dictgen::InsensitiveStr::Ascii("ulaiton"),
        dictgen::InsensitiveStr::Ascii("ularaty"),
        dictgen::InsensitiveStr::Ascii("ulare"),
        dictgen::InsensitiveStr::Ascii("ularest"),
        dictgen::InsensitiveStr::Ascii("ularily"),
        dictgen::InsensitiveStr::Ascii("ulary"),
        dictgen::InsensitiveStr::Ascii("ulaties"),
        dictgen::InsensitiveStr::Ascii("ulatin"),
        dictgen::InsensitiveStr::Ascii("ulationes"),
        dictgen::InsensitiveStr::Ascii("ulatiry"),
        dictgen::InsensitiveStr::Ascii("ulative"),
        dictgen::InsensitiveStr::Ascii("ulatoin"),
        dictgen::InsensitiveStr::Ascii("uler"),
        dictgen::InsensitiveStr::Ascii("ullate"),
        dictgen::InsensitiveStr::Ascii("ullated"),
        dictgen::InsensitiveStr::Ascii("ulos"),
        dictgen::InsensitiveStr::Ascii("ulr"),
        dictgen::InsensitiveStr::Ascii("ultaion"),
        dictgen::InsensitiveStr::Ascii("uplar"),
        dictgen::InsensitiveStr::Ascii("uplarity"),
        dictgen::InsensitiveStr::Ascii("uplate"),
        dictgen::InsensitiveStr::Ascii("uplated"),
        dictgen::InsensitiveStr::Ascii("uplates"),
        dictgen::InsensitiveStr::Ascii("uplating"),
        dictgen::InsensitiveStr::Ascii("uplation"),
    ],
    values: &[
        &["popped", "pooped"],
        &["potpourri"],
        &["properly", "property"],
        &["properties"],
        &["property", "properly"],
        &["popping", "pooping"],
        &["popular"],
        &["populations"],
        &["popen"],
        &["populate"],
        &["populated"],
        &["populates"],
        &["populating"],
        &["proportional"],
        &["population"],
        &["populous"],
        &["popup"],
        &["popup"],
        &["populations"],
        &["popular"],
        &["popularity"],
        &["populations"],
        &["popularity"],
        &["popular"],
        &["populate"],
        &["popularity"],
        &["popularity"],
        &["populate"],
        &["populations"],
        &["populations"],
        &["popularity"],
        &["populate"],
        &["populations"],
        &["popular"],
        &["populate"],
        &["populated"],
        &["populous"],
        &["popular"],
        &["populations"],
        &["popular"],
        &["popularity"],
        &["populate"],
        &["populated"],
        &["populates"],
        &["populating"],
        &["population"],
    ],
    range: 2..=9,
};

static WORD_POO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_POO_CHILDREN),
    value: None,
};

pub static WORD_POO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("int"),
        dictgen::InsensitiveStr::Ascii("inted"),
        dictgen::InsensitiveStr::Ascii("inter"),
        dictgen::InsensitiveStr::Ascii("ints"),
        dictgen::InsensitiveStr::Ascii("st"),
    ],
    values: &[
        &["point"],
        &["pointed"],
        &["pointer"],
        &["points"],
        &["post"],
    ],
    range: 2..=5,
};

static WORD_PON_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PON_CHILDREN),
    value: None,
};

pub static WORD_PON_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("int"),
        dictgen::InsensitiveStr::Ascii("inted"),
        dictgen::InsensitiveStr::Ascii("inter"),
        dictgen::InsensitiveStr::Ascii("inting"),
        dictgen::InsensitiveStr::Ascii("ints"),
        dictgen::InsensitiveStr::Ascii("it"),
        dictgen::InsensitiveStr::Ascii("itd"),
        dictgen::InsensitiveStr::Ascii("ited"),
        dictgen::InsensitiveStr::Ascii("iter"),
        dictgen::InsensitiveStr::Ascii("iters"),
        dictgen::InsensitiveStr::Ascii("its"),
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("tential"),
        dictgen::InsensitiveStr::Ascii("ter"),
        dictgen::InsensitiveStr::Ascii("ting"),
        dictgen::InsensitiveStr::Ascii("ts"),
        dictgen::InsensitiveStr::Ascii("tuation"),
    ],
    values: &[
        &["point"],
        &["pointed"],
        &["pointer"],
        &["pointing"],
        &["points"],
        &["point"],
        &["pointed"],
        &["pointed"],
        &["pointer"],
        &["pointers"],
        &["points"],
        &["point"],
        &["potential"],
        &["pointer"],
        &["pointing"],
        &["points"],
        &["punctuation"],
    ],
    range: 1..=7,
};

static WORD_POM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_POM_CHILDREN),
    value: None,
};

pub static WORD_POM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("egranite"),
        dictgen::InsensitiveStr::Ascii("otion"),
        dictgen::InsensitiveStr::Ascii("pay"),
    ],
    values: &[&["pomegranate"], &["promotion"], &["pompeii"]],
    range: 3..=8,
};

static WORD_POL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_POL_CHILDREN),
    value: None,
};

static WORD_POL_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_POLA_NODE),
    None,
    Some(&WORD_POLC_NODE),
    None,
    None,
    None,
    Some(&WORD_POLG_NODE),
    None,
    Some(&WORD_POLI_NODE),
    None,
    None,
    Some(&WORD_POLL_NODE),
    None,
    None,
    Some(&WORD_POLO_NODE),
    Some(&WORD_POLP_NODE),
    None,
    None,
    None,
    Some(&WORD_POLT_NODE),
    Some(&WORD_POLU_NODE),
    None,
    None,
    None,
    Some(&WORD_POLY_NODE),
    None,
];

static WORD_POLY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_POLY_CHILDREN),
    value: None,
};

pub static WORD_POLY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ar"),
        dictgen::InsensitiveStr::Ascii("edral"),
        dictgen::InsensitiveStr::Ascii("gammy"),
        dictgen::InsensitiveStr::Ascii("gond"),
        dictgen::InsensitiveStr::Ascii("gone"),
        dictgen::InsensitiveStr::Ascii("goon"),
        dictgen::InsensitiveStr::Ascii("lon"),
        dictgen::InsensitiveStr::Ascii("more"),
        dictgen::InsensitiveStr::Ascii("morpic"),
        dictgen::InsensitiveStr::Ascii("nomal"),
        dictgen::InsensitiveStr::Ascii("nomals"),
        dictgen::InsensitiveStr::Ascii("phonyic"),
        dictgen::InsensitiveStr::Ascii("poygon"),
        dictgen::InsensitiveStr::Ascii("poylgons"),
        dictgen::InsensitiveStr::Ascii("saccaride"),
        dictgen::InsensitiveStr::Ascii("saccharid"),
    ],
    values: &[
        &["polar"],
        &["polyhedral"],
        &["polygamy"],
        &["polygons"],
        &["polygon"],
        &["polygon"],
        &["polygon", "pylon"],
        &["polymer"],
        &["polymorphic"],
        &["polynomial"],
        &["polynomials"],
        &["polyphonic"],
        &["polypolygon"],
        &["polypolygons"],
        &["polysaccharide"],
        &["polysaccharide"],
    ],
    range: 2..=9,
};

static WORD_POLU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_POLU_CHILDREN),
    value: None,
};

pub static WORD_POLU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("late"),
        dictgen::InsensitiveStr::Ascii("lated"),
        dictgen::InsensitiveStr::Ascii("lates"),
        dictgen::InsensitiveStr::Ascii("lating"),
        dictgen::InsensitiveStr::Ascii("te"),
        dictgen::InsensitiveStr::Ascii("ted"),
        dictgen::InsensitiveStr::Ascii("tes"),
        dictgen::InsensitiveStr::Ascii("ting"),
        dictgen::InsensitiveStr::Ascii("tion"),
    ],
    values: &[
        &["populate"],
        &["populated"],
        &["populates"],
        &["populating"],
        &["pollute"],
        &["polluted"],
        &["pollutes"],
        &["polluting"],
        &["pollution"],
    ],
    range: 2..=6,
};

static WORD_POLT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_POLT_CHILDREN),
    value: None,
};

pub static WORD_POLT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ic"),
        dictgen::InsensitiveStr::Ascii("ical"),
        dictgen::InsensitiveStr::Ascii("ically"),
        dictgen::InsensitiveStr::Ascii("ics"),
        dictgen::InsensitiveStr::Ascii("ry"),
    ],
    values: &[
        &["politic"],
        &["political"],
        &["politically"],
        &["politics"],
        &["poultry"],
    ],
    range: 2..=6,
};

static WORD_POLP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_POLP_CHILDREN),
    value: None,
};

pub static WORD_POLP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ulate")],
    values: &[&["populate"]],
    range: 5..=5,
};

static WORD_POLO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_POLO_CHILDREN),
    value: None,
};

pub static WORD_POLO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cies"),
        dictgen::InsensitiveStr::Ascii("cy"),
        dictgen::InsensitiveStr::Ascii("cys"),
        dictgen::InsensitiveStr::Ascii("gon"),
        dictgen::InsensitiveStr::Ascii("gons"),
        dictgen::InsensitiveStr::Ascii("tic"),
        dictgen::InsensitiveStr::Ascii("tical"),
        dictgen::InsensitiveStr::Ascii("tically"),
        dictgen::InsensitiveStr::Ascii("tics"),
    ],
    values: &[
        &["policies"],
        &["policy"],
        &["policies"],
        &["polygon"],
        &["polygons"],
        &["politic"],
        &["political"],
        &["politically"],
        &["politics"],
    ],
    range: 2..=7,
};

static WORD_POLL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_POLL_CHILDREN),
    value: None,
};

pub static WORD_POLL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("enate"),
        dictgen::InsensitiveStr::Ascii("try"),
    ],
    values: &[&["pollinate"], &["poultry"]],
    range: 3..=5,
};

static WORD_POLI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_POLI_CHILDREN),
    value: None,
};

pub static WORD_POLI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cal"),
        dictgen::InsensitiveStr::Ascii("cally"),
        dictgen::InsensitiveStr::Ascii("cie"),
        dictgen::InsensitiveStr::Ascii("citally"),
        dictgen::InsensitiveStr::Ascii("citian"),
        dictgen::InsensitiveStr::Ascii("citians"),
        dictgen::InsensitiveStr::Ascii("ciy"),
        dictgen::InsensitiveStr::Ascii("cys"),
        dictgen::InsensitiveStr::Ascii("etly"),
        dictgen::InsensitiveStr::Ascii("gon"),
        dictgen::InsensitiveStr::Ascii("gons"),
        dictgen::InsensitiveStr::Ascii("nator"),
        dictgen::InsensitiveStr::Ascii("nators"),
        dictgen::InsensitiveStr::Ascii("shees"),
        dictgen::InsensitiveStr::Ascii("shs"),
        dictgen::InsensitiveStr::Ascii("shuset"),
        dictgen::InsensitiveStr::Ascii("sse"),
        dictgen::InsensitiveStr::Ascii("telly"),
        dictgen::InsensitiveStr::Ascii("tessen"),
        dictgen::InsensitiveStr::Ascii("tey"),
        dictgen::InsensitiveStr::Ascii("ticain"),
        dictgen::InsensitiveStr::Ascii("ticains"),
        dictgen::InsensitiveStr::Ascii("ticaly"),
        dictgen::InsensitiveStr::Ascii("tican"),
        dictgen::InsensitiveStr::Ascii("ticans"),
        dictgen::InsensitiveStr::Ascii("ticanti"),
        dictgen::InsensitiveStr::Ascii("ticas"),
        dictgen::InsensitiveStr::Ascii("ticien"),
        dictgen::InsensitiveStr::Ascii("ticiens"),
        dictgen::InsensitiveStr::Ascii("ticin"),
        dictgen::InsensitiveStr::Ascii("ticing"),
        dictgen::InsensitiveStr::Ascii("ticion"),
        dictgen::InsensitiveStr::Ascii("tickin"),
        dictgen::InsensitiveStr::Ascii("ticus"),
        dictgen::InsensitiveStr::Ascii("tiicans"),
        dictgen::InsensitiveStr::Ascii("tiikan"),
        dictgen::InsensitiveStr::Ascii("tiness"),
        dictgen::InsensitiveStr::Ascii("ting"),
        dictgen::InsensitiveStr::Ascii("titian"),
        dictgen::InsensitiveStr::Ascii("titians"),
        dictgen::InsensitiveStr::Ascii("tley"),
    ],
    values: &[
        &["political"],
        &["politically"],
        &["policies", "policy", "police"],
        &["politically"],
        &["politician"],
        &["politicians"],
        &["policy"],
        &["police", "policies"],
        &["politely"],
        &["polygon"],
        &["polygons"],
        &["pollinator"],
        &["pollinators"],
        &["polishes"],
        &["polishes"],
        &["polishes"],
        &["polishes"],
        &["politely"],
        &["politeness"],
        &["politely"],
        &["politician"],
        &["politicians"],
        &["politically"],
        &["politician"],
        &["politicians"],
        &["politician"],
        &["politics"],
        &["politician"],
        &["politicians"],
        &["politician"],
        &["politician", "politicking"],
        &["politician"],
        &["politician"],
        &["politics"],
        &["politician"],
        &["politician"],
        &["politeness"],
        &["piloting"],
        &["politician"],
        &["politicians"],
        &["politely"],
    ],
    range: 3..=7,
};

static WORD_POLG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_POLG_CHILDREN),
    value: None,
};

pub static WORD_POLG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("on"),
        dictgen::InsensitiveStr::Ascii("ons"),
        dictgen::InsensitiveStr::Ascii("yamy"),
        dictgen::InsensitiveStr::Ascii("yon"),
    ],
    values: &[&["polygon"], &["polygons"], &["polygamy"], &["polygon"]],
    range: 2..=4,
};

static WORD_POLC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_POLC_CHILDREN),
    value: None,
};

pub static WORD_POLC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ies"),
        dictgen::InsensitiveStr::Ascii("iy"),
        dictgen::InsensitiveStr::Ascii("y"),
    ],
    values: &[&["policies"], &["policy"], &["policy"]],
    range: 1..=3,
};

static WORD_POLA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_POLA_CHILDREN),
    value: None,
};

pub static WORD_POLA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("riy")],
    values: &[&["polarity"]],
    range: 3..=3,
};

static WORD_POK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_POK_CHILDREN),
    value: None,
};

pub static WORD_POK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("et")],
    values: &[&["pocket"]],
    range: 2..=2,
};

static WORD_POJ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_POJ_CHILDREN),
    value: None,
};

pub static WORD_POJ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ect"),
        dictgen::InsensitiveStr::Ascii("ecting"),
        dictgen::InsensitiveStr::Ascii("nt"),
        dictgen::InsensitiveStr::Ascii("rect"),
        dictgen::InsensitiveStr::Ascii("rected"),
        dictgen::InsensitiveStr::Ascii("recting"),
        dictgen::InsensitiveStr::Ascii("rection"),
        dictgen::InsensitiveStr::Ascii("rections"),
        dictgen::InsensitiveStr::Ascii("rector"),
        dictgen::InsensitiveStr::Ascii("rectors"),
        dictgen::InsensitiveStr::Ascii("rects"),
    ],
    values: &[
        &["project"],
        &["projecting"],
        &["point"],
        &["project"],
        &["projected"],
        &["projecting"],
        &["projection"],
        &["projections"],
        &["projector"],
        &["projectors"],
        &["projects"],
    ],
    range: 2..=8,
};

static WORD_POI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_POI_CHILDREN),
    value: None,
};

pub static WORD_POI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cies"),
        dictgen::InsensitiveStr::Ascii("cy"),
        dictgen::InsensitiveStr::Ascii("gnat"),
        dictgen::InsensitiveStr::Ascii("int"),
        dictgen::InsensitiveStr::Ascii("ints"),
        dictgen::InsensitiveStr::Ascii("n"),
        dictgen::InsensitiveStr::Ascii("nd"),
        dictgen::InsensitiveStr::Ascii("ndcloud"),
        dictgen::InsensitiveStr::Ascii("neer"),
        dictgen::InsensitiveStr::Ascii("ner"),
        dictgen::InsensitiveStr::Ascii("ng"),
        dictgen::InsensitiveStr::Ascii("ngant"),
        dictgen::InsensitiveStr::Ascii("nits"),
        dictgen::InsensitiveStr::Ascii("nnter"),
        dictgen::InsensitiveStr::Ascii("ns"),
        dictgen::InsensitiveStr::Ascii("nteres"),
        dictgen::InsensitiveStr::Ascii("ntes"),
        dictgen::InsensitiveStr::Ascii("ntetr"),
        dictgen::InsensitiveStr::Ascii("ntetrs"),
        dictgen::InsensitiveStr::Ascii("nteur"),
        dictgen::InsensitiveStr::Ascii("ntseta"),
        dictgen::InsensitiveStr::Ascii("ntss"),
        dictgen::InsensitiveStr::Ascii("nture"),
        dictgen::InsensitiveStr::Ascii("ntzer"),
        dictgen::InsensitiveStr::Ascii("nyent"),
        dictgen::InsensitiveStr::Ascii("sin"),
        dictgen::InsensitiveStr::Ascii("sition"),
        dictgen::InsensitiveStr::Ascii("sitioned"),
        dictgen::InsensitiveStr::Ascii("sitioning"),
        dictgen::InsensitiveStr::Ascii("sitionning"),
        dictgen::InsensitiveStr::Ascii("sitions"),
        dictgen::InsensitiveStr::Ascii("sond"),
        dictgen::InsensitiveStr::Ascii("sones"),
        dictgen::InsensitiveStr::Ascii("sonis"),
        dictgen::InsensitiveStr::Ascii("sonos"),
        dictgen::InsensitiveStr::Ascii("sonus"),
        dictgen::InsensitiveStr::Ascii("stion"),
        dictgen::InsensitiveStr::Ascii("stioned"),
        dictgen::InsensitiveStr::Ascii("stioning"),
        dictgen::InsensitiveStr::Ascii("stions"),
        dictgen::InsensitiveStr::Ascii("stive"),
        dictgen::InsensitiveStr::Ascii("stively"),
        dictgen::InsensitiveStr::Ascii("stives"),
        dictgen::InsensitiveStr::Ascii("stivly"),
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("td"),
        dictgen::InsensitiveStr::Ascii("ted"),
        dictgen::InsensitiveStr::Ascii("ter"),
        dictgen::InsensitiveStr::Ascii("ters"),
        dictgen::InsensitiveStr::Ascii("ting"),
        dictgen::InsensitiveStr::Ascii("tless"),
        dictgen::InsensitiveStr::Ascii("tlessly"),
        dictgen::InsensitiveStr::Ascii("tn"),
        dictgen::InsensitiveStr::Ascii("tnd"),
        dictgen::InsensitiveStr::Ascii("tned"),
        dictgen::InsensitiveStr::Ascii("tner"),
        dictgen::InsensitiveStr::Ascii("tnes"),
        dictgen::InsensitiveStr::Ascii("tning"),
        dictgen::InsensitiveStr::Ascii("tns"),
        dictgen::InsensitiveStr::Ascii("ts"),
        dictgen::InsensitiveStr::Ascii("unter"),
    ],
    values: &[
        &["policies"],
        &["policy"],
        &["poignant"],
        &["point"],
        &["points"],
        &["point"],
        &["point"],
        &["pointcloud"],
        &["pioneer"],
        &["pointer"],
        &["point"],
        &["poignant"],
        &["points"],
        &["pointer"],
        &["points"],
        &["pointers"],
        &["pointers", "points"],
        &["pointer"],
        &["pointers"],
        &["pointer"],
        &["poinsettia"],
        &["points"],
        &["pointer"],
        &["pointer"],
        &["poignant"],
        &["poison"],
        &["position"],
        &["positioned"],
        &["positioning"],
        &["positioning"],
        &["positions"],
        &["poisoned"],
        &["poisons"],
        &["poisons"],
        &["poisons"],
        &["poisons"],
        &["position"],
        &["positioned"],
        &["positioning"],
        &["positions"],
        &["positive"],
        &["positively"],
        &["positives"],
        &["positively"],
        &["point"],
        &["pointed"],
        &["pointed"],
        &["pointer"],
        &["pointers"],
        &["pointing"],
        &["pointless"],
        &["pointlessly"],
        &["point"],
        &["pointed"],
        &["pointed"],
        &["pointer"],
        &["points"],
        &["pointing"],
        &["points"],
        &["points"],
        &["pointer"],
    ],
    range: 1..=10,
};

static WORD_POG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_POG_CHILDREN),
    value: None,
};

pub static WORD_POG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ress")],
    values: &[&["progress"]],
    range: 4..=4,
};

static WORD_POE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_POE_CHILDREN),
    value: None,
};

pub static WORD_POE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("nis"),
        dictgen::InsensitiveStr::Ascii("ntial"),
        dictgen::InsensitiveStr::Ascii("ntially"),
        dictgen::InsensitiveStr::Ascii("ntials"),
        dictgen::InsensitiveStr::Ascii("oples"),
        dictgen::InsensitiveStr::Ascii("ple"),
        dictgen::InsensitiveStr::Ascii("ples"),
        dictgen::InsensitiveStr::Ascii("r"),
        dictgen::InsensitiveStr::Ascii("rful"),
        dictgen::InsensitiveStr::Ascii("rs"),
        dictgen::InsensitiveStr::Ascii("ty"),
    ],
    values: &[
        &["penis"],
        &["potential"],
        &["potentially"],
        &["potentials"],
        &["peoples"],
        &["people"],
        &["peoples"],
        &["power", "poor", "pour"],
        &["powerful"],
        &["powers"],
        &["poetry"],
    ],
    range: 1..=7,
};

static WORD_POD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_POD_CHILDREN),
    value: None,
};

pub static WORD_POD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("emso"),
        dictgen::InsensitiveStr::Ascii("fie"),
        dictgen::InsensitiveStr::Ascii("meos"),
        dictgen::InsensitiveStr::Ascii("ule"),
    ],
    values: &[&["podemos"], &["podfile"], &["podemos"], &["module"]],
    range: 3..=4,
};

static WORD_POC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_POC_CHILDREN),
    value: None,
};

pub static WORD_POC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ess"),
        dictgen::InsensitiveStr::Ascii("essed"),
        dictgen::InsensitiveStr::Ascii("ession"),
    ],
    values: &[
        &["process", "possess"],
        &["processed", "possessed"],
        &["procession", "possession"],
    ],
    range: 3..=6,
};

static WORD_POB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_POB_CHILDREN),
    value: None,
};

pub static WORD_POB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ular"),
        dictgen::InsensitiveStr::Ascii("ularity"),
    ],
    values: &[&["popular"], &["popularity"]],
    range: 4..=7,
};

static WORD_PN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PN_CHILDREN),
    value: None,
};

pub static WORD_PN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("atheon")],
    values: &[&["pantheon"]],
    range: 6..=6,
};

static WORD_PL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_PL_CHILDREN),
    value: None,
};

static WORD_PL_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_PLA_NODE),
    None,
    Some(&WORD_PLC_NODE),
    None,
    Some(&WORD_PLE_NODE),
    None,
    Some(&WORD_PLG_NODE),
    None,
    Some(&WORD_PLI_NODE),
    None,
    None,
    Some(&WORD_PLL_NODE),
    None,
    None,
    Some(&WORD_PLO_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_PLT_NODE),
    Some(&WORD_PLU_NODE),
    None,
    None,
    None,
    Some(&WORD_PLY_NODE),
    None,
];

static WORD_PLY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PLY_CHILDREN),
    value: None,
};

pub static WORD_PLY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("otropy")],
    values: &[&["pleiotropy"]],
    range: 6..=6,
};

static WORD_PLU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PLU_CHILDREN),
    value: None,
};

pub static WORD_PLU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("gable"),
        dictgen::InsensitiveStr::Ascii("ged"),
        dictgen::InsensitiveStr::Ascii("ggin"),
        dictgen::InsensitiveStr::Ascii("ging"),
        dictgen::InsensitiveStr::Ascii("ginss"),
        dictgen::InsensitiveStr::Ascii("ign"),
        dictgen::InsensitiveStr::Ascii("igns"),
        dictgen::InsensitiveStr::Ascii("se"),
    ],
    values: &[
        &["pluggable"],
        &["plugged"],
        &["plugin"],
        &["plugging", "plugin"],
        &["plugins"],
        &["plugin"],
        &["plugins"],
        &["pulse"],
    ],
    range: 2..=5,
};

static WORD_PLT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PLT_CHILDREN),
    value: None,
};

pub static WORD_PLT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("form"),
        dictgen::InsensitiveStr::Ascii("forms"),
    ],
    values: &[&["platform"], &["platforms"]],
    range: 4..=5,
};

static WORD_PLO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PLO_CHILDREN),
    value: None,
};

pub static WORD_PLO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("arized"),
        dictgen::InsensitiveStr::Ascii("retariat"),
        dictgen::InsensitiveStr::Ascii("ted"),
        dictgen::InsensitiveStr::Ascii("ting"),
        dictgen::InsensitiveStr::Ascii("ygamy"),
        dictgen::InsensitiveStr::Ascii("ygon"),
        dictgen::InsensitiveStr::Ascii("ymer"),
        dictgen::InsensitiveStr::Ascii("ynomial"),
        dictgen::InsensitiveStr::Ascii("ynomials"),
    ],
    values: &[
        &["polarized"],
        &["proletariat"],
        &["plotted"],
        &["plotting"],
        &["polygamy"],
        &["polygon"],
        &["polymer"],
        &["polynomial"],
        &["polynomials"],
    ],
    range: 3..=8,
};

static WORD_PLL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PLL_CHILDREN),
    value: None,
};

pub static WORD_PLL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("atforms")],
    values: &[&["platforms"]],
    range: 7..=7,
};

static WORD_PLI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PLI_CHILDREN),
    value: None,
};

pub static WORD_PLI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("an"),
        dictgen::InsensitiveStr::Ascii("ars"),
        dictgen::InsensitiveStr::Ascii("grim"),
    ],
    values: &[&["plain", "pliant"], &["pliers"], &["pilgrim"]],
    range: 2..=4,
};

static WORD_PLG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PLG_CHILDREN),
    value: None,
};

pub static WORD_PLG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("uin")],
    values: &[&["plugin"]],
    range: 3..=3,
};

static WORD_PLE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PLE_CHILDREN),
    value: None,
};

pub static WORD_PLE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aase"),
        dictgen::InsensitiveStr::Ascii("ace"),
        dictgen::InsensitiveStr::Ascii("acing"),
        dictgen::InsensitiveStr::Ascii("ae"),
        dictgen::InsensitiveStr::Ascii("aee"),
        dictgen::InsensitiveStr::Ascii("aes"),
        dictgen::InsensitiveStr::Ascii("asd"),
        dictgen::InsensitiveStr::Ascii("asent"),
        dictgen::InsensitiveStr::Ascii("asently"),
        dictgen::InsensitiveStr::Ascii("ass"),
        dictgen::InsensitiveStr::Ascii("bicite"),
        dictgen::InsensitiveStr::Ascii("cing"),
        dictgen::InsensitiveStr::Ascii("htora"),
        dictgen::InsensitiveStr::Ascii("nt"),
        dictgen::InsensitiveStr::Ascii("othra"),
        dictgen::InsensitiveStr::Ascii("sae"),
        dictgen::InsensitiveStr::Ascii("sant"),
        dictgen::InsensitiveStr::Ascii("se"),
        dictgen::InsensitiveStr::Ascii("sently"),
        dictgen::InsensitiveStr::Ascii("sing"),
        dictgen::InsensitiveStr::Ascii("thoria"),
        dictgen::InsensitiveStr::Ascii("thorian"),
        dictgen::InsensitiveStr::Ascii("throa"),
    ],
    values: &[
        &["please"],
        &["please", "place"],
        &["placing"],
        &["please"],
        &["please"],
        &["please"],
        &["pleased"],
        &["pleasant"],
        &["pleasantly"],
        &["pleases", "bless"],
        &["plebiscite"],
        &["placing"],
        &["plethora"],
        &["plenty"],
        &["plethora"],
        &["please"],
        &["pleasant"],
        &["please"],
        &["pleasantly"],
        &["pleasing", "blessing"],
        &["plethora"],
        &["plethora"],
        &["plethora"],
    ],
    range: 2..=7,
};

static WORD_PLC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PLC_CHILDREN),
    value: None,
};

pub static WORD_PLC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ae"),
        dictgen::InsensitiveStr::Ascii("aebo"),
        dictgen::InsensitiveStr::Ascii("aed"),
        dictgen::InsensitiveStr::Ascii("aeholder"),
        dictgen::InsensitiveStr::Ascii("aeholders"),
        dictgen::InsensitiveStr::Ascii("aement"),
        dictgen::InsensitiveStr::Ascii("aements"),
        dictgen::InsensitiveStr::Ascii("aes"),
        dictgen::InsensitiveStr::Ascii("eholder"),
    ],
    values: &[
        &["place"],
        &["placebo"],
        &["placed"],
        &["placeholder"],
        &["placeholders"],
        &["placement"],
        &["placements"],
        &["places"],
        &["placeholder"],
    ],
    range: 2..=9,
};

static WORD_PLA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_PLA_CHILDREN),
    value: None,
};

static WORD_PLA_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    Some(&WORD_PLAB_NODE),
    Some(&WORD_PLAC_NODE),
    Some(&WORD_PLAD_NODE),
    Some(&WORD_PLAE_NODE),
    Some(&WORD_PLAF_NODE),
    Some(&WORD_PLAG_NODE),
    None,
    Some(&WORD_PLAI_NODE),
    None,
    None,
    Some(&WORD_PLAL_NODE),
    None,
    Some(&WORD_PLAN_NODE),
    None,
    None,
    None,
    Some(&WORD_PLAR_NODE),
    Some(&WORD_PLAS_NODE),
    Some(&WORD_PLAT_NODE),
    Some(&WORD_PLAU_NODE),
    None,
    None,
    None,
    Some(&WORD_PLAY_NODE),
    None,
];

static WORD_PLAY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PLAY_CHILDREN),
    value: None,
};

pub static WORD_PLAY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("abe"),
        dictgen::InsensitiveStr::Ascii("around"),
        dictgen::InsensitiveStr::Ascii("ble"),
        dictgen::InsensitiveStr::Ascii("body"),
        dictgen::InsensitiveStr::Ascii("ersare"),
        dictgen::InsensitiveStr::Ascii("full"),
        dictgen::InsensitiveStr::Ascii("ge"),
        dictgen::InsensitiveStr::Ascii("gerise"),
        dictgen::InsensitiveStr::Ascii("gerize"),
        dictgen::InsensitiveStr::Ascii("gorund"),
        dictgen::InsensitiveStr::Ascii("gropund"),
        dictgen::InsensitiveStr::Ascii("groud"),
        dictgen::InsensitiveStr::Ascii("htrough"),
        dictgen::InsensitiveStr::Ascii("htroughs"),
        dictgen::InsensitiveStr::Ascii("ist"),
        dictgen::InsensitiveStr::Ascii("ists"),
        dictgen::InsensitiveStr::Ascii("ofs"),
        dictgen::InsensitiveStr::Ascii("right"),
        dictgen::InsensitiveStr::Ascii("stlye"),
        dictgen::InsensitiveStr::Ascii("stye"),
        dictgen::InsensitiveStr::Ascii("tgroughs"),
        dictgen::InsensitiveStr::Ascii("thorugh"),
        dictgen::InsensitiveStr::Ascii("thorughs"),
        dictgen::InsensitiveStr::Ascii("thourgh"),
        dictgen::InsensitiveStr::Ascii("thourghs"),
        dictgen::InsensitiveStr::Ascii("throgh"),
        dictgen::InsensitiveStr::Ascii("throguh"),
        dictgen::InsensitiveStr::Ascii("throughers"),
        dictgen::InsensitiveStr::Ascii("throughts"),
        dictgen::InsensitiveStr::Ascii("througs"),
        dictgen::InsensitiveStr::Ascii("througth"),
        dictgen::InsensitiveStr::Ascii("throuh"),
        dictgen::InsensitiveStr::Ascii("throuhg"),
        dictgen::InsensitiveStr::Ascii("throuhgs"),
        dictgen::InsensitiveStr::Ascii("thtough"),
        dictgen::InsensitiveStr::Ascii("thtoughs"),
        dictgen::InsensitiveStr::Ascii("trhough"),
        dictgen::InsensitiveStr::Ascii("trhoughs"),
        dictgen::InsensitiveStr::Ascii("write"),
        dictgen::InsensitiveStr::Ascii("writes"),
    ],
    values: &[
        &["playable"],
        &["playground"],
        &["playable"],
        &["playboy"],
        &["playerbase"],
        &["playful", "playfully"],
        &["plague"],
        &["plagiarise"],
        &["plagiarize"],
        &["playground"],
        &["playground"],
        &["playground"],
        &["playthrough"],
        &["playthroughs"],
        &["playlist"],
        &["playlists"],
        &["playoffs"],
        &["playwright"],
        &["playstyle"],
        &["playstyle"],
        &["playthroughs"],
        &["playthrough"],
        &["playthroughs"],
        &["playthrough"],
        &["playthroughs"],
        &["playthrough"],
        &["playthroughs"],
        &["playthroughs"],
        &["playthroughs"],
        &["playthroughs"],
        &["playthroughs"],
        &["playthrough"],
        &["playthroughs"],
        &["playthroughs"],
        &["playthrough"],
        &["playthroughs"],
        &["playthrough"],
        &["playthroughs"],
        &["playwright"],
        &["playwrights"],
    ],
    range: 2..=10,
};

static WORD_PLAU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PLAU_CHILDREN),
    value: None,
};

pub static WORD_PLAU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("sability"),
        dictgen::InsensitiveStr::Ascii("sable"),
        dictgen::InsensitiveStr::Ascii("sbile"),
        dictgen::InsensitiveStr::Ascii("sibe"),
        dictgen::InsensitiveStr::Ascii("sibel"),
        dictgen::InsensitiveStr::Ascii("throughs"),
    ],
    values: &[
        &["plausibility"],
        &["plausible"],
        &["plausible"],
        &["plausible"],
        &["plausible"],
        &["playthroughs"],
    ],
    range: 4..=8,
};

static WORD_PLAT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PLAT_CHILDREN),
    value: None,
};

pub static WORD_PLAT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aeu"),
        dictgen::InsensitiveStr::Ascii("eu"),
        dictgen::InsensitiveStr::Ascii("eua"),
        dictgen::InsensitiveStr::Ascii("farm"),
        dictgen::InsensitiveStr::Ascii("farmer"),
        dictgen::InsensitiveStr::Ascii("farms"),
        dictgen::InsensitiveStr::Ascii("fform"),
        dictgen::InsensitiveStr::Ascii("fforms"),
        dictgen::InsensitiveStr::Ascii("florm"),
        dictgen::InsensitiveStr::Ascii("florms"),
        dictgen::InsensitiveStr::Ascii("foem"),
        dictgen::InsensitiveStr::Ascii("fom"),
        dictgen::InsensitiveStr::Ascii("fomr"),
        dictgen::InsensitiveStr::Ascii("fomrs"),
        dictgen::InsensitiveStr::Ascii("foms"),
        dictgen::InsensitiveStr::Ascii("forma"),
        dictgen::InsensitiveStr::Ascii("formar"),
        dictgen::InsensitiveStr::Ascii("formie"),
        dictgen::InsensitiveStr::Ascii("formt"),
        dictgen::InsensitiveStr::Ascii("fotmer"),
        dictgen::InsensitiveStr::Ascii("from"),
        dictgen::InsensitiveStr::Ascii("fromer"),
        dictgen::InsensitiveStr::Ascii("fromers"),
        dictgen::InsensitiveStr::Ascii("froms"),
        dictgen::InsensitiveStr::Ascii("home"),
        dictgen::InsensitiveStr::Ascii("imun"),
        dictgen::InsensitiveStr::Ascii("nium"),
        dictgen::InsensitiveStr::Ascii("nuim"),
        dictgen::InsensitiveStr::Ascii("oe"),
        dictgen::InsensitiveStr::Ascii("oes"),
        dictgen::InsensitiveStr::Ascii("ofmr"),
        dictgen::InsensitiveStr::Ascii("ofmrs"),
        dictgen::InsensitiveStr::Ascii("ofms"),
        dictgen::InsensitiveStr::Ascii("ofmss"),
        dictgen::InsensitiveStr::Ascii("oform"),
        dictgen::InsensitiveStr::Ascii("oforms"),
        dictgen::InsensitiveStr::Ascii("ofrm"),
        dictgen::InsensitiveStr::Ascii("ofrmer"),
        dictgen::InsensitiveStr::Ascii("ofrms"),
        dictgen::InsensitiveStr::Ascii("orm"),
        dictgen::InsensitiveStr::Ascii("tform"),
        dictgen::InsensitiveStr::Ascii("tforms"),
        dictgen::InsensitiveStr::Ascii("toe"),
        dictgen::InsensitiveStr::Ascii("toes"),
    ],
    values: &[
        &["plateau"],
        &["plateau"],
        &["plateau"],
        &["platform"],
        &["platformer"],
        &["platforms"],
        &["platform"],
        &["platforms"],
        &["platform"],
        &["platforms"],
        &["platform"],
        &["platform"],
        &["platform"],
        &["platforms"],
        &["platforms"],
        &["platforms"],
        &["platformer"],
        &["platformer"],
        &["platforms"],
        &["platformer"],
        &["platform"],
        &["platformer"],
        &["platformer"],
        &["platforms"],
        &["platform"],
        &["platinum"],
        &["platinum"],
        &["platinum"],
        &["plateau"],
        &["plateaus"],
        &["platform"],
        &["platforms"],
        &["platforms"],
        &["platforms"],
        &["platform"],
        &["platforms"],
        &["platform"],
        &["platformer"],
        &["platforms"],
        &["platform"],
        &["platform"],
        &["platforms"],
        &["plateau"],
        &["plateaus"],
    ],
    range: 2..=7,
};

static WORD_PLAS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PLAS_CHILDREN),
    value: None,
};

pub static WORD_PLAS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("ement"),
        dictgen::InsensitiveStr::Ascii("ements"),
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("itcs"),
        dictgen::InsensitiveStr::Ascii("ticas"),
        dictgen::InsensitiveStr::Ascii("ticos"),
        dictgen::InsensitiveStr::Ascii("ticosa"),
        dictgen::InsensitiveStr::Ascii("ticus"),
        dictgen::InsensitiveStr::Ascii("tis"),
        dictgen::InsensitiveStr::Ascii("tre"),
    ],
    values: &[
        &["place", "please", "phase", "plaice"],
        &["placed", "pleased", "phased"],
        &["placement"],
        &["placements"],
        &["places", "pleases", "phases"],
        &["placing", "pleasing", "phasing"],
        &["plastics"],
        &["plastics"],
        &["plastics"],
        &["plastics"],
        &["plastics"],
        &["plastics"],
        &["plaster"],
    ],
    range: 1..=6,
};

static WORD_PLAR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PLAR_CHILDREN),
    value: None,
};

pub static WORD_PLAR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("form")],
    values: &[&["platform"]],
    range: 4..=4,
};

static WORD_PLAN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PLAN_CHILDREN),
    value: None,
};

pub static WORD_PLAN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("atery"),
        dictgen::InsensitiveStr::Ascii("ation"),
        dictgen::InsensitiveStr::Ascii("eswaker"),
        dictgen::InsensitiveStr::Ascii("eswaler"),
        dictgen::InsensitiveStr::Ascii("eswalkr"),
        dictgen::InsensitiveStr::Ascii("eswaller"),
        dictgen::InsensitiveStr::Ascii("eswlaker"),
        dictgen::InsensitiveStr::Ascii("eswlakers"),
        dictgen::InsensitiveStr::Ascii("etas"),
        dictgen::InsensitiveStr::Ascii("etos"),
        dictgen::InsensitiveStr::Ascii("etwalker"),
        dictgen::InsensitiveStr::Ascii("sewalker"),
        dictgen::InsensitiveStr::Ascii("sewalkers"),
        dictgen::InsensitiveStr::Ascii("teary"),
        dictgen::InsensitiveStr::Ascii("tes"),
        dictgen::InsensitiveStr::Ascii("text"),
        dictgen::InsensitiveStr::Ascii("tiff"),
        dictgen::InsensitiveStr::Ascii("tium"),
    ],
    values: &[
        &["planetary"],
        &["plantation"],
        &["planeswalker"],
        &["planeswalker"],
        &["planeswalker"],
        &["planeswalker"],
        &["planeswalker"],
        &["planeswalker"],
        &["planets"],
        &["planets"],
        &["planeswalker"],
        &["planeswalker"],
        &["planeswalker"],
        &["planetary"],
        &["planets"],
        &["plaintext"],
        &["plaintiff"],
        &["platinum"],
    ],
    range: 3..=9,
};

static WORD_PLAL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PLAL_CHILDREN),
    value: None,
};

pub static WORD_PLAL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("form"),
        dictgen::InsensitiveStr::Ascii("forms"),
    ],
    values: &[&["platform"], &["platforms"]],
    range: 4..=5,
};

static WORD_PLAI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PLAI_CHILDREN),
    value: None,
};

pub static WORD_PLAI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("garism")],
    values: &[&["plagiarism"]],
    range: 6..=6,
};

static WORD_PLAG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PLAG_CHILDREN),
    value: None,
};

pub static WORD_PLAG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("airism"),
        dictgen::InsensitiveStr::Ascii("arisim"),
        dictgen::InsensitiveStr::Ascii("arism"),
        dictgen::InsensitiveStr::Ascii("erism"),
        dictgen::InsensitiveStr::Ascii("iariam"),
        dictgen::InsensitiveStr::Ascii("iariasm"),
        dictgen::InsensitiveStr::Ascii("iarios"),
        dictgen::InsensitiveStr::Ascii("iarius"),
        dictgen::InsensitiveStr::Ascii("iarizm"),
        dictgen::InsensitiveStr::Ascii("ierism"),
        dictgen::InsensitiveStr::Ascii("uarism"),
    ],
    values: &[
        &["plagiarism"],
        &["plagiarism"],
        &["plagiarism"],
        &["plagiarism"],
        &["plagiarism"],
        &["plagiarism"],
        &["plagiarism"],
        &["plagiarism"],
        &["plagiarism"],
        &["plagiarism"],
        &["plagiarism"],
    ],
    range: 5..=7,
};

static WORD_PLAF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PLAF_CHILDREN),
    value: None,
};

pub static WORD_PLAF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("orm"),
        dictgen::InsensitiveStr::Ascii("orms"),
        dictgen::InsensitiveStr::Ascii("torm"),
        dictgen::InsensitiveStr::Ascii("torms"),
    ],
    values: &[&["platform"], &["platforms"], &["platform"], &["platforms"]],
    range: 3..=5,
};

static WORD_PLAE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PLAE_CHILDREN),
    value: None,
};

pub static WORD_PLAE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("stine"),
        dictgen::InsensitiveStr::Ascii("stinian"),
        dictgen::InsensitiveStr::Ascii("stinians"),
    ],
    values: &[&["palestine"], &["palestinian"], &["palestinians"]],
    range: 5..=8,
};

static WORD_PLAD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PLAD_CHILDREN),
    value: Some(&["plaid", "plead"]),
};

pub static WORD_PLAD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ed")],
    values: &[&["plaided", "pleaded"]],
    range: 2..=2,
};

static WORD_PLAC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PLAC_CHILDREN),
    value: None,
};

pub static WORD_PLAC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ebro"),
        dictgen::InsensitiveStr::Ascii("eemnt"),
        dictgen::InsensitiveStr::Ascii("eemnts"),
        dictgen::InsensitiveStr::Ascii("eheld"),
        dictgen::InsensitiveStr::Ascii("ehoder"),
        dictgen::InsensitiveStr::Ascii("eholde"),
        dictgen::InsensitiveStr::Ascii("eholdes"),
        dictgen::InsensitiveStr::Ascii("eholdr"),
        dictgen::InsensitiveStr::Ascii("eholer"),
        dictgen::InsensitiveStr::Ascii("eholers"),
        dictgen::InsensitiveStr::Ascii("ehoulder"),
        dictgen::InsensitiveStr::Ascii("ehoulders"),
        dictgen::InsensitiveStr::Ascii("ematt"),
        dictgen::InsensitiveStr::Ascii("emenet"),
        dictgen::InsensitiveStr::Ascii("emenets"),
        dictgen::InsensitiveStr::Ascii("emens"),
        dictgen::InsensitiveStr::Ascii("emet"),
        dictgen::InsensitiveStr::Ascii("emets"),
        dictgen::InsensitiveStr::Ascii("holder"),
        dictgen::InsensitiveStr::Ascii("holders"),
        dictgen::InsensitiveStr::Ascii("menet"),
        dictgen::InsensitiveStr::Ascii("menets"),
    ],
    values: &[
        &["placebo"],
        &["placement"],
        &["placements"],
        &["placeholder"],
        &["placeholder"],
        &["placeholder"],
        &["placeholders"],
        &["placeholder"],
        &["placeholder"],
        &["placeholders"],
        &["placeholder"],
        &["placeholders"],
        &["placemat", "placement"],
        &["placements", "placement"],
        &["placements"],
        &["placements"],
        &["placements", "placement", "placemat"],
        &["placements", "placemats"],
        &["placeholder"],
        &["placeholders"],
        &["placement"],
        &["placements"],
    ],
    range: 4..=9,
};

static WORD_PLAB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PLAB_CHILDREN),
    value: None,
};

pub static WORD_PLAB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("eswalker")],
    values: &[&["planeswalker"]],
    range: 8..=8,
};

static WORD_PK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PK_CHILDREN),
    value: None,
};

pub static WORD_PK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("aythroughs")],
    values: &[&["playthroughs"]],
    range: 10..=10,
};

static WORD_PI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_PI_CHILDREN),
    value: None,
};

static WORD_PI_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_PIA_NODE),
    Some(&WORD_PIB_NODE),
    Some(&WORD_PIC_NODE),
    None,
    Some(&WORD_PIE_NODE),
    None,
    Some(&WORD_PIG_NODE),
    None,
    None,
    Some(&WORD_PIJ_NODE),
    None,
    Some(&WORD_PIL_NODE),
    Some(&WORD_PIM_NODE),
    Some(&WORD_PIN_NODE),
    Some(&WORD_PIO_NODE),
    Some(&WORD_PIP_NODE),
    None,
    Some(&WORD_PIR_NODE),
    None,
    Some(&WORD_PIT_NODE),
    None,
    Some(&WORD_PIV_NODE),
    None,
    Some(&WORD_PIX_NODE),
    None,
    None,
];

static WORD_PIX_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PIX_CHILDREN),
    value: None,
};

pub static WORD_PIX_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("elx"),
        dictgen::InsensitiveStr::Ascii("es"),
    ],
    values: &[&["pixels", "pixel"], &["pixels"]],
    range: 2..=3,
};

static WORD_PIV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PIV_CHILDREN),
    value: None,
};

pub static WORD_PIV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ott"),
        dictgen::InsensitiveStr::Ascii("otting"),
    ],
    values: &[&["pivot"], &["pivoting"]],
    range: 3..=6,
};

static WORD_PIT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PIT_CHILDREN),
    value: None,
};

pub static WORD_PIT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("chferks"),
        dictgen::InsensitiveStr::Ascii("chfolks"),
        dictgen::InsensitiveStr::Ascii("chforcks"),
        dictgen::InsensitiveStr::Ascii("chfords"),
        dictgen::InsensitiveStr::Ascii("chforkers"),
        dictgen::InsensitiveStr::Ascii("chforkes"),
        dictgen::InsensitiveStr::Ascii("chworks"),
        dictgen::InsensitiveStr::Ascii("ckforks"),
        dictgen::InsensitiveStr::Ascii("hcers"),
        dictgen::InsensitiveStr::Ascii("hces"),
        dictgen::InsensitiveStr::Ascii("map"),
        dictgen::InsensitiveStr::Ascii("taburgh"),
        dictgen::InsensitiveStr::Ascii("tsbrugh"),
        dictgen::InsensitiveStr::Ascii("ty"),
    ],
    values: &[
        &["pitchforks"],
        &["pitchforks"],
        &["pitchforks"],
        &["pitchforks"],
        &["pitchforks"],
        &["pitchforks"],
        &["pitchforks"],
        &["pitchforks"],
        &["pitchers"],
        &["pitches"],
        &["pixmap", "bitmap"],
        &["pittsburgh"],
        &["pittsburgh"],
        &["pity"],
    ],
    range: 2..=9,
};

static WORD_PIR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PIR_CHILDREN),
    value: None,
};

pub static WORD_PIR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eced"),
        dictgen::InsensitiveStr::Ascii("ric"),
    ],
    values: &[&["pierced"], &["pyrrhic"]],
    range: 3..=4,
};

static WORD_PIP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PIP_CHILDREN),
    value: None,
};

pub static WORD_PIP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eine"),
        dictgen::InsensitiveStr::Ascii("eines"),
        dictgen::InsensitiveStr::Ascii("elien"),
        dictgen::InsensitiveStr::Ascii("eliens"),
        dictgen::InsensitiveStr::Ascii("elin"),
        dictgen::InsensitiveStr::Ascii("elinining"),
        dictgen::InsensitiveStr::Ascii("elins"),
        dictgen::InsensitiveStr::Ascii("epline"),
        dictgen::InsensitiveStr::Ascii("eplines"),
        dictgen::InsensitiveStr::Ascii("iline"),
        dictgen::InsensitiveStr::Ascii("ilines"),
        dictgen::InsensitiveStr::Ascii("leine"),
        dictgen::InsensitiveStr::Ascii("leines"),
        dictgen::InsensitiveStr::Ascii("leline"),
        dictgen::InsensitiveStr::Ascii("lelines"),
        dictgen::InsensitiveStr::Ascii("line"),
        dictgen::InsensitiveStr::Ascii("lines"),
    ],
    values: &[
        &["pipeline"],
        &["pipelines"],
        &["pipeline"],
        &["pipelines"],
        &["pipeline"],
        &["pipelining"],
        &["pipelines"],
        &["pipeline"],
        &["pipelines"],
        &["pipeline"],
        &["pipelines"],
        &["pipeline"],
        &["pipelines"],
        &["pipeline"],
        &["pipelines"],
        &["pipeline"],
        &["pipelines"],
    ],
    range: 4..=9,
};

static WORD_PIO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PIO_CHILDREN),
    value: None,
};

pub static WORD_PIO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("lting"),
        dictgen::InsensitiveStr::Ascii("neeer"),
        dictgen::InsensitiveStr::Ascii("nere"),
        dictgen::InsensitiveStr::Ascii("nt"),
        dictgen::InsensitiveStr::Ascii("nter"),
        dictgen::InsensitiveStr::Ascii("nts"),
        dictgen::InsensitiveStr::Ascii("rity"),
    ],
    values: &[
        &["piloting"],
        &["pioneer"],
        &["pioneer"],
        &["point"],
        &["pointer"],
        &["points"],
        &["priority"],
    ],
    range: 2..=5,
};

static WORD_PIN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PIN_CHILDREN),
    value: None,
};

pub static WORD_PIN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ancle"),
        dictgen::InsensitiveStr::Ascii("apple"),
        dictgen::InsensitiveStr::Ascii("cher"),
        dictgen::InsensitiveStr::Ascii("etrest"),
        dictgen::InsensitiveStr::Ascii("nalce"),
        dictgen::InsensitiveStr::Ascii("naple"),
        dictgen::InsensitiveStr::Ascii("ncale"),
        dictgen::InsensitiveStr::Ascii("ockle"),
        dictgen::InsensitiveStr::Ascii("oeer"),
        dictgen::InsensitiveStr::Ascii("oneered"),
        dictgen::InsensitiveStr::Ascii("piont"),
        dictgen::InsensitiveStr::Ascii("poit"),
        dictgen::InsensitiveStr::Ascii("ter"),
        dictgen::InsensitiveStr::Ascii("teret"),
        dictgen::InsensitiveStr::Ascii("uchle"),
        dictgen::InsensitiveStr::Ascii("uckle"),
    ],
    values: &[
        &["pinnacle"],
        &["pineapple"],
        &["pinscher"],
        &["pinterest"],
        &["pinnacle"],
        &["pineapple"],
        &["pinnacle"],
        &["pinochle"],
        &["pioneer"],
        &["pioneered"],
        &["pinpoint"],
        &["pinpoint"],
        &["pointer", "printer"],
        &["pinterest"],
        &["pinochle"],
        &["pinochle"],
    ],
    range: 3..=7,
};

static WORD_PIM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PIM_CHILDREN),
    value: None,
};

pub static WORD_PIM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("xap"),
        dictgen::InsensitiveStr::Ascii("xaps"),
    ],
    values: &[&["pixmap"], &["pixmaps"]],
    range: 3..=4,
};

static WORD_PIL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PIL_CHILDREN),
    value: None,
};

pub static WORD_PIL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("girm"),
        dictgen::InsensitiveStr::Ascii("gram"),
        dictgen::InsensitiveStr::Ascii("gramidge"),
        dictgen::InsensitiveStr::Ascii("gramig"),
        dictgen::InsensitiveStr::Ascii("gramige"),
        dictgen::InsensitiveStr::Ascii("grimmage"),
        dictgen::InsensitiveStr::Ascii("grimmages"),
        dictgen::InsensitiveStr::Ascii("lards"),
        dictgen::InsensitiveStr::Ascii("laris"),
        dictgen::InsensitiveStr::Ascii("on"),
        dictgen::InsensitiveStr::Ascii("ons"),
        dictgen::InsensitiveStr::Ascii("rgim"),
    ],
    values: &[
        &["pilgrim"],
        &["pilgrim"],
        &["pilgrimage"],
        &["pilgrimage"],
        &["pilgrimage"],
        &["pilgrimage"],
        &["pilgrimages"],
        &["pillars"],
        &["pillars"],
        &["pillion", "pylon"],
        &["pillions", "pylons"],
        &["pilgrim"],
    ],
    range: 2..=9,
};

static WORD_PIJ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PIJ_CHILDREN),
    value: None,
};

pub static WORD_PIJ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eon"),
        dictgen::InsensitiveStr::Ascii("eons"),
        dictgen::InsensitiveStr::Ascii("un"),
        dictgen::InsensitiveStr::Ascii("uns"),
    ],
    values: &[&["pigeon"], &["pigeons"], &["pigeon"], &["pigeons"]],
    range: 2..=4,
};

static WORD_PIG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PIG_CHILDREN),
    value: None,
};

pub static WORD_PIG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("en"),
        dictgen::InsensitiveStr::Ascii("ens"),
        dictgen::InsensitiveStr::Ascii("gypack"),
        dictgen::InsensitiveStr::Ascii("gypacked"),
        dictgen::InsensitiveStr::Ascii("in"),
        dictgen::InsensitiveStr::Ascii("ins"),
        dictgen::InsensitiveStr::Ascii("lrim"),
        dictgen::InsensitiveStr::Ascii("oens"),
        dictgen::InsensitiveStr::Ascii("un"),
        dictgen::InsensitiveStr::Ascii("uns"),
    ],
    values: &[
        &["pigeon", "pigpen"],
        &["pigeons", "pigpens"],
        &["piggyback"],
        &["piggybacked"],
        &["pigeon"],
        &["pigeons"],
        &["pilgrim"],
        &["pigeons"],
        &["pigeon"],
        &["pigeons"],
    ],
    range: 2..=8,
};

static WORD_PIE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PIE_CHILDREN),
    value: None,
};

pub static WORD_PIE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ceweise"),
        dictgen::InsensitiveStr::Ascii("cewiese"),
        dictgen::InsensitiveStr::Ascii("cwise"),
        dictgen::InsensitiveStr::Ascii("gons"),
    ],
    values: &[&["piecewise"], &["piecewise"], &["piecewise"], &["pigeons"]],
    range: 4..=7,
};

static WORD_PIC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PIC_CHILDREN),
    value: None,
};

pub static WORD_PIC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("h"),
        dictgen::InsensitiveStr::Ascii("hed"),
        dictgen::InsensitiveStr::Ascii("hes"),
        dictgen::InsensitiveStr::Ascii("hing"),
        dictgen::InsensitiveStr::Ascii("knic"),
        dictgen::InsensitiveStr::Ascii("kniced"),
        dictgen::InsensitiveStr::Ascii("knicer"),
        dictgen::InsensitiveStr::Ascii("knicing"),
        dictgen::InsensitiveStr::Ascii("knicked"),
        dictgen::InsensitiveStr::Ascii("knicker"),
        dictgen::InsensitiveStr::Ascii("knicking"),
        dictgen::InsensitiveStr::Ascii("knicks"),
        dictgen::InsensitiveStr::Ascii("knics"),
        dictgen::InsensitiveStr::Ascii("kyune"),
        dictgen::InsensitiveStr::Ascii("kyunes"),
        dictgen::InsensitiveStr::Ascii("niced"),
        dictgen::InsensitiveStr::Ascii("nicer"),
        dictgen::InsensitiveStr::Ascii("nicing"),
        dictgen::InsensitiveStr::Ascii("nick"),
        dictgen::InsensitiveStr::Ascii("nicks"),
        dictgen::InsensitiveStr::Ascii("oseond"),
        dictgen::InsensitiveStr::Ascii("oseonds"),
        dictgen::InsensitiveStr::Ascii("thed"),
        dictgen::InsensitiveStr::Ascii("ther"),
        dictgen::InsensitiveStr::Ascii("thers"),
        dictgen::InsensitiveStr::Ascii("thes"),
        dictgen::InsensitiveStr::Ascii("thfork"),
        dictgen::InsensitiveStr::Ascii("thforks"),
        dictgen::InsensitiveStr::Ascii("turesk"),
        dictgen::InsensitiveStr::Ascii("tureskely"),
        dictgen::InsensitiveStr::Ascii("tureskly"),
        dictgen::InsensitiveStr::Ascii("tureskness"),
    ],
    values: &[
        &["piece"],
        &["pitch", "pick", "pinch"],
        &["picked", "pinched", "pitched"],
        &["pinches", "pitches"],
        &["picking", "pinching", "pitching"],
        &["picnic"],
        &["picnicked"],
        &["picnicker"],
        &["picnicking"],
        &["picnicked"],
        &["picnicker"],
        &["picnicking"],
        &["picnics"],
        &["picnics"],
        &["picayune"],
        &["picayunes"],
        &["picnicked"],
        &["picnicker"],
        &["picnicking"],
        &["picnic"],
        &["picnics"],
        &["picosecond"],
        &["picoseconds"],
        &["pitched"],
        &["pitcher"],
        &["pitchers"],
        &["pitches"],
        &["pitchfork"],
        &["pitchforks"],
        &["picturesque"],
        &["picturesquely"],
        &["picturesquely"],
        &["picturesqueness"],
    ],
    range: 1..=10,
};

static WORD_PIB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PIB_CHILDREN),
    value: None,
};

pub static WORD_PIB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("lisher")],
    values: &[&["publisher"]],
    range: 6..=6,
};

static WORD_PIA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PIA_CHILDREN),
    value: None,
};

pub static WORD_PIA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("nkillers"),
        dictgen::InsensitiveStr::Ascii("r"),
        dictgen::InsensitiveStr::Ascii("rs"),
    ],
    values: &[
        &["painkillers"],
        &["pair", "pier", "pliers"],
        &["pairs", "piers", "pliers"],
    ],
    range: 1..=8,
};

static WORD_PH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_PH_CHILDREN),
    value: None,
};

static WORD_PH_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_PHA_NODE),
    None,
    None,
    None,
    Some(&WORD_PHE_NODE),
    None,
    None,
    None,
    Some(&WORD_PHI_NODE),
    None,
    None,
    Some(&WORD_PHL_NODE),
    None,
    None,
    Some(&WORD_PHO_NODE),
    None,
    None,
    Some(&WORD_PHR_NODE),
    Some(&WORD_PHS_NODE),
    Some(&WORD_PHT_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_PHY_NODE),
    None,
];

static WORD_PHY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PHY_CHILDREN),
    value: None,
};

pub static WORD_PHY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("chedelics"),
        dictgen::InsensitiveStr::Ascii("chiatrist"),
        dictgen::InsensitiveStr::Ascii("chiatrists"),
        dictgen::InsensitiveStr::Ascii("chological"),
        dictgen::InsensitiveStr::Ascii("chologically"),
        dictgen::InsensitiveStr::Ascii("chologist"),
        dictgen::InsensitiveStr::Ascii("chologists"),
        dictgen::InsensitiveStr::Ascii("chopathic"),
        dictgen::InsensitiveStr::Ascii("cisian"),
        dictgen::InsensitiveStr::Ascii("cisians"),
        dictgen::InsensitiveStr::Ascii("cisist"),
        dictgen::InsensitiveStr::Ascii("cisists"),
        dictgen::InsensitiveStr::Ascii("iscal"),
        dictgen::InsensitiveStr::Ascii("iscally"),
        dictgen::InsensitiveStr::Ascii("iscs"),
        dictgen::InsensitiveStr::Ascii("isology"),
        dictgen::InsensitiveStr::Ascii("isque"),
        dictgen::InsensitiveStr::Ascii("losophical"),
        dictgen::InsensitiveStr::Ascii("losophically"),
        dictgen::InsensitiveStr::Ascii("scedelic"),
        dictgen::InsensitiveStr::Ascii("scedelics"),
        dictgen::InsensitiveStr::Ascii("scial"),
        dictgen::InsensitiveStr::Ascii("scially"),
        dictgen::InsensitiveStr::Ascii("sciatric"),
        dictgen::InsensitiveStr::Ascii("sciatrist"),
        dictgen::InsensitiveStr::Ascii("sciatrists"),
        dictgen::InsensitiveStr::Ascii("scis"),
        dictgen::InsensitiveStr::Ascii("scological"),
        dictgen::InsensitiveStr::Ascii("scologically"),
        dictgen::InsensitiveStr::Ascii("scologist"),
        dictgen::InsensitiveStr::Ascii("scologists"),
        dictgen::InsensitiveStr::Ascii("scology"),
        dictgen::InsensitiveStr::Ascii("scopath"),
        dictgen::InsensitiveStr::Ascii("scopathic"),
        dictgen::InsensitiveStr::Ascii("scopaths"),
        dictgen::InsensitiveStr::Ascii("sial"),
        dictgen::InsensitiveStr::Ascii("sicallity"),
        dictgen::InsensitiveStr::Ascii("sicaly"),
        dictgen::InsensitiveStr::Ascii("sican"),
        dictgen::InsensitiveStr::Ascii("sicans"),
        dictgen::InsensitiveStr::Ascii("sicials"),
        dictgen::InsensitiveStr::Ascii("siciens"),
        dictgen::InsensitiveStr::Ascii("sicion"),
        dictgen::InsensitiveStr::Ascii("sicions"),
        dictgen::InsensitiveStr::Ascii("sicis"),
        dictgen::InsensitiveStr::Ascii("sicits"),
        dictgen::InsensitiveStr::Ascii("sicks"),
        dictgen::InsensitiveStr::Ascii("sicts"),
        dictgen::InsensitiveStr::Ascii("sioligical"),
        dictgen::InsensitiveStr::Ascii("sioligy"),
        dictgen::InsensitiveStr::Ascii("siologial"),
        dictgen::InsensitiveStr::Ascii("siqe"),
        dictgen::InsensitiveStr::Ascii("sisan"),
        dictgen::InsensitiveStr::Ascii("sisans"),
        dictgen::InsensitiveStr::Ascii("sisian"),
        dictgen::InsensitiveStr::Ascii("sisians"),
        dictgen::InsensitiveStr::Ascii("sisict"),
        dictgen::InsensitiveStr::Ascii("sision"),
        dictgen::InsensitiveStr::Ascii("sisions"),
        dictgen::InsensitiveStr::Ascii("sisist"),
        dictgen::InsensitiveStr::Ascii("sqiue"),
        dictgen::InsensitiveStr::Ascii("thon"),
        dictgen::InsensitiveStr::Ascii("ton"),
    ],
    values: &[
        &["psychedelics"],
        &["psychiatrist"],
        &["psychiatrists"],
        &["psychological"],
        &["psychologically"],
        &["psychologist"],
        &["psychologists"],
        &["psychopathic"],
        &["physician"],
        &["physicians"],
        &["physicist"],
        &["physicists"],
        &["physical"],
        &["physically"],
        &["physics"],
        &["physiology"],
        &["physique"],
        &["philosophical"],
        &["philosophically"],
        &["psychedelic"],
        &["psychedelics"],
        &["physical"],
        &["physically"],
        &["psychiatric"],
        &["psychiatrist"],
        &["psychiatrists"],
        &["physics"],
        &["psychological"],
        &["psychologically"],
        &["psychologist"],
        &["psychologists"],
        &["psychology"],
        &["psychopath"],
        &["psychopathic"],
        &["psychopaths"],
        &["physical"],
        &["physically"],
        &["physically"],
        &["physician"],
        &["physicians"],
        &["physicians"],
        &["physicians"],
        &["physician"],
        &["physicians"],
        &["physicians"],
        &["physicist"],
        &["physics"],
        &["physicist"],
        &["physiological"],
        &["physiology"],
        &["physiological"],
        &["physique"],
        &["physician"],
        &["physicians"],
        &["physician"],
        &["physicians"],
        &["physicist"],
        &["physician"],
        &["physicians"],
        &["physicist"],
        &["physique"],
        &["python"],
        &["python"],
    ],
    range: 3..=12,
};

static WORD_PHT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PHT_CHILDREN),
    value: None,
};

pub static WORD_PHT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("read"),
        dictgen::InsensitiveStr::Ascii("reads"),
    ],
    values: &[&["pthread"], &["pthreads"]],
    range: 4..=5,
};

static WORD_PHS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PHS_CHILDREN),
    value: None,
};

pub static WORD_PHS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ical"),
        dictgen::InsensitiveStr::Ascii("ycologically"),
        dictgen::InsensitiveStr::Ascii("yical"),
        dictgen::InsensitiveStr::Ascii("yically"),
        dictgen::InsensitiveStr::Ascii("yician"),
        dictgen::InsensitiveStr::Ascii("yicians"),
        dictgen::InsensitiveStr::Ascii("yicist"),
        dictgen::InsensitiveStr::Ascii("yicists"),
        dictgen::InsensitiveStr::Ascii("yics"),
        dictgen::InsensitiveStr::Ascii("yiological"),
        dictgen::InsensitiveStr::Ascii("yiology"),
        dictgen::InsensitiveStr::Ascii("yique"),
    ],
    values: &[
        &["physical"],
        &["psychologically"],
        &["physical"],
        &["physically"],
        &["physician"],
        &["physicians"],
        &["physicist"],
        &["physicists"],
        &["physics"],
        &["physiological"],
        &["physiology"],
        &["physique"],
    ],
    range: 4..=12,
};

static WORD_PHR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PHR_CHILDREN),
    value: None,
};

pub static WORD_PHR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("amaceutical"),
        dictgen::InsensitiveStr::Ascii("amacist"),
        dictgen::InsensitiveStr::Ascii("amacy"),
    ],
    values: &[&["pharmaceutical"], &["pharmacist"], &["pharmacy"]],
    range: 5..=11,
};

static WORD_PHO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PHO_CHILDREN),
    value: None,
};

pub static WORD_PHO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("necian"),
        dictgen::InsensitiveStr::Ascii("nemena"),
        dictgen::InsensitiveStr::Ascii("neticly"),
        dictgen::InsensitiveStr::Ascii("ngraph"),
        dictgen::InsensitiveStr::Ascii("tagrapher"),
        dictgen::InsensitiveStr::Ascii("tagraphers"),
        dictgen::InsensitiveStr::Ascii("te"),
        dictgen::InsensitiveStr::Ascii("tochopped"),
        dictgen::InsensitiveStr::Ascii("tografic"),
        dictgen::InsensitiveStr::Ascii("tografical"),
        dictgen::InsensitiveStr::Ascii("tografy"),
        dictgen::InsensitiveStr::Ascii("togragh"),
        dictgen::InsensitiveStr::Ascii("tograh"),
        dictgen::InsensitiveStr::Ascii("tograhed"),
        dictgen::InsensitiveStr::Ascii("tograher"),
        dictgen::InsensitiveStr::Ascii("tograhic"),
        dictgen::InsensitiveStr::Ascii("tograhper"),
        dictgen::InsensitiveStr::Ascii("tograhpy"),
        dictgen::InsensitiveStr::Ascii("tograhs"),
        dictgen::InsensitiveStr::Ascii("tograhy"),
        dictgen::InsensitiveStr::Ascii("tograped"),
        dictgen::InsensitiveStr::Ascii("tograper"),
        dictgen::InsensitiveStr::Ascii("tograpers"),
        dictgen::InsensitiveStr::Ascii("tograpgh"),
        dictgen::InsensitiveStr::Ascii("tographes"),
        dictgen::InsensitiveStr::Ascii("tographics"),
        dictgen::InsensitiveStr::Ascii("tographied"),
        dictgen::InsensitiveStr::Ascii("tographier"),
        dictgen::InsensitiveStr::Ascii("tographyi"),
        dictgen::InsensitiveStr::Ascii("tograpic"),
        dictgen::InsensitiveStr::Ascii("tograpical"),
        dictgen::InsensitiveStr::Ascii("tograpphed"),
        dictgen::InsensitiveStr::Ascii("tograps"),
        dictgen::InsensitiveStr::Ascii("tograpy"),
        dictgen::InsensitiveStr::Ascii("togropher"),
        dictgen::InsensitiveStr::Ascii("togrophers"),
        dictgen::InsensitiveStr::Ascii("togrpah"),
        dictgen::InsensitiveStr::Ascii("togrpahed"),
        dictgen::InsensitiveStr::Ascii("togrpaher"),
        dictgen::InsensitiveStr::Ascii("togrpahers"),
        dictgen::InsensitiveStr::Ascii("togrpahs"),
        dictgen::InsensitiveStr::Ascii("togrpahy"),
        dictgen::InsensitiveStr::Ascii("toshipped"),
        dictgen::InsensitiveStr::Ascii("toshooped"),
        dictgen::InsensitiveStr::Ascii("toshopd"),
        dictgen::InsensitiveStr::Ascii("toshope"),
        dictgen::InsensitiveStr::Ascii("toshoppad"),
        dictgen::InsensitiveStr::Ascii("toshoppade"),
        dictgen::InsensitiveStr::Ascii("toshoppped"),
    ],
    values: &[
        &["phoenecian"],
        &["phenomena"],
        &["phonetically"],
        &["phonograph"],
        &["photographer"],
        &["photographers"],
        &["photo"],
        &["photoshopped"],
        &["photographic"],
        &["photographical"],
        &["photography"],
        &["photograph"],
        &["photograph"],
        &["photographed"],
        &["photographer"],
        &["photographic"],
        &["photographer"],
        &["photography"],
        &["photographs"],
        &["photography"],
        &["photographed"],
        &["photographer"],
        &["photographers"],
        &["photographs"],
        &["photographs"],
        &["photographs"],
        &["photographed"],
        &["photographer"],
        &["photographic"],
        &["photographic"],
        &["photographical"],
        &["photographed"],
        &["photographs"],
        &["photography"],
        &["photographer"],
        &["photographers"],
        &["photographs"],
        &["photographed"],
        &["photographer"],
        &["photographers"],
        &["photographs"],
        &["photography"],
        &["photoshopped"],
        &["photoshopped"],
        &["photoshopped"],
        &["photoshopped"],
        &["photoshopped"],
        &["photoshopped"],
        &["photoshopped"],
    ],
    range: 2..=10,
};

static WORD_PHL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PHL_CHILDREN),
    value: None,
};

pub static WORD_PHL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("em"),
        dictgen::InsensitiveStr::Ascii("ema"),
        dictgen::InsensitiveStr::Ascii("ematic"),
        dictgen::InsensitiveStr::Ascii("ematically"),
        dictgen::InsensitiveStr::Ascii("ematous"),
        dictgen::InsensitiveStr::Ascii("emy"),
    ],
    values: &[
        &["phlegm", "phloem"],
        &["phlegma"],
        &["phlegmatic"],
        &["phlegmatically"],
        &["phlegmatous"],
        &["phlegmy"],
    ],
    range: 2..=10,
};

static WORD_PHI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_PHI_CHILDREN),
    value: None,
};

static WORD_PHI_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_PHIA_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_PHIL_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_PHIS_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_PHIS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PHIS_CHILDREN),
    value: None,
};

pub static WORD_PHIS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ical"),
        dictgen::InsensitiveStr::Ascii("ically"),
        dictgen::InsensitiveStr::Ascii("icaly"),
        dictgen::InsensitiveStr::Ascii("ics"),
        dictgen::InsensitiveStr::Ascii("iological"),
        dictgen::InsensitiveStr::Ascii("osophy"),
    ],
    values: &[
        &["physical"],
        &["physically"],
        &["physically"],
        &["physics"],
        &["physiological"],
        &["philosophy"],
    ],
    range: 3..=9,
};

static WORD_PHIL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PHIL_CHILDREN),
    value: None,
};

pub static WORD_PHIL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("adalphia"),
        dictgen::InsensitiveStr::Ascii("adelhpia"),
        dictgen::InsensitiveStr::Ascii("adelpha"),
        dictgen::InsensitiveStr::Ascii("adelpia"),
        dictgen::InsensitiveStr::Ascii("adeplhia"),
        dictgen::InsensitiveStr::Ascii("adlephia"),
        dictgen::InsensitiveStr::Ascii("edalphia"),
        dictgen::InsensitiveStr::Ascii("edelphia"),
        dictgen::InsensitiveStr::Ascii("idalphia"),
        dictgen::InsensitiveStr::Ascii("iphines"),
        dictgen::InsensitiveStr::Ascii("ipines"),
        dictgen::InsensitiveStr::Ascii("ippenes"),
        dictgen::InsensitiveStr::Ascii("ippenis"),
        dictgen::InsensitiveStr::Ascii("ippides"),
        dictgen::InsensitiveStr::Ascii("ippinas"),
        dictgen::InsensitiveStr::Ascii("ippinnes"),
        dictgen::InsensitiveStr::Ascii("ippinoes"),
        dictgen::InsensitiveStr::Ascii("ippinos"),
        dictgen::InsensitiveStr::Ascii("ippins"),
        dictgen::InsensitiveStr::Ascii("isopher"),
        dictgen::InsensitiveStr::Ascii("isophers"),
        dictgen::InsensitiveStr::Ascii("isophical"),
        dictgen::InsensitiveStr::Ascii("isophies"),
        dictgen::InsensitiveStr::Ascii("isophy"),
        dictgen::InsensitiveStr::Ascii("lipine"),
        dictgen::InsensitiveStr::Ascii("lipines"),
        dictgen::InsensitiveStr::Ascii("lippines"),
        dictgen::InsensitiveStr::Ascii("lipse"),
        dictgen::InsensitiveStr::Ascii("lipses"),
        dictgen::InsensitiveStr::Ascii("losophically"),
        dictgen::InsensitiveStr::Ascii("oshopically"),
        dictgen::InsensitiveStr::Ascii("osipher"),
        dictgen::InsensitiveStr::Ascii("osiphers"),
        dictgen::InsensitiveStr::Ascii("osiphical"),
        dictgen::InsensitiveStr::Ascii("osiphies"),
        dictgen::InsensitiveStr::Ascii("osiphy"),
        dictgen::InsensitiveStr::Ascii("osohpers"),
        dictgen::InsensitiveStr::Ascii("osohpical"),
        dictgen::InsensitiveStr::Ascii("osohpically"),
        dictgen::InsensitiveStr::Ascii("osohpies"),
        dictgen::InsensitiveStr::Ascii("osohpy"),
        dictgen::InsensitiveStr::Ascii("osoper"),
        dictgen::InsensitiveStr::Ascii("osopers"),
        dictgen::InsensitiveStr::Ascii("osophae"),
        dictgen::InsensitiveStr::Ascii("osophia"),
        dictgen::InsensitiveStr::Ascii("osophiae"),
        dictgen::InsensitiveStr::Ascii("osophicaly"),
        dictgen::InsensitiveStr::Ascii("osophics"),
        dictgen::InsensitiveStr::Ascii("osophios"),
        dictgen::InsensitiveStr::Ascii("osophycal"),
        dictgen::InsensitiveStr::Ascii("osophycally"),
        dictgen::InsensitiveStr::Ascii("osopies"),
        dictgen::InsensitiveStr::Ascii("osopy"),
        dictgen::InsensitiveStr::Ascii("ospher"),
        dictgen::InsensitiveStr::Ascii("osphies"),
        dictgen::InsensitiveStr::Ascii("osphy"),
        dictgen::InsensitiveStr::Ascii("ospoher"),
        dictgen::InsensitiveStr::Ascii("ospohers"),
        dictgen::InsensitiveStr::Ascii("ospohical"),
        dictgen::InsensitiveStr::Ascii("ospohies"),
        dictgen::InsensitiveStr::Ascii("ospohy"),
    ],
    values: &[
        &["philadelphia"],
        &["philadelphia"],
        &["philadelphia"],
        &["philadelphia"],
        &["philadelphia"],
        &["philadelphia"],
        &["philadelphia"],
        &["philadelphia"],
        &["philadelphia"],
        &["philippines"],
        &["philippines"],
        &["philippines"],
        &["philippines"],
        &["philippines"],
        &["philippines"],
        &["philippines"],
        &["philippines"],
        &["philippines"],
        &["philippines"],
        &["philosopher"],
        &["philosophers"],
        &["philosophical"],
        &["philosophies"],
        &["philosophy"],
        &["philippine"],
        &["philippines"],
        &["philippines"],
        &["phillies"],
        &["phillies"],
        &["philosophically"],
        &["philosophically"],
        &["philosopher"],
        &["philosophers"],
        &["philosophical"],
        &["philosophies"],
        &["philosophy"],
        &["philosopher"],
        &["philosophical"],
        &["philosophically"],
        &["philosophies"],
        &["philosophy"],
        &["philosopher"],
        &["philosophers"],
        &["philosopher"],
        &["philosophical"],
        &["philosophies"],
        &["philosophically"],
        &["philosophies"],
        &["philosophies"],
        &["philosophically"],
        &["philosophically"],
        &["philosophies"],
        &["philosophy"],
        &["philosopher"],
        &["philosophies"],
        &["philosophy"],
        &["philosopher"],
        &["philosophers"],
        &["philosophical"],
        &["philosophies"],
        &["philosophy"],
    ],
    range: 5..=12,
};

static WORD_PHIA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PHIA_CHILDREN),
    value: None,
};

pub static WORD_PHIA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ldelphia")],
    values: &[&["philadelphia"]],
    range: 8..=8,
};

static WORD_PHE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PHE_CHILDREN),
    value: None,
};

pub static WORD_PHE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("monena"),
        dictgen::InsensitiveStr::Ascii("monenon"),
        dictgen::InsensitiveStr::Ascii("nemenon"),
        dictgen::InsensitiveStr::Ascii("nemona"),
        dictgen::InsensitiveStr::Ascii("nemonal"),
        dictgen::InsensitiveStr::Ascii("nomanal"),
        dictgen::InsensitiveStr::Ascii("nomanon"),
        dictgen::InsensitiveStr::Ascii("nomemon"),
        dictgen::InsensitiveStr::Ascii("nomenen"),
        dictgen::InsensitiveStr::Ascii("nomenol"),
        dictgen::InsensitiveStr::Ascii("nomenom"),
        dictgen::InsensitiveStr::Ascii("nomenona"),
        dictgen::InsensitiveStr::Ascii("nomenonal"),
        dictgen::InsensitiveStr::Ascii("nomenonly"),
        dictgen::InsensitiveStr::Ascii("nominon"),
        dictgen::InsensitiveStr::Ascii("nomon"),
        dictgen::InsensitiveStr::Ascii("nomonal"),
        dictgen::InsensitiveStr::Ascii("nomonen"),
        dictgen::InsensitiveStr::Ascii("nomonenon"),
        dictgen::InsensitiveStr::Ascii("nomonon"),
        dictgen::InsensitiveStr::Ascii("nonema"),
        dictgen::InsensitiveStr::Ascii("nonemal"),
        dictgen::InsensitiveStr::Ascii("nonemon"),
        dictgen::InsensitiveStr::Ascii("nonmena"),
        dictgen::InsensitiveStr::Ascii("riparials"),
    ],
    values: &[
        &["phenomena"],
        &["phenomenon"],
        &["phenomenon"],
        &["phenomena"],
        &["phenomenal"],
        &["phenomenal"],
        &["phenomenon"],
        &["phenomenon"],
        &["phenomenon"],
        &["phenomenal"],
        &["phenomenon"],
        &["phenomena"],
        &["phenomenal"],
        &["phenomenally"],
        &["phenomenon"],
        &["phenomenon"],
        &["phenomenal"],
        &["phenomenon"],
        &["phenomenon"],
        &["phenomenon"],
        &["phenomena"],
        &["phenomenal"],
        &["phenomenon"],
        &["phenomena"],
        &["peripherals"],
    ],
    range: 5..=9,
};

static WORD_PHA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PHA_CHILDREN),
    value: None,
};

pub static WORD_PHA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("nthom"),
        dictgen::InsensitiveStr::Ascii("ntoom"),
        dictgen::InsensitiveStr::Ascii("ramceutical"),
        dictgen::InsensitiveStr::Ascii("ramceuticals"),
        dictgen::InsensitiveStr::Ascii("ramcist"),
        dictgen::InsensitiveStr::Ascii("ramcists"),
        dictgen::InsensitiveStr::Ascii("ramcy"),
        dictgen::InsensitiveStr::Ascii("rmaceudical"),
        dictgen::InsensitiveStr::Ascii("rmaceutial"),
        dictgen::InsensitiveStr::Ascii("rmacias"),
        dictgen::InsensitiveStr::Ascii("rmacs"),
        dictgen::InsensitiveStr::Ascii("rmacuetical"),
        dictgen::InsensitiveStr::Ascii("rmacueticals"),
        dictgen::InsensitiveStr::Ascii("rmacyst"),
        dictgen::InsensitiveStr::Ascii("rmaseudical"),
        dictgen::InsensitiveStr::Ascii("rmaseudically"),
        dictgen::InsensitiveStr::Ascii("rmaseudicals"),
        dictgen::InsensitiveStr::Ascii("rmaseudicaly"),
        dictgen::InsensitiveStr::Ascii("rmaseutical"),
        dictgen::InsensitiveStr::Ascii("rmaseutically"),
        dictgen::InsensitiveStr::Ascii("rmaseuticals"),
        dictgen::InsensitiveStr::Ascii("rmaseuticaly"),
        dictgen::InsensitiveStr::Ascii("rmasist"),
        dictgen::InsensitiveStr::Ascii("rmasists"),
        dictgen::InsensitiveStr::Ascii("rmasudical"),
        dictgen::InsensitiveStr::Ascii("rmasudically"),
        dictgen::InsensitiveStr::Ascii("rmasudicals"),
        dictgen::InsensitiveStr::Ascii("rmasudicaly"),
        dictgen::InsensitiveStr::Ascii("rmasutical"),
        dictgen::InsensitiveStr::Ascii("rmasutically"),
        dictgen::InsensitiveStr::Ascii("rmasuticals"),
        dictgen::InsensitiveStr::Ascii("rmasuticaly"),
        dictgen::InsensitiveStr::Ascii("rmeceutical"),
        dictgen::InsensitiveStr::Ascii("rmicist"),
        dictgen::InsensitiveStr::Ascii("rmsci"),
        dictgen::InsensitiveStr::Ascii("roah"),
        dictgen::InsensitiveStr::Ascii("roh"),
        dictgen::InsensitiveStr::Ascii("rse"),
        dictgen::InsensitiveStr::Ascii("sepsace"),
        dictgen::InsensitiveStr::Ascii("sis"),
        dictgen::InsensitiveStr::Ascii("tnom"),
    ],
    values: &[
        &["phantom"],
        &["phantom"],
        &["pharmaceutical"],
        &["pharmaceutical"],
        &["pharmacist"],
        &["pharmacist"],
        &["pharmacy"],
        &["pharmaceutical"],
        &["pharmaceutical"],
        &["pharmacist"],
        &["pharmacist"],
        &["pharmaceutical"],
        &["pharmaceutical"],
        &["pharmacist"],
        &["pharmaceutical"],
        &["pharmaceutical"],
        &["pharmaceuticals"],
        &["pharmaceutical"],
        &["pharmaceutical"],
        &["pharmaceutical"],
        &["pharmaceuticals"],
        &["pharmaceutical"],
        &["pharmacist"],
        &["pharmacists"],
        &["pharmaceutical"],
        &["pharmaceutical"],
        &["pharmaceuticals"],
        &["pharmaceutical"],
        &["pharmaceutical"],
        &["pharmaceutical"],
        &["pharmaceuticals"],
        &["pharmaceutical"],
        &["pharmaceutical"],
        &["pharmacist"],
        &["pharmacist"],
        &["pharaoh"],
        &["pharaoh"],
        &["phrase"],
        &["phasespace"],
        &["phases"],
        &["phantom"],
    ],
    range: 3..=13,
};

static WORD_PE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_PE_CHILDREN),
    value: None,
};

static WORD_PE_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_PEA_NODE),
    Some(&WORD_PEB_NODE),
    Some(&WORD_PEC_NODE),
    Some(&WORD_PED_NODE),
    Some(&WORD_PEE_NODE),
    Some(&WORD_PEF_NODE),
    Some(&WORD_PEG_NODE),
    Some(&WORD_PEH_NODE),
    Some(&WORD_PEI_NODE),
    None,
    None,
    Some(&WORD_PEL_NODE),
    None,
    Some(&WORD_PEN_NODE),
    Some(&WORD_PEO_NODE),
    Some(&WORD_PEP_NODE),
    None,
    Some(&WORD_PER_NODE),
    Some(&WORD_PES_NODE),
    Some(&WORD_PET_NODE),
    None,
    Some(&WORD_PEV_NODE),
    Some(&WORD_PEW_NODE),
    None,
    None,
    Some(&WORD_PEZ_NODE),
];

static WORD_PEZ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PEZ_CHILDREN),
    value: None,
};

pub static WORD_PEZ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ier")],
    values: &[&["bezier"]],
    range: 3..=3,
};

static WORD_PEW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PEW_CHILDREN),
    value: None,
};

pub static WORD_PEW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("der")],
    values: &[&["lewder", "pewter", "powder"]],
    range: 3..=3,
};

static WORD_PEV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PEV_CHILDREN),
    value: None,
};

pub static WORD_PEV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ent"),
        dictgen::InsensitiveStr::Ascii("ents"),
    ],
    values: &[&["prevent"], &["prevents"]],
    range: 3..=4,
};

static WORD_PET_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PET_CHILDREN),
    value: None,
};

pub static WORD_PET_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("etion"),
        dictgen::InsensitiveStr::Ascii("rolem"),
        dictgen::InsensitiveStr::Ascii("roluem"),
    ],
    values: &[&["petition"], &["petroleum"], &["petroleum"]],
    range: 5..=6,
};

static WORD_PES_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PES_CHILDREN),
    value: None,
};

pub static WORD_PES_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("itcides"),
        dictgen::InsensitiveStr::Ascii("siary"),
        dictgen::InsensitiveStr::Ascii("simestic"),
        dictgen::InsensitiveStr::Ascii("simisitic"),
        dictgen::InsensitiveStr::Ascii("simisstic"),
        dictgen::InsensitiveStr::Ascii("simistc"),
        dictgen::InsensitiveStr::Ascii("simistisch"),
        dictgen::InsensitiveStr::Ascii("simitic"),
        dictgen::InsensitiveStr::Ascii("tacides"),
        dictgen::InsensitiveStr::Ascii("tecides"),
        dictgen::InsensitiveStr::Ascii("ticedes"),
        dictgen::InsensitiveStr::Ascii("ticidas"),
        dictgen::InsensitiveStr::Ascii("ticids"),
        dictgen::InsensitiveStr::Ascii("tisides"),
        dictgen::InsensitiveStr::Ascii("tizides"),
        dictgen::InsensitiveStr::Ascii("tore"),
    ],
    values: &[
        &["pesticides"],
        &["pessary"],
        &["pessimistic"],
        &["pessimistic"],
        &["pessimistic"],
        &["pessimistic"],
        &["pessimistic"],
        &["pessimistic"],
        &["pesticides"],
        &["pesticides"],
        &["pesticides"],
        &["pesticides"],
        &["pesticides"],
        &["pesticides"],
        &["pesticides"],
        &["petstore"],
    ],
    range: 4..=10,
};

static WORD_PER_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_PER_CHILDREN),
    value: None,
};

static WORD_PER_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_PERA_NODE),
    None,
    Some(&WORD_PERC_NODE),
    Some(&WORD_PERD_NODE),
    Some(&WORD_PERE_NODE),
    Some(&WORD_PERF_NODE),
    None,
    Some(&WORD_PERH_NODE),
    Some(&WORD_PERI_NODE),
    Some(&WORD_PERJ_NODE),
    None,
    Some(&WORD_PERL_NODE),
    Some(&WORD_PERM_NODE),
    Some(&WORD_PERN_NODE),
    Some(&WORD_PERO_NODE),
    Some(&WORD_PERP_NODE),
    None,
    Some(&WORD_PERR_NODE),
    Some(&WORD_PERS_NODE),
    Some(&WORD_PERT_NODE),
    Some(&WORD_PERU_NODE),
    Some(&WORD_PERV_NODE),
    None,
    Some(&WORD_PERX_NODE),
    None,
    None,
];

static WORD_PERX_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PERX_CHILDREN),
    value: None,
};

pub static WORD_PERX_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("oide")],
    values: &[&["peroxide"]],
    range: 4..=4,
};

static WORD_PERV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PERV_CHILDREN),
    value: None,
};

pub static WORD_PERV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ail"),
        dictgen::InsensitiveStr::Ascii("ailing"),
        dictgen::InsensitiveStr::Ascii("alence"),
        dictgen::InsensitiveStr::Ascii("ention"),
        dictgen::InsensitiveStr::Ascii("ents"),
        dictgen::InsensitiveStr::Ascii("ersley"),
        dictgen::InsensitiveStr::Ascii("erst"),
        dictgen::InsensitiveStr::Ascii("ertes"),
        dictgen::InsensitiveStr::Ascii("iew"),
        dictgen::InsensitiveStr::Ascii("iews"),
    ],
    values: &[
        &["prevail"],
        &["prevailing"],
        &["prevalence"],
        &["prevention"],
        &["prevents"],
        &["perverse"],
        &["pervert"],
        &["perverse"],
        &["preview", "purview"],
        &["previews", "purviews"],
    ],
    range: 3..=6,
};

static WORD_PERU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PERU_CHILDREN),
    value: None,
};

pub static WORD_PERU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("saded")],
    values: &[&["persuaded"]],
    range: 5..=5,
};

static WORD_PERT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PERT_CHILDREN),
    value: None,
};

pub static WORD_PERT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aing"),
        dictgen::InsensitiveStr::Ascii("ended"),
        dictgen::InsensitiveStr::Ascii("ians"),
        dictgen::InsensitiveStr::Ascii("icipate"),
        dictgen::InsensitiveStr::Ascii("icipated"),
        dictgen::InsensitiveStr::Ascii("icipates"),
        dictgen::InsensitiveStr::Ascii("icipating"),
        dictgen::InsensitiveStr::Ascii("icipation"),
        dictgen::InsensitiveStr::Ascii("icular"),
        dictgen::InsensitiveStr::Ascii("icularly"),
        dictgen::InsensitiveStr::Ascii("iculars"),
        dictgen::InsensitiveStr::Ascii("inante"),
        dictgen::InsensitiveStr::Ascii("inate"),
        dictgen::InsensitiveStr::Ascii("inately"),
        dictgen::InsensitiveStr::Ascii("inet"),
        dictgen::InsensitiveStr::Ascii("oleum"),
        dictgen::InsensitiveStr::Ascii("rub"),
        dictgen::InsensitiveStr::Ascii("rubation"),
        dictgen::InsensitiveStr::Ascii("rubations"),
        dictgen::InsensitiveStr::Ascii("rubing"),
        dictgen::InsensitiveStr::Ascii("ub"),
        dictgen::InsensitiveStr::Ascii("ubate"),
        dictgen::InsensitiveStr::Ascii("ubated"),
        dictgen::InsensitiveStr::Ascii("ubates"),
        dictgen::InsensitiveStr::Ascii("ubation"),
        dictgen::InsensitiveStr::Ascii("ubations"),
        dictgen::InsensitiveStr::Ascii("ubing"),
        dictgen::InsensitiveStr::Ascii("urbate"),
        dictgen::InsensitiveStr::Ascii("urbates"),
        dictgen::InsensitiveStr::Ascii("urbe"),
    ],
    values: &[
        &["pertaining"],
        &["pretended"],
        &["pertains"],
        &["participate"],
        &["participated"],
        &["participates"],
        &["participating"],
        &["participation"],
        &["particular"],
        &["particularly"],
        &["particulars"],
        &["pertinent"],
        &["pertinent"],
        &["pertinently"],
        &["pertinent"],
        &["petroleum"],
        &["perturb"],
        &["perturbation"],
        &["perturbations"],
        &["perturbing"],
        &["perturb"],
        &["perturb"],
        &["perturbed"],
        &["perturbs"],
        &["perturbation"],
        &["perturbations"],
        &["perturbing"],
        &["perturb"],
        &["perturbs"],
        &["perturb", "perturbed"],
    ],
    range: 2..=9,
};

static WORD_PERS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_PERS_CHILDREN),
    value: None,
};

static WORD_PERS_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_PERSA_NODE),
    None,
    Some(&WORD_PERSC_NODE),
    None,
    Some(&WORD_PERSE_NODE),
    None,
    None,
    Some(&WORD_PERSH_NODE),
    Some(&WORD_PERSI_NODE),
    None,
    None,
    None,
    Some(&WORD_PERSM_NODE),
    None,
    Some(&WORD_PERSO_NODE),
    Some(&WORD_PERSP_NODE),
    None,
    None,
    Some(&WORD_PERSS_NODE),
    Some(&WORD_PERST_NODE),
    Some(&WORD_PERSU_NODE),
    Some(&WORD_PERSV_NODE),
    Some(&WORD_PERSW_NODE),
    None,
    None,
    None,
];

static WORD_PERSW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PERSW_CHILDREN),
    value: None,
};

pub static WORD_PERSW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("asion")],
    values: &[&["persuasion"]],
    range: 5..=5,
};

static WORD_PERSV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PERSV_CHILDREN),
    value: None,
};

pub static WORD_PERSV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("asive")],
    values: &[&["persuasive"]],
    range: 5..=5,
};

static WORD_PERSU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PERSU_CHILDREN),
    value: None,
};

pub static WORD_PERSU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("asian"),
        dictgen::InsensitiveStr::Ascii("asing"),
        dictgen::InsensitiveStr::Ascii("asivo"),
        dictgen::InsensitiveStr::Ascii("aso"),
        dictgen::InsensitiveStr::Ascii("assion"),
        dictgen::InsensitiveStr::Ascii("assive"),
        dictgen::InsensitiveStr::Ascii("ated"),
        dictgen::InsensitiveStr::Ascii("ation"),
        dictgen::InsensitiveStr::Ascii("cuted"),
        dictgen::InsensitiveStr::Ascii("cution"),
        dictgen::InsensitiveStr::Ascii("ded"),
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("it"),
        dictgen::InsensitiveStr::Ascii("its"),
        dictgen::InsensitiveStr::Ascii("mably"),
        dictgen::InsensitiveStr::Ascii("med"),
        dictgen::InsensitiveStr::Ascii("mption"),
        dictgen::InsensitiveStr::Ascii("mptuous"),
        dictgen::InsensitiveStr::Ascii("ssion"),
    ],
    values: &[
        &["persuasion"],
        &["persuasion"],
        &["persuasion"],
        &["persuasion"],
        &["persuasion"],
        &["persuasive"],
        &["persuade"],
        &["persuasion"],
        &["persecuted"],
        &["persecution"],
        &["persuaded"],
        &["pursue"],
        &["pursued"],
        &["pursuing"],
        &["pursuit"],
        &["pursuits"],
        &["presumably"],
        &["presumed"],
        &["presumption"],
        &["presumptuous"],
        &["persuasion"],
    ],
    range: 1..=7,
};

static WORD_PERST_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PERST_CHILDREN),
    value: None,
};

pub static WORD_PERST_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ige")],
    values: &[&["prestige"]],
    range: 3..=3,
};

static WORD_PERSS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PERSS_CHILDREN),
    value: None,
};

pub static WORD_PERSS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ious"),
        dictgen::InsensitiveStr::Ascii("iously"),
        dictgen::InsensitiveStr::Ascii("iuos"),
        dictgen::InsensitiveStr::Ascii("iuosly"),
    ],
    values: &[
        &["precious"],
        &["preciously"],
        &["precious"],
        &["preciously"],
    ],
    range: 4..=6,
};

static WORD_PERSP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PERSP_CHILDREN),
    value: None,
};

pub static WORD_PERSP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ecitve"),
        dictgen::InsensitiveStr::Ascii("ecitves"),
        dictgen::InsensitiveStr::Ascii("ecive"),
        dictgen::InsensitiveStr::Ascii("ectie"),
        dictgen::InsensitiveStr::Ascii("ectief"),
        dictgen::InsensitiveStr::Ascii("ectivas"),
        dictgen::InsensitiveStr::Ascii("ektive"),
    ],
    values: &[
        &["perspective"],
        &["perspectives"],
        &["perspective"],
        &["perspectives"],
        &["perspective"],
        &["perspectives"],
        &["perspective"],
    ],
    range: 5..=7,
};

static WORD_PERSO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PERSO_CHILDREN),
    value: None,
};

pub static WORD_PERSO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("anlly"),
        dictgen::InsensitiveStr::Ascii("cuted"),
        dictgen::InsensitiveStr::Ascii("naes"),
        dictgen::InsensitiveStr::Ascii("nalie"),
        dictgen::InsensitiveStr::Ascii("nalis"),
        dictgen::InsensitiveStr::Ascii("nalites"),
        dictgen::InsensitiveStr::Ascii("nalitie"),
        dictgen::InsensitiveStr::Ascii("nalitites"),
        dictgen::InsensitiveStr::Ascii("nalitits"),
        dictgen::InsensitiveStr::Ascii("nalitity"),
        dictgen::InsensitiveStr::Ascii("nalitys"),
        dictgen::InsensitiveStr::Ascii("nallity"),
        dictgen::InsensitiveStr::Ascii("naly"),
        dictgen::InsensitiveStr::Ascii("narse"),
        dictgen::InsensitiveStr::Ascii("natus"),
        dictgen::InsensitiveStr::Ascii("nel"),
        dictgen::InsensitiveStr::Ascii("nell"),
        dictgen::InsensitiveStr::Ascii("nes"),
        dictgen::InsensitiveStr::Ascii("nhod"),
        dictgen::InsensitiveStr::Ascii("nhoood"),
        dictgen::InsensitiveStr::Ascii("nilized"),
        dictgen::InsensitiveStr::Ascii("nis"),
        dictgen::InsensitiveStr::Ascii("nnal"),
        dictgen::InsensitiveStr::Ascii("nnaly"),
        dictgen::InsensitiveStr::Ascii("nnell"),
        dictgen::InsensitiveStr::Ascii("nsa"),
    ],
    values: &[
        &["personally"],
        &["persecuted"],
        &["personas"],
        &["personalized"],
        &["personas"],
        &["personalities"],
        &["personality"],
        &["personalities"],
        &["personalities"],
        &["personality"],
        &["personalities"],
        &["personally"],
        &["personally"],
        &["personas"],
        &["personas"],
        &["personnel", "personal"],
        &["personnel"],
        &["persons"],
        &["personhood"],
        &["personhood"],
        &["personalized"],
        &["persons"],
        &["personal"],
        &["personally"],
        &["personnel"],
        &["personas"],
    ],
    range: 3..=9,
};

static WORD_PERSM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PERSM_CHILDREN),
    value: None,
};

pub static WORD_PERSM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("issions")],
    values: &[&["permissions"]],
    range: 7..=7,
};

static WORD_PERSI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PERSI_CHILDREN),
    value: None,
};

pub static WORD_PERSI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cuted"),
        dictgen::InsensitiveStr::Ascii("cution"),
        dictgen::InsensitiveStr::Ascii("sit"),
        dictgen::InsensitiveStr::Ascii("sited"),
        dictgen::InsensitiveStr::Ascii("stance"),
        dictgen::InsensitiveStr::Ascii("stant"),
        dictgen::InsensitiveStr::Ascii("stante"),
        dictgen::InsensitiveStr::Ascii("stantly"),
        dictgen::InsensitiveStr::Ascii("sten"),
        dictgen::InsensitiveStr::Ascii("stens"),
        dictgen::InsensitiveStr::Ascii("stense"),
        dictgen::InsensitiveStr::Ascii("stente"),
        dictgen::InsensitiveStr::Ascii("stented"),
        dictgen::InsensitiveStr::Ascii("stes"),
        dictgen::InsensitiveStr::Ascii("ted"),
        dictgen::InsensitiveStr::Ascii("tent"),
        dictgen::InsensitiveStr::Ascii("tentely"),
        dictgen::InsensitiveStr::Ascii("tently"),
        dictgen::InsensitiveStr::Ascii("ts"),
    ],
    values: &[
        &["persecuted"],
        &["persecution"],
        &["persist"],
        &["persisted"],
        &["persistence"],
        &["persistent"],
        &["persistent"],
        &["persistently"],
        &["persistent"],
        &["persists"],
        &["persistence"],
        &["persistence"],
        &["persisted"],
        &["persists"],
        &["persisted"],
        &["persistent"],
        &["persistently"],
        &["persistently"],
        &["persist"],
    ],
    range: 2..=7,
};

static WORD_PERSH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PERSH_CHILDREN),
    value: None,
};

pub static WORD_PERSH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("is"),
        dictgen::InsensitiveStr::Ascii("isly"),
        dictgen::InsensitiveStr::Ascii("us"),
        dictgen::InsensitiveStr::Ascii("usly"),
    ],
    values: &[
        &["precious"],
        &["preciously"],
        &["precious"],
        &["preciously"],
    ],
    range: 2..=4,
};

static WORD_PERSE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PERSE_CHILDREN),
    value: None,
};

pub static WORD_PERSE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ctive"),
        dictgen::InsensitiveStr::Ascii("ctives"),
        dictgen::InsensitiveStr::Ascii("ctued"),
        dictgen::InsensitiveStr::Ascii("ctuion"),
        dictgen::InsensitiveStr::Ascii("cucion"),
        dictgen::InsensitiveStr::Ascii("cusion"),
        dictgen::InsensitiveStr::Ascii("cutie"),
        dictgen::InsensitiveStr::Ascii("cutin"),
        dictgen::InsensitiveStr::Ascii("cutted"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("eded"),
        dictgen::InsensitiveStr::Ascii("edes"),
        dictgen::InsensitiveStr::Ascii("eding"),
        dictgen::InsensitiveStr::Ascii("eds"),
        dictgen::InsensitiveStr::Ascii("pctive"),
        dictgen::InsensitiveStr::Ascii("pctives"),
        dictgen::InsensitiveStr::Ascii("pective"),
        dictgen::InsensitiveStr::Ascii("pectives"),
        dictgen::InsensitiveStr::Ascii("rvation"),
        dictgen::InsensitiveStr::Ascii("rve"),
        dictgen::InsensitiveStr::Ascii("rved"),
        dictgen::InsensitiveStr::Ascii("rverance"),
        dictgen::InsensitiveStr::Ascii("rvere"),
        dictgen::InsensitiveStr::Ascii("rvered"),
        dictgen::InsensitiveStr::Ascii("rveres"),
        dictgen::InsensitiveStr::Ascii("rvering"),
        dictgen::InsensitiveStr::Ascii("rves"),
        dictgen::InsensitiveStr::Ascii("rving"),
        dictgen::InsensitiveStr::Ascii("ts"),
        dictgen::InsensitiveStr::Ascii("verence"),
        dictgen::InsensitiveStr::Ascii("w"),
        dictgen::InsensitiveStr::Ascii("wed"),
        dictgen::InsensitiveStr::Ascii("wer"),
        dictgen::InsensitiveStr::Ascii("wes"),
        dictgen::InsensitiveStr::Ascii("wing"),
        dictgen::InsensitiveStr::Ascii("ws"),
    ],
    values: &[
        &["respective", "perspective"],
        &["perspectives"],
        &["persecuted"],
        &["persecution"],
        &["persecution"],
        &["persecution"],
        &["persecuted"],
        &["persecution"],
        &["persecuted"],
        &["precede"],
        &["preceded"],
        &["precedes"],
        &["preceding"],
        &["precedes"],
        &["perspective"],
        &["perspectives"],
        &["perspective"],
        &["perspectives"],
        &["preservation"],
        &["preserve"],
        &["preserved"],
        &["perseverance"],
        &["persevere"],
        &["persevered"],
        &["perseveres"],
        &["persevering"],
        &["preserves"],
        &["preserving"],
        &["presets"],
        &["perseverance"],
        &["pursue"],
        &["pursued"],
        &["pursuer"],
        &["pursues"],
        &["pursuing"],
        &["pursues"],
    ],
    range: 1..=8,
};

static WORD_PERSC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PERSC_CHILDREN),
    value: None,
};

pub static WORD_PERSC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eptive"),
        dictgen::InsensitiveStr::Ascii("iuos"),
        dictgen::InsensitiveStr::Ascii("iuosly"),
        dictgen::InsensitiveStr::Ascii("ius"),
        dictgen::InsensitiveStr::Ascii("iusly"),
        dictgen::InsensitiveStr::Ascii("ribe"),
    ],
    values: &[
        &["perspectives"],
        &["precious"],
        &["preciously"],
        &["precious"],
        &["preciously"],
        &["prescribe"],
    ],
    range: 3..=6,
};

static WORD_PERSA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PERSA_CHILDREN),
    value: None,
};

pub static WORD_PERSA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("in"),
        dictgen::InsensitiveStr::Ascii("n"),
        dictgen::InsensitiveStr::Ascii("ude"),
        dictgen::InsensitiveStr::Ascii("uded"),
        dictgen::InsensitiveStr::Ascii("usion"),
        dictgen::InsensitiveStr::Ascii("usive"),
    ],
    values: &[
        &["persian"],
        &["person"],
        &["persuade"],
        &["persuaded"],
        &["persuasion"],
        &["persuasive"],
    ],
    range: 1..=5,
};

static WORD_PERR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PERR_CHILDREN),
    value: None,
};

pub static WORD_PERR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ogative"),
        dictgen::InsensitiveStr::Ascii("ror"),
    ],
    values: &[&["prerogative"], &["perror"]],
    range: 3..=7,
};

static WORD_PERP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PERP_CHILDREN),
    value: None,
};

pub static WORD_PERP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aid"),
        dictgen::InsensitiveStr::Ascii("andicular"),
        dictgen::InsensitiveStr::Ascii("andicularly"),
        dictgen::InsensitiveStr::Ascii("aration"),
        dictgen::InsensitiveStr::Ascii("atrated"),
        dictgen::InsensitiveStr::Ascii("atrator"),
        dictgen::InsensitiveStr::Ascii("atrators"),
        dictgen::InsensitiveStr::Ascii("atuate"),
        dictgen::InsensitiveStr::Ascii("atuated"),
        dictgen::InsensitiveStr::Ascii("atuates"),
        dictgen::InsensitiveStr::Ascii("atuating"),
        dictgen::InsensitiveStr::Ascii("endicualr"),
        dictgen::InsensitiveStr::Ascii("endiculaire"),
        dictgen::InsensitiveStr::Ascii("endiculaires"),
        dictgen::InsensitiveStr::Ascii("enticular"),
        dictgen::InsensitiveStr::Ascii("ertated"),
        dictgen::InsensitiveStr::Ascii("ertator"),
        dictgen::InsensitiveStr::Ascii("ertators"),
        dictgen::InsensitiveStr::Ascii("erties"),
        dictgen::InsensitiveStr::Ascii("ertrated"),
        dictgen::InsensitiveStr::Ascii("erty"),
        dictgen::InsensitiveStr::Ascii("etraded"),
        dictgen::InsensitiveStr::Ascii("etrador"),
        dictgen::InsensitiveStr::Ascii("etraitor"),
        dictgen::InsensitiveStr::Ascii("etrar"),
        dictgen::InsensitiveStr::Ascii("etraron"),
        dictgen::InsensitiveStr::Ascii("etrater"),
        dictgen::InsensitiveStr::Ascii("etraters"),
        dictgen::InsensitiveStr::Ascii("etuaded"),
        dictgen::InsensitiveStr::Ascii("etuae"),
        dictgen::InsensitiveStr::Ascii("etualy"),
        dictgen::InsensitiveStr::Ascii("etuare"),
        dictgen::InsensitiveStr::Ascii("etuas"),
        dictgen::InsensitiveStr::Ascii("etuaters"),
        dictgen::InsensitiveStr::Ascii("etuationg"),
        dictgen::InsensitiveStr::Ascii("etue"),
        dictgen::InsensitiveStr::Ascii("etutate"),
        dictgen::InsensitiveStr::Ascii("etuties"),
        dictgen::InsensitiveStr::Ascii("has"),
        dictgen::InsensitiveStr::Ascii("indicular"),
        dictgen::InsensitiveStr::Ascii("itrated"),
        dictgen::InsensitiveStr::Ascii("itrator"),
        dictgen::InsensitiveStr::Ascii("itrators"),
        dictgen::InsensitiveStr::Ascii("osefully"),
        dictgen::InsensitiveStr::Ascii("osterous"),
        dictgen::InsensitiveStr::Ascii("retated"),
        dictgen::InsensitiveStr::Ascii("retator"),
        dictgen::InsensitiveStr::Ascii("retators"),
        dictgen::InsensitiveStr::Ascii("sective"),
        dictgen::InsensitiveStr::Ascii("sectives"),
        dictgen::InsensitiveStr::Ascii("utrator"),
        dictgen::InsensitiveStr::Ascii("utrators"),
        dictgen::InsensitiveStr::Ascii("utually"),
        dictgen::InsensitiveStr::Ascii("utuated"),
        dictgen::InsensitiveStr::Ascii("utuates"),
        dictgen::InsensitiveStr::Ascii("utuating"),
    ],
    values: &[
        &["prepaid"],
        &["perpendicular"],
        &["perpendicularly"],
        &["preparation"],
        &["perpetrated"],
        &["perpetrator"],
        &["perpetrators"],
        &["perpetuate"],
        &["perpetuated"],
        &["perpetuates"],
        &["perpetuating"],
        &["perpendicular"],
        &["perpendicular"],
        &["perpendicular"],
        &["perpendicular"],
        &["perpetuated"],
        &["perpetrators"],
        &["perpetrators"],
        &["properties"],
        &["perpetrated"],
        &["property"],
        &["perpetrated"],
        &["perpetrator"],
        &["perpetrator"],
        &["perpetrator"],
        &["perpetrator"],
        &["perpetrator"],
        &["perpetrators"],
        &["perpetuated"],
        &["perpetuate"],
        &["perpetually"],
        &["perpetuate"],
        &["perpetuates"],
        &["perpetuates"],
        &["perpetuating"],
        &["perpetuate"],
        &["perpetuate"],
        &["perpetuates"],
        &["perhaps"],
        &["perpendicular"],
        &["perpetrated"],
        &["perpetrator"],
        &["perpetrators"],
        &["purposefully"],
        &["preposterous"],
        &["perpetrated"],
        &["perpetrators"],
        &["perpetrators"],
        &["perspective"],
        &["perspectives"],
        &["perpetrator"],
        &["perpetrators"],
        &["perpetually"],
        &["perpetuated"],
        &["perpetuates"],
        &["perpetuating"],
    ],
    range: 3..=12,
};

static WORD_PERO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PERO_CHILDREN),
    value: None,
};

pub static WORD_PERO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("dically"),
        dictgen::InsensitiveStr::Ascii("endicular"),
        dictgen::InsensitiveStr::Ascii("gative"),
        dictgen::InsensitiveStr::Ascii("grative"),
        dictgen::InsensitiveStr::Ascii("id"),
        dictgen::InsensitiveStr::Ascii("idic"),
        dictgen::InsensitiveStr::Ascii("idical"),
        dictgen::InsensitiveStr::Ascii("idically"),
        dictgen::InsensitiveStr::Ascii("idicals"),
        dictgen::InsensitiveStr::Ascii("idicity"),
        dictgen::InsensitiveStr::Ascii("ids"),
        dictgen::InsensitiveStr::Ascii("nal"),
        dictgen::InsensitiveStr::Ascii("perly"),
        dictgen::InsensitiveStr::Ascii("rdered"),
        dictgen::InsensitiveStr::Ascii("rders"),
        dictgen::InsensitiveStr::Ascii("snality"),
        dictgen::InsensitiveStr::Ascii("snas"),
    ],
    values: &[
        &["periodically"],
        &["perpendicular"],
        &["prerogative"],
        &["prerogative"],
        &["period"],
        &["periodic"],
        &["periodical"],
        &["periodically"],
        &["periodicals"],
        &["periodicity"],
        &["periods"],
        &["personal"],
        &["properly"],
        &["preordered"],
        &["preorders"],
        &["personality"],
        &["personas"],
    ],
    range: 2..=9,
};

static WORD_PERN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PERN_CHILDREN),
    value: None,
};

pub static WORD_PERN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ament"),
        dictgen::InsensitiveStr::Ascii("amently"),
    ],
    values: &[&["permanent"], &["permanently"]],
    range: 5..=7,
};

static WORD_PERM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_PERM_CHILDREN),
    value: None,
};

static WORD_PERM_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_PERMA_NODE),
    None,
    None,
    None,
    Some(&WORD_PERME_NODE),
    None,
    None,
    None,
    Some(&WORD_PERMI_NODE),
    None,
    None,
    None,
    Some(&WORD_PERMM_NODE),
    None,
    Some(&WORD_PERMO_NODE),
    None,
    None,
    None,
    Some(&WORD_PERMS_NODE),
    Some(&WORD_PERMT_NODE),
    Some(&WORD_PERMU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_PERMU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PERMU_CHILDREN),
    value: None,
};

pub static WORD_PERMU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("atate"),
        dictgen::InsensitiveStr::Ascii("atated"),
        dictgen::InsensitiveStr::Ascii("atates"),
        dictgen::InsensitiveStr::Ascii("atating"),
        dictgen::InsensitiveStr::Ascii("atation"),
        dictgen::InsensitiveStr::Ascii("atations"),
        dictgen::InsensitiveStr::Ascii("ate"),
        dictgen::InsensitiveStr::Ascii("ated"),
        dictgen::InsensitiveStr::Ascii("ates"),
        dictgen::InsensitiveStr::Ascii("ating"),
        dictgen::InsensitiveStr::Ascii("ation"),
        dictgen::InsensitiveStr::Ascii("ations"),
        dictgen::InsensitiveStr::Ascii("taion"),
        dictgen::InsensitiveStr::Ascii("taions"),
        dictgen::InsensitiveStr::Ascii("tion"),
        dictgen::InsensitiveStr::Ascii("tions"),
    ],
    values: &[
        &["permutate"],
        &["permutated"],
        &["permutates"],
        &["permutating"],
        &["permutation"],
        &["permutations"],
        &["permutate", "permute"],
        &["permutated", "permuted"],
        &["permutates", "permutes"],
        &["permutating", "permuting"],
        &["permutation"],
        &["permutations"],
        &["permutation"],
        &["permutations"],
        &["permutation"],
        &["permutations"],
    ],
    range: 3..=8,
};

static WORD_PERMT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PERMT_CHILDREN),
    value: None,
};

pub static WORD_PERMT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("uation")],
    values: &[&["permutation"]],
    range: 6..=6,
};

static WORD_PERMS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PERMS_CHILDREN),
    value: None,
};

pub static WORD_PERMS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("sion"),
        dictgen::InsensitiveStr::Ascii("sions"),
    ],
    values: &[&["permission"], &["permissions"]],
    range: 4..=5,
};

static WORD_PERMO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PERMO_CHILDREN),
    value: None,
};

pub static WORD_PERMO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("rmance")],
    values: &[&["performance"]],
    range: 6..=6,
};

static WORD_PERMM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PERMM_CHILDREN),
    value: None,
};

pub static WORD_PERMM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ission"),
        dictgen::InsensitiveStr::Ascii("issions"),
    ],
    values: &[&["permission"], &["permissions"]],
    range: 6..=7,
};

static WORD_PERMI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PERMI_CHILDREN),
    value: None,
};

pub static WORD_PERMI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("er"),
        dictgen::InsensitiveStr::Ascii("ere"),
        dictgen::InsensitiveStr::Ascii("eter"),
        dictgen::InsensitiveStr::Ascii("nantly"),
        dictgen::InsensitiveStr::Ascii("nently"),
        dictgen::InsensitiveStr::Ascii("se"),
        dictgen::InsensitiveStr::Ascii("ses"),
        dictgen::InsensitiveStr::Ascii("sion"),
        dictgen::InsensitiveStr::Ascii("sions"),
        dictgen::InsensitiveStr::Ascii("sison"),
        dictgen::InsensitiveStr::Ascii("sisons"),
        dictgen::InsensitiveStr::Ascii("ssble"),
        dictgen::InsensitiveStr::Ascii("ssiable"),
        dictgen::InsensitiveStr::Ascii("ssibe"),
        dictgen::InsensitiveStr::Ascii("ssie"),
        dictgen::InsensitiveStr::Ascii("ssin"),
        dictgen::InsensitiveStr::Ascii("ssino"),
        dictgen::InsensitiveStr::Ascii("ssinos"),
        dictgen::InsensitiveStr::Ascii("ssiosn"),
        dictgen::InsensitiveStr::Ascii("sson"),
        dictgen::InsensitiveStr::Ascii("ssons"),
        dictgen::InsensitiveStr::Ascii("sssion"),
        dictgen::InsensitiveStr::Ascii("sssions"),
        dictgen::InsensitiveStr::Ascii("tas"),
        dictgen::InsensitiveStr::Ascii("ted"),
        dictgen::InsensitiveStr::Ascii("tes"),
        dictgen::InsensitiveStr::Ascii("tion"),
        dictgen::InsensitiveStr::Ascii("tions"),
        dictgen::InsensitiveStr::Ascii("tis"),
        dictgen::InsensitiveStr::Ascii("tts"),
        dictgen::InsensitiveStr::Ascii("um"),
        dictgen::InsensitiveStr::Ascii("ums"),
    ],
    values: &[
        &["premier"],
        &["premiere"],
        &["perimeter"],
        &["permanently"],
        &["permanently"],
        &["premise"],
        &["premises"],
        &["permission"],
        &["permission", "permissions"],
        &["permissions", "permission"],
        &["permissions"],
        &["permissible"],
        &["permissible"],
        &["permissible"],
        &["permissible"],
        &["permissions"],
        &["permission"],
        &["permissions"],
        &["permissions"],
        &["permission"],
        &["permissions"],
        &["permissions", "permission"],
        &["permissions"],
        &["permits"],
        &["permitted"],
        &["permits"],
        &["permission"],
        &["permissions"],
        &["permits"],
        &["permits"],
        &["premium"],
        &["premiums"],
    ],
    range: 2..=7,
};

static WORD_PERME_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PERME_CHILDREN),
    value: None,
};

pub static WORD_PERME_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("nant"),
        dictgen::InsensitiveStr::Ascii("nantly"),
        dictgen::InsensitiveStr::Ascii("nently"),
        dictgen::InsensitiveStr::Ascii("ssioned"),
    ],
    values: &[
        &["permanent"],
        &["permanently"],
        &["permanently"],
        &["permissioned"],
    ],
    range: 4..=7,
};

static WORD_PERMA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PERMA_CHILDREN),
    value: None,
};

pub static WORD_PERMA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ble"),
        dictgen::InsensitiveStr::Ascii("de"),
        dictgen::InsensitiveStr::Ascii("ment"),
        dictgen::InsensitiveStr::Ascii("mently"),
        dictgen::InsensitiveStr::Ascii("nant"),
        dictgen::InsensitiveStr::Ascii("nantely"),
        dictgen::InsensitiveStr::Ascii("nantly"),
        dictgen::InsensitiveStr::Ascii("nentely"),
        dictgen::InsensitiveStr::Ascii("nenty"),
        dictgen::InsensitiveStr::Ascii("net"),
        dictgen::InsensitiveStr::Ascii("netly"),
        dictgen::InsensitiveStr::Ascii("ntly"),
        dictgen::InsensitiveStr::Ascii("ture"),
        dictgen::InsensitiveStr::Ascii("turely"),
    ],
    values: &[
        &["permeable"],
        &["premade"],
        &["permanent"],
        &["permanently"],
        &["permanent"],
        &["permanently"],
        &["permanently"],
        &["permanently"],
        &["permanently"],
        &["permanent"],
        &["permanently"],
        &["permanently"],
        &["premature"],
        &["prematurely"],
    ],
    range: 2..=7,
};

static WORD_PERL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PERL_CHILDREN),
    value: None,
};

pub static WORD_PERL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ciritc"),
        dictgen::InsensitiveStr::Ascii("iferate"),
        dictgen::InsensitiveStr::Ascii("iferated"),
        dictgen::InsensitiveStr::Ascii("iferates"),
        dictgen::InsensitiveStr::Ascii("iferating"),
        dictgen::InsensitiveStr::Ascii("iminary"),
    ],
    values: &[
        &["perlcritic"],
        &["proliferate"],
        &["proliferated"],
        &["proliferates"],
        &["proliferating"],
        &["preliminary"],
    ],
    range: 6..=9,
};

static WORD_PERJ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PERJ_CHILDREN),
    value: None,
};

pub static WORD_PERJ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ery"),
        dictgen::InsensitiveStr::Ascii("orative"),
    ],
    values: &[&["perjury"], &["pejorative"]],
    range: 3..=7,
};

static WORD_PERI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PERI_CHILDREN),
    value: None,
};

pub static WORD_PERI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cing"),
        dictgen::InsensitiveStr::Ascii("cings"),
        dictgen::InsensitiveStr::Ascii("dic"),
        dictgen::InsensitiveStr::Ascii("dical"),
        dictgen::InsensitiveStr::Ascii("dically"),
        dictgen::InsensitiveStr::Ascii("dinkle"),
        dictgen::InsensitiveStr::Ascii("doic"),
        dictgen::InsensitiveStr::Ascii("doically"),
        dictgen::InsensitiveStr::Ascii("hperal"),
        dictgen::InsensitiveStr::Ascii("hperals"),
        dictgen::InsensitiveStr::Ascii("lious"),
        dictgen::InsensitiveStr::Ascii("metr"),
        dictgen::InsensitiveStr::Ascii("metre"),
        dictgen::InsensitiveStr::Ascii("metres"),
        dictgen::InsensitiveStr::Ascii("ode"),
        dictgen::InsensitiveStr::Ascii("odes"),
        dictgen::InsensitiveStr::Ascii("odicaly"),
        dictgen::InsensitiveStr::Ascii("odioc"),
        dictgen::InsensitiveStr::Ascii("odisch"),
        dictgen::InsensitiveStr::Ascii("odos"),
        dictgen::InsensitiveStr::Ascii("pathetic"),
        dictgen::InsensitiveStr::Ascii("peral"),
        dictgen::InsensitiveStr::Ascii("perhal"),
        dictgen::InsensitiveStr::Ascii("perhals"),
        dictgen::InsensitiveStr::Ascii("pheals"),
        dictgen::InsensitiveStr::Ascii("phereal"),
        dictgen::InsensitiveStr::Ascii("phereals"),
        dictgen::InsensitiveStr::Ascii("pheria"),
        dictgen::InsensitiveStr::Ascii("pherial"),
        dictgen::InsensitiveStr::Ascii("pherials"),
        dictgen::InsensitiveStr::Ascii("phiral"),
        dictgen::InsensitiveStr::Ascii("phirals"),
        dictgen::InsensitiveStr::Ascii("phreal"),
        dictgen::InsensitiveStr::Ascii("phreals"),
        dictgen::InsensitiveStr::Ascii("phrial"),
        dictgen::InsensitiveStr::Ascii("phrials"),
        dictgen::InsensitiveStr::Ascii("san"),
        dictgen::InsensitiveStr::Ascii("sist"),
        dictgen::InsensitiveStr::Ascii("sisted"),
        dictgen::InsensitiveStr::Ascii("sistent"),
        dictgen::InsensitiveStr::Ascii("stent"),
        dictgen::InsensitiveStr::Ascii("tinkle"),
        dictgen::InsensitiveStr::Ascii("wankle"),
        dictgen::InsensitiveStr::Ascii("winke"),
        dictgen::InsensitiveStr::Ascii("winkel"),
        dictgen::InsensitiveStr::Ascii("winkie"),
        dictgen::InsensitiveStr::Ascii("winlke"),
    ],
    values: &[
        &["piercing"],
        &["piercings"],
        &["periodic"],
        &["periodical"],
        &["periodically"],
        &["periwinkle"],
        &["periodic"],
        &["periodically"],
        &["peripheral"],
        &["peripherals"],
        &["perilous"],
        &["perimeter"],
        &["perimeter"],
        &["perimeters"],
        &["period"],
        &["periods"],
        &["periodically"],
        &["periodic"],
        &["periodic"],
        &["periods"],
        &["peripatetic"],
        &["peripheral"],
        &["peripheral"],
        &["peripherals"],
        &["peripherals"],
        &["peripheral"],
        &["peripherals"],
        &["peripheral"],
        &["peripheral"],
        &["peripherals"],
        &["peripheral"],
        &["peripherals"],
        &["peripheral"],
        &["peripherals"],
        &["peripheral"],
        &["peripherals"],
        &["persian"],
        &["persist"],
        &["persisted"],
        &["persistent"],
        &["persistent"],
        &["periwinkle"],
        &["periwinkle"],
        &["periwinkle"],
        &["periwinkle"],
        &["periwinkle"],
        &["periwinkle"],
    ],
    range: 3..=8,
};

static WORD_PERH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PERH_CHILDREN),
    value: None,
};

pub static WORD_PERH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("abs"),
        dictgen::InsensitiveStr::Ascii("as"),
        dictgen::InsensitiveStr::Ascii("asp"),
        dictgen::InsensitiveStr::Ascii("eaps"),
        dictgen::InsensitiveStr::Ascii("iperal"),
        dictgen::InsensitiveStr::Ascii("iperals"),
        dictgen::InsensitiveStr::Ascii("pas"),
    ],
    values: &[
        &["perhaps"],
        &["perhaps"],
        &["perhaps"],
        &["perhaps"],
        &["peripheral"],
        &["peripherals"],
        &["perhaps"],
    ],
    range: 2..=7,
};

static WORD_PERF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_PERF_CHILDREN),
    value: None,
};

static WORD_PERF_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    None,
    None,
    Some(&WORD_PERFE_NODE),
    None,
    None,
    None,
    Some(&WORD_PERFI_NODE),
    None,
    None,
    None,
    Some(&WORD_PERFM_NODE),
    None,
    Some(&WORD_PERFO_NODE),
    None,
    None,
    Some(&WORD_PERFR_NODE),
    None,
    None,
    Some(&WORD_PERFU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_PERFU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PERFU_CHILDREN),
    value: None,
};

pub static WORD_PERFU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("r"),
        dictgen::InsensitiveStr::Ascii("rd"),
        dictgen::InsensitiveStr::Ascii("red"),
        dictgen::InsensitiveStr::Ascii("ring"),
        dictgen::InsensitiveStr::Ascii("rrd"),
        dictgen::InsensitiveStr::Ascii("rred"),
        dictgen::InsensitiveStr::Ascii("rring"),
        dictgen::InsensitiveStr::Ascii("rs"),
    ],
    values: &[
        &["prefer"],
        &["preferred"],
        &["preferred"],
        &["preferring"],
        &["preferred"],
        &["preferred"],
        &["preferring"],
        &["prefers"],
    ],
    range: 1..=5,
};

static WORD_PERFR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PERFR_CHILDREN),
    value: None,
};

pub static WORD_PERFR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("o"),
        dictgen::InsensitiveStr::Ascii("om"),
        dictgen::InsensitiveStr::Ascii("omance"),
        dictgen::InsensitiveStr::Ascii("omances"),
        dictgen::InsensitiveStr::Ascii("omed"),
        dictgen::InsensitiveStr::Ascii("omer"),
        dictgen::InsensitiveStr::Ascii("omers"),
        dictgen::InsensitiveStr::Ascii("oming"),
        dictgen::InsensitiveStr::Ascii("oms"),
    ],
    values: &[
        &["perform"],
        &["perform"],
        &["performance"],
        &["performances"],
        &["performed"],
        &["performer"],
        &["performers"],
        &["performing"],
        &["performs"],
    ],
    range: 1..=7,
};

static WORD_PERFO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_PERFO_CHILDREN),
    value: None,
};

static WORD_PERFO_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    None,
    None,
    Some(&WORD_PERFOE_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_PERFOM_NODE),
    None,
    Some(&WORD_PERFOO_NODE),
    None,
    None,
    Some(&WORD_PERFOR_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_PERFOR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PERFOR_CHILDREN),
    value: Some(&["perform"]),
};

pub static WORD_PERFOR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("am"),
        dictgen::InsensitiveStr::Ascii("amed"),
        dictgen::InsensitiveStr::Ascii("aming"),
        dictgen::InsensitiveStr::Ascii("amnce"),
        dictgen::InsensitiveStr::Ascii("amnces"),
        dictgen::InsensitiveStr::Ascii("ams"),
        dictgen::InsensitiveStr::Ascii("d"),
        dictgen::InsensitiveStr::Ascii("emd"),
        dictgen::InsensitiveStr::Ascii("mace"),
        dictgen::InsensitiveStr::Ascii("maces"),
        dictgen::InsensitiveStr::Ascii("macne"),
        dictgen::InsensitiveStr::Ascii("maed"),
        dictgen::InsensitiveStr::Ascii("mamce"),
        dictgen::InsensitiveStr::Ascii("mancepcs"),
        dictgen::InsensitiveStr::Ascii("mancetest"),
        dictgen::InsensitiveStr::Ascii("mancewise"),
        dictgen::InsensitiveStr::Ascii("mane"),
        dictgen::InsensitiveStr::Ascii("manes"),
        dictgen::InsensitiveStr::Ascii("mans"),
        dictgen::InsensitiveStr::Ascii("manse"),
        dictgen::InsensitiveStr::Ascii("mantes"),
        dictgen::InsensitiveStr::Ascii("mas"),
        dictgen::InsensitiveStr::Ascii("me"),
        dictgen::InsensitiveStr::Ascii("mence"),
        dictgen::InsensitiveStr::Ascii("mences"),
        dictgen::InsensitiveStr::Ascii("mens"),
        dictgen::InsensitiveStr::Ascii("mes"),
        dictgen::InsensitiveStr::Ascii("mnace"),
        dictgen::InsensitiveStr::Ascii("mous"),
        dictgen::InsensitiveStr::Ascii("s"),
    ],
    values: &[
        &["perform"],
        &["performed"],
        &["performing"],
        &["performances", "performance"],
        &["performances"],
        &["performs"],
        &["performed"],
        &["performed"],
        &["performance"],
        &["performances"],
        &["performance"],
        &["performed"],
        &["performance"],
        &["performances"],
        &["performances"],
        &["performances"],
        &["performances", "performance"],
        &["performances"],
        &["performances"],
        &["performances"],
        &["performances"],
        &["performs"],
        &["perform", "performed"],
        &["performance"],
        &["performances"],
        &["performers"],
        &["performed", "performs"],
        &["performances", "performance"],
        &["performs"],
        &["performs"],
    ],
    range: 1..=9,
};

static WORD_PERFOO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PERFOO_CHILDREN),
    value: None,
};

pub static WORD_PERFOO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("m")],
    values: &[&["perfume", "perform"]],
    range: 1..=1,
};

static WORD_PERFOM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PERFOM_CHILDREN),
    value: Some(&["perform"]),
};

pub static WORD_PERFOM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("amce"),
        dictgen::InsensitiveStr::Ascii("amces"),
        dictgen::InsensitiveStr::Ascii("ance"),
        dictgen::InsensitiveStr::Ascii("anse"),
        dictgen::InsensitiveStr::Ascii("anses"),
        dictgen::InsensitiveStr::Ascii("ant"),
        dictgen::InsensitiveStr::Ascii("ative"),
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("eamce"),
        dictgen::InsensitiveStr::Ascii("eamces"),
        dictgen::InsensitiveStr::Ascii("eance"),
        dictgen::InsensitiveStr::Ascii("eanse"),
        dictgen::InsensitiveStr::Ascii("eanses"),
        dictgen::InsensitiveStr::Ascii("eant"),
        dictgen::InsensitiveStr::Ascii("eative"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("eed"),
        dictgen::InsensitiveStr::Ascii("eer"),
        dictgen::InsensitiveStr::Ascii("eers"),
        dictgen::InsensitiveStr::Ascii("eing"),
        dictgen::InsensitiveStr::Ascii("enace"),
        dictgen::InsensitiveStr::Ascii("enaces"),
        dictgen::InsensitiveStr::Ascii("er"),
        dictgen::InsensitiveStr::Ascii("ers"),
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("nace"),
        dictgen::InsensitiveStr::Ascii("naces"),
        dictgen::InsensitiveStr::Ascii("r"),
        dictgen::InsensitiveStr::Ascii("ramce"),
        dictgen::InsensitiveStr::Ascii("ramces"),
        dictgen::InsensitiveStr::Ascii("rance"),
        dictgen::InsensitiveStr::Ascii("ranse"),
        dictgen::InsensitiveStr::Ascii("ranses"),
        dictgen::InsensitiveStr::Ascii("rant"),
        dictgen::InsensitiveStr::Ascii("rative"),
        dictgen::InsensitiveStr::Ascii("red"),
        dictgen::InsensitiveStr::Ascii("rer"),
        dictgen::InsensitiveStr::Ascii("rers"),
        dictgen::InsensitiveStr::Ascii("ring"),
        dictgen::InsensitiveStr::Ascii("rnace"),
        dictgen::InsensitiveStr::Ascii("rnaces"),
        dictgen::InsensitiveStr::Ascii("rs"),
        dictgen::InsensitiveStr::Ascii("s"),
    ],
    values: &[
        &["performance"],
        &["performances"],
        &["performance"],
        &["performance"],
        &["performances"],
        &["performant"],
        &["performative"],
        &["perform"],
        &["performance"],
        &["performances"],
        &["performance"],
        &["performance"],
        &["performances"],
        &["performant"],
        &["performative"],
        &["performed"],
        &["performed"],
        &["performer"],
        &["performers"],
        &["performing"],
        &["performance"],
        &["performances"],
        &["performer"],
        &["performers"],
        &["performs"],
        &["performing"],
        &["performance"],
        &["performances"],
        &["perform"],
        &["performance"],
        &["performances"],
        &["performances", "performance"],
        &["performance"],
        &["performances"],
        &["performant"],
        &["performative"],
        &["performed"],
        &["performer"],
        &["performers"],
        &["performing"],
        &["performance"],
        &["performances"],
        &["performs"],
        &["performs"],
    ],
    range: 1..=6,
};

static WORD_PERFOE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PERFOE_CHILDREN),
    value: None,
};

pub static WORD_PERFOE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("m"),
        dictgen::InsensitiveStr::Ascii("mamce"),
        dictgen::InsensitiveStr::Ascii("mamces"),
        dictgen::InsensitiveStr::Ascii("mance"),
        dictgen::InsensitiveStr::Ascii("manse"),
        dictgen::InsensitiveStr::Ascii("manses"),
        dictgen::InsensitiveStr::Ascii("mant"),
        dictgen::InsensitiveStr::Ascii("mative"),
        dictgen::InsensitiveStr::Ascii("med"),
        dictgen::InsensitiveStr::Ascii("mer"),
        dictgen::InsensitiveStr::Ascii("mers"),
        dictgen::InsensitiveStr::Ascii("ming"),
        dictgen::InsensitiveStr::Ascii("mnace"),
        dictgen::InsensitiveStr::Ascii("mnaces"),
        dictgen::InsensitiveStr::Ascii("ms"),
    ],
    values: &[
        &["perform"],
        &["performance"],
        &["performances"],
        &["performance"],
        &["performance"],
        &["performances"],
        &["performant"],
        &["performative"],
        &["performed"],
        &["performer"],
        &["performers"],
        &["performing"],
        &["performance"],
        &["performances"],
        &["performs"],
    ],
    range: 1..=6,
};

static WORD_PERFM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PERFM_CHILDREN),
    value: None,
};

pub static WORD_PERFM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ormance")],
    values: &[&["performance"]],
    range: 7..=7,
};

static WORD_PERFI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PERFI_CHILDREN),
    value: None,
};

pub static WORD_PERFI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("x")],
    values: &[&["prefix"]],
    range: 1..=1,
};

static WORD_PERFE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PERFE_CHILDREN),
    value: None,
};

pub static WORD_PERFE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("c"),
        dictgen::InsensitiveStr::Ascii("ccion"),
        dictgen::InsensitiveStr::Ascii("cct"),
        dictgen::InsensitiveStr::Ascii("cctly"),
        dictgen::InsensitiveStr::Ascii("clty"),
        dictgen::InsensitiveStr::Ascii("cly"),
        dictgen::InsensitiveStr::Ascii("ctably"),
        dictgen::InsensitiveStr::Ascii("cty"),
        dictgen::InsensitiveStr::Ascii("cxion"),
        dictgen::InsensitiveStr::Ascii("ktion"),
        dictgen::InsensitiveStr::Ascii("r"),
        dictgen::InsensitiveStr::Ascii("rable"),
        dictgen::InsensitiveStr::Ascii("rably"),
        dictgen::InsensitiveStr::Ascii("rance"),
        dictgen::InsensitiveStr::Ascii("rances"),
        dictgen::InsensitiveStr::Ascii("rct"),
        dictgen::InsensitiveStr::Ascii("rctly"),
        dictgen::InsensitiveStr::Ascii("rect"),
        dictgen::InsensitiveStr::Ascii("rectly"),
        dictgen::InsensitiveStr::Ascii("red"),
        dictgen::InsensitiveStr::Ascii("rence"),
        dictgen::InsensitiveStr::Ascii("rences"),
        dictgen::InsensitiveStr::Ascii("rential"),
        dictgen::InsensitiveStr::Ascii("rm"),
        dictgen::InsensitiveStr::Ascii("rmance"),
        dictgen::InsensitiveStr::Ascii("rmances"),
        dictgen::InsensitiveStr::Ascii("rmence"),
        dictgen::InsensitiveStr::Ascii("rmences"),
        dictgen::InsensitiveStr::Ascii("rr"),
        dictgen::InsensitiveStr::Ascii("rrable"),
        dictgen::InsensitiveStr::Ascii("rrably"),
        dictgen::InsensitiveStr::Ascii("rrance"),
        dictgen::InsensitiveStr::Ascii("rrances"),
        dictgen::InsensitiveStr::Ascii("rred"),
        dictgen::InsensitiveStr::Ascii("rrence"),
        dictgen::InsensitiveStr::Ascii("rrences"),
        dictgen::InsensitiveStr::Ascii("rring"),
        dictgen::InsensitiveStr::Ascii("rrm"),
        dictgen::InsensitiveStr::Ascii("rrmance"),
        dictgen::InsensitiveStr::Ascii("rrmances"),
        dictgen::InsensitiveStr::Ascii("rrmence"),
        dictgen::InsensitiveStr::Ascii("rrmences"),
        dictgen::InsensitiveStr::Ascii("rrs"),
        dictgen::InsensitiveStr::Ascii("rs"),
        dictgen::InsensitiveStr::Ascii("xcion"),
    ],
    values: &[
        &["perfect"],
        &["perfection"],
        &["perfect"],
        &["perfectly"],
        &["perfectly"],
        &["perfectly"],
        &["perfectly"],
        &["perfectly"],
        &["perfection"],
        &["perfection"],
        &["prefer"],
        &["preferable"],
        &["preferably"],
        &["preference"],
        &["preferences"],
        &["perfect"],
        &["perfectly"],
        &["perfect"],
        &["perfectly"],
        &["preferred"],
        &["preference"],
        &["preferences"],
        &["preferential"],
        &["perform"],
        &["performance"],
        &["performances"],
        &["performance"],
        &["performances"],
        &["prefer"],
        &["preferable"],
        &["preferably"],
        &["preference"],
        &["preferences"],
        &["preferred"],
        &["preference"],
        &["preferences"],
        &["preferring"],
        &["perform"],
        &["performance"],
        &["performances"],
        &["performance"],
        &["performances"],
        &["prefers"],
        &["prefers"],
        &["perfection"],
    ],
    range: 1..=8,
};

static WORD_PERE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PERE_CHILDREN),
    value: None,
};

pub static WORD_PERE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("miter"),
        dictgen::InsensitiveStr::Ascii("nially"),
        dictgen::InsensitiveStr::Ascii("phirals"),
        dictgen::InsensitiveStr::Ascii("ptually"),
        dictgen::InsensitiveStr::Ascii("sent"),
        dictgen::InsensitiveStr::Ascii("trator"),
    ],
    values: &[
        &["perimeter"],
        &["perennially"],
        &["peripherals"],
        &["perpetually"],
        &["present", "presents", "presence", "percent"],
        &["perpetrator"],
    ],
    range: 4..=7,
};

static WORD_PERD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PERD_CHILDREN),
    value: None,
};

pub static WORD_PERD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ators"),
        dictgen::InsensitiveStr::Ascii("icament"),
        dictgen::InsensitiveStr::Ascii("ict"),
        dictgen::InsensitiveStr::Ascii("ictable"),
        dictgen::InsensitiveStr::Ascii("icting"),
        dictgen::InsensitiveStr::Ascii("iction"),
        dictgen::InsensitiveStr::Ascii("ictions"),
        dictgen::InsensitiveStr::Ascii("ictive"),
        dictgen::InsensitiveStr::Ascii("ominantly"),
    ],
    values: &[
        &["predators"],
        &["predicament"],
        &["predict"],
        &["predictable"],
        &["predicting"],
        &["prediction"],
        &["predictions"],
        &["predictive"],
        &["predominantly"],
    ],
    range: 3..=9,
};

static WORD_PERC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PERC_CHILDREN),
    value: None,
};

pub static WORD_PERC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("antage"),
        dictgen::InsensitiveStr::Ascii("antages"),
        dictgen::InsensitiveStr::Ascii("antile"),
        dictgen::InsensitiveStr::Ascii("aution"),
        dictgen::InsensitiveStr::Ascii("autions"),
        dictgen::InsensitiveStr::Ascii("eded"),
        dictgen::InsensitiveStr::Ascii("enatge"),
        dictgen::InsensitiveStr::Ascii("enatges"),
        dictgen::InsensitiveStr::Ascii("entagens"),
        dictgen::InsensitiveStr::Ascii("entange"),
        dictgen::InsensitiveStr::Ascii("entanges"),
        dictgen::InsensitiveStr::Ascii("ente"),
        dictgen::InsensitiveStr::Ascii("ential"),
        dictgen::InsensitiveStr::Ascii("entige"),
        dictgen::InsensitiveStr::Ascii("entil"),
        dictgen::InsensitiveStr::Ascii("entille"),
        dictgen::InsensitiveStr::Ascii("epted"),
        dictgen::InsensitiveStr::Ascii("eptoin"),
        dictgen::InsensitiveStr::Ascii("ession"),
        dictgen::InsensitiveStr::Ascii("etage"),
        dictgen::InsensitiveStr::Ascii("etages"),
        dictgen::InsensitiveStr::Ascii("etange"),
        dictgen::InsensitiveStr::Ascii("etnage"),
        dictgen::InsensitiveStr::Ascii("evied"),
        dictgen::InsensitiveStr::Ascii("ievable"),
        dictgen::InsensitiveStr::Ascii("ievabley"),
        dictgen::InsensitiveStr::Ascii("ievably"),
        dictgen::InsensitiveStr::Ascii("ieve"),
        dictgen::InsensitiveStr::Ascii("ieved"),
        dictgen::InsensitiveStr::Ascii("intile"),
        dictgen::InsensitiveStr::Ascii("ious"),
        dictgen::InsensitiveStr::Ascii("ise"),
        dictgen::InsensitiveStr::Ascii("isely"),
        dictgen::InsensitiveStr::Ascii("ision"),
        dictgen::InsensitiveStr::Ascii("ission"),
        dictgen::InsensitiveStr::Ascii("lude"),
        dictgen::InsensitiveStr::Ascii("petion"),
        dictgen::InsensitiveStr::Ascii("petions"),
        dictgen::InsensitiveStr::Ascii("ursor"),
        dictgen::InsensitiveStr::Ascii("usions"),
        dictgen::InsensitiveStr::Ascii("usssion"),
    ],
    values: &[
        &["percentage"],
        &["percentages"],
        &["percentile"],
        &["precaution"],
        &["precautions"],
        &["preceded"],
        &["percentages", "percentage"],
        &["percentages"],
        &["percentages"],
        &["percentage"],
        &["percentages"],
        &["percentile"],
        &["percentile"],
        &["percentile"],
        &["percentile"],
        &["percentile"],
        &["perceived"],
        &["perceptions"],
        &["percussion"],
        &["percentage"],
        &["percentages"],
        &["percentages"],
        &["percentages"],
        &["perceived"],
        &["perceivable"],
        &["perceivably"],
        &["perceivably"],
        &["perceive"],
        &["perceived"],
        &["percentile"],
        &["precious"],
        &["precise"],
        &["precisely"],
        &["precision"],
        &["percussion"],
        &["preclude"],
        &["perceptions"],
        &["perceptions"],
        &["precursor"],
        &["percussion"],
        &["percussion"],
    ],
    range: 3..=8,
};

static WORD_PERA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PERA_CHILDREN),
    value: None,
};

pub static WORD_PERA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("de"),
        dictgen::InsensitiveStr::Ascii("phs"),
    ],
    values: &[&["parade"], &["perhaps"]],
    range: 2..=3,
};

static WORD_PEP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PEP_CHILDREN),
    value: None,
};

pub static WORD_PEP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("are"),
        dictgen::InsensitiveStr::Ascii("orted"),
        dictgen::InsensitiveStr::Ascii("perin"),
        dictgen::InsensitiveStr::Ascii("perino"),
        dictgen::InsensitiveStr::Ascii("perment"),
        dictgen::InsensitiveStr::Ascii("permit"),
        dictgen::InsensitiveStr::Ascii("perocini"),
        dictgen::InsensitiveStr::Ascii("peronni"),
        dictgen::InsensitiveStr::Ascii("rocessor"),
    ],
    values: &[
        &["prepare"],
        &["reported", "purported"],
        &["pepperoni"],
        &["pepperoni"],
        &["peppermint"],
        &["peppermint"],
        &["pepperoni"],
        &["pepperoni"],
        &["preprocessor"],
    ],
    range: 3..=8,
};

static WORD_PEO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PEO_CHILDREN),
    value: None,
};

pub static WORD_PEO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("dphile"),
        dictgen::InsensitiveStr::Ascii("dphiles"),
        dictgen::InsensitiveStr::Ascii("dphilia"),
        dictgen::InsensitiveStr::Ascii("m"),
        dictgen::InsensitiveStr::Ascii("ms"),
        dictgen::InsensitiveStr::Ascii("pel"),
        dictgen::InsensitiveStr::Ascii("pels"),
        dictgen::InsensitiveStr::Ascii("pl"),
        dictgen::InsensitiveStr::Ascii("try"),
    ],
    values: &[
        &["pedophile"],
        &["pedophiles"],
        &["pedophilia"],
        &["poem"],
        &["poems"],
        &["people"],
        &["peoples"],
        &["people"],
        &["poetry"],
    ],
    range: 1..=7,
};

static WORD_PEN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_PEN_CHILDREN),
    value: None,
};

static WORD_PEN_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_PENA_NODE),
    None,
    Some(&WORD_PENC_NODE),
    Some(&WORD_PEND_NODE),
    Some(&WORD_PENE_NODE),
    None,
    Some(&WORD_PENG_NODE),
    None,
    Some(&WORD_PENI_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_PENN_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_PENS_NODE),
    Some(&WORD_PENT_NODE),
    Some(&WORD_PENU_NODE),
    None,
    Some(&WORD_PENW_NODE),
    None,
    None,
    None,
];

static WORD_PENW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PENW_CHILDREN),
    value: None,
};

pub static WORD_PENW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ar")],
    values: &[&["peignoir"]],
    range: 2..=2,
};

static WORD_PENU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PENU_CHILDREN),
    value: None,
};

pub static WORD_PENU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ltimante")],
    values: &[&["penultimate"]],
    range: 8..=8,
};

static WORD_PENT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PENT_CHILDREN),
    value: None,
};

pub static WORD_PENT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("agoon"),
        dictgen::InsensitiveStr::Ascii("alty"),
        dictgen::InsensitiveStr::Ascii("sylvania"),
        dictgen::InsensitiveStr::Ascii("uim"),
    ],
    values: &[&["pentagon"], &["penalty"], &["pennsylvania"], &["pentium"]],
    range: 3..=8,
};

static WORD_PENS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PENS_CHILDREN),
    value: None,
};

pub static WORD_PENS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ies"),
        dictgen::InsensitiveStr::Ascii("ino"),
        dictgen::InsensitiveStr::Ascii("inula"),
        dictgen::InsensitiveStr::Ascii("ioen"),
        dictgen::InsensitiveStr::Ascii("le"),
        dictgen::InsensitiveStr::Ascii("sylvania"),
    ],
    values: &[
        &["penises"],
        &["pension"],
        &["peninsula"],
        &["pension"],
        &["pencil"],
        &["pennsylvania"],
    ],
    range: 2..=8,
};

static WORD_PENN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PENN_CHILDREN),
    value: None,
};

pub static WORD_PENN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("al"),
        dictgen::InsensitiveStr::Ascii("als"),
        dictgen::InsensitiveStr::Ascii("ensula"),
        dictgen::InsensitiveStr::Ascii("ensular"),
        dictgen::InsensitiveStr::Ascii("ensulas"),
        dictgen::InsensitiveStr::Ascii("insula"),
        dictgen::InsensitiveStr::Ascii("insular"),
        dictgen::InsensitiveStr::Ascii("insulas"),
        dictgen::InsensitiveStr::Ascii("isula"),
        dictgen::InsensitiveStr::Ascii("isular"),
        dictgen::InsensitiveStr::Ascii("isulas"),
        dictgen::InsensitiveStr::Ascii("silvania"),
        dictgen::InsensitiveStr::Ascii("slyvania"),
        dictgen::InsensitiveStr::Ascii("sylvaina"),
        dictgen::InsensitiveStr::Ascii("sylvainia"),
        dictgen::InsensitiveStr::Ascii("sylvanica"),
        dictgen::InsensitiveStr::Ascii("sylvannia"),
        dictgen::InsensitiveStr::Ascii("sylvnia"),
        dictgen::InsensitiveStr::Ascii("syvlania"),
        dictgen::InsensitiveStr::Ascii("yslvania"),
    ],
    values: &[
        &["panel"],
        &["panels"],
        &["peninsula"],
        &["peninsular"],
        &["peninsulas"],
        &["peninsula"],
        &["peninsular"],
        &["peninsulas"],
        &["peninsula"],
        &["peninsular"],
        &["peninsulas"],
        &["pennsylvania"],
        &["pennsylvania"],
        &["pennsylvania"],
        &["pennsylvania"],
        &["pennsylvania"],
        &["pennsylvania"],
        &["pennsylvania"],
        &["pennsylvania"],
        &["pennsylvania"],
    ],
    range: 2..=9,
};

static WORD_PENI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PENI_CHILDREN),
    value: None,
};

pub static WORD_PENI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cls"),
        dictgen::InsensitiveStr::Ascii("nsual"),
        dictgen::InsensitiveStr::Ascii("nsulla"),
        dictgen::InsensitiveStr::Ascii("nusla"),
        dictgen::InsensitiveStr::Ascii("snula"),
        dictgen::InsensitiveStr::Ascii("son"),
        dictgen::InsensitiveStr::Ascii("sse"),
        dictgen::InsensitiveStr::Ascii("sula"),
        dictgen::InsensitiveStr::Ascii("sular"),
        dictgen::InsensitiveStr::Ascii("sylvania"),
        dictgen::InsensitiveStr::Ascii("tum"),
    ],
    values: &[
        &["pencils"],
        &["peninsula"],
        &["peninsula"],
        &["peninsula"],
        &["peninsula"],
        &["pension"],
        &["penises"],
        &["peninsula"],
        &["peninsular"],
        &["pennsylvania"],
        &["pentium"],
    ],
    range: 3..=8,
};

static WORD_PENG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PENG_CHILDREN),
    value: None,
};

pub static WORD_PENG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("iuns"),
        dictgen::InsensitiveStr::Ascii("uines"),
        dictgen::InsensitiveStr::Ascii("uinese"),
        dictgen::InsensitiveStr::Ascii("uiness"),
        dictgen::InsensitiveStr::Ascii("uings"),
        dictgen::InsensitiveStr::Ascii("uinos"),
        dictgen::InsensitiveStr::Ascii("uis"),
        dictgen::InsensitiveStr::Ascii("wen"),
        dictgen::InsensitiveStr::Ascii("wens"),
        dictgen::InsensitiveStr::Ascii("win"),
        dictgen::InsensitiveStr::Ascii("wins"),
    ],
    values: &[
        &["penguins"],
        &["penguins"],
        &["penguins"],
        &["penguins"],
        &["penguins"],
        &["penguins"],
        &["penguins"],
        &["penguin"],
        &["penguins"],
        &["penguin"],
        &["penguins"],
    ],
    range: 3..=6,
};

static WORD_PENE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PENE_CHILDREN),
    value: None,
};

pub static WORD_PENE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("rator"),
        dictgen::InsensitiveStr::Ascii("tracion"),
        dictgen::InsensitiveStr::Ascii("trading"),
        dictgen::InsensitiveStr::Ascii("traion"),
        dictgen::InsensitiveStr::Ascii("trarion"),
        dictgen::InsensitiveStr::Ascii("tratiing"),
        dictgen::InsensitiveStr::Ascii("tratin"),
        dictgen::InsensitiveStr::Ascii("traton"),
    ],
    values: &[
        &["penetrator"],
        &["penetration"],
        &["penetrating"],
        &["penetration"],
        &["penetration"],
        &["penetrating"],
        &["penetration"],
        &["penetration"],
    ],
    range: 5..=8,
};

static WORD_PEND_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PEND_CHILDREN),
    value: None,
};

pub static WORD_PEND_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("antic"),
        dictgen::InsensitiveStr::Ascii("atic"),
        dictgen::InsensitiveStr::Ascii("ig"),
        dictgen::InsensitiveStr::Ascii("ning"),
        dictgen::InsensitiveStr::Ascii("ulm"),
        dictgen::InsensitiveStr::Ascii("uluum"),
    ],
    values: &[
        &["pedantic"],
        &["pedantic"],
        &["pending"],
        &["pending"],
        &["pendulum"],
        &["pendulum"],
    ],
    range: 2..=5,
};

static WORD_PENC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PENC_CHILDREN),
    value: None,
};

pub static WORD_PENC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("iles")],
    values: &[&["pencils"]],
    range: 4..=4,
};

static WORD_PENA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PENA_CHILDREN),
    value: None,
};

pub static WORD_PENA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("lites"),
        dictgen::InsensitiveStr::Ascii("lities"),
        dictgen::InsensitiveStr::Ascii("lity"),
        dictgen::InsensitiveStr::Ascii("ltis"),
        dictgen::InsensitiveStr::Ascii("tenturies"),
        dictgen::InsensitiveStr::Ascii("tentury"),
        dictgen::InsensitiveStr::Ascii("tgon"),
        dictgen::InsensitiveStr::Ascii("tlies"),
        dictgen::InsensitiveStr::Ascii("tly"),
    ],
    values: &[
        &["penalties"],
        &["penalties"],
        &["penalty"],
        &["penalties"],
        &["penitentiaries"],
        &["penitentiary"],
        &["pentagon"],
        &["penalties"],
        &["penalty"],
    ],
    range: 3..=9,
};

static WORD_PEL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PEL_CHILDREN),
    value: None,
};

pub static WORD_PEL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("oponnes")],
    values: &[&["peloponnese", "peloponnesus"]],
    range: 7..=7,
};

static WORD_PEI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PEI_CHILDREN),
    value: None,
};

pub static WORD_PEI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ce"),
        dictgen::InsensitiveStr::Ascii("cemeal"),
        dictgen::InsensitiveStr::Ascii("ces"),
        dictgen::InsensitiveStr::Ascii("cewise"),
        dictgen::InsensitiveStr::Ascii("ece"),
        dictgen::InsensitiveStr::Ascii("rced"),
        dictgen::InsensitiveStr::Ascii("rcing"),
        dictgen::InsensitiveStr::Ascii("rcings"),
        dictgen::InsensitiveStr::Ascii("rod"),
        dictgen::InsensitiveStr::Ascii("rodical"),
        dictgen::InsensitiveStr::Ascii("rodicals"),
        dictgen::InsensitiveStr::Ascii("rods"),
    ],
    values: &[
        &["piece"],
        &["piecemeal"],
        &["pieces"],
        &["piecewise"],
        &["piece"],
        &["pierced"],
        &["piercing"],
        &["piercings"],
        &["period"],
        &["periodical"],
        &["periodicals"],
        &["periods"],
    ],
    range: 2..=8,
};

static WORD_PEH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PEH_CHILDREN),
    value: None,
};

pub static WORD_PEH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("aps")],
    values: &[&["perhaps"]],
    range: 3..=3,
};

static WORD_PEG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PEG_CHILDREN),
    value: None,
};

pub static WORD_PEG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("e")],
    values: &[&["page"]],
    range: 1..=1,
};

static WORD_PEF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PEF_CHILDREN),
    value: None,
};

pub static WORD_PEF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("er"),
        dictgen::InsensitiveStr::Ascii("erable"),
        dictgen::InsensitiveStr::Ascii("erably"),
        dictgen::InsensitiveStr::Ascii("ered"),
        dictgen::InsensitiveStr::Ascii("erence"),
        dictgen::InsensitiveStr::Ascii("erences"),
        dictgen::InsensitiveStr::Ascii("erential"),
        dictgen::InsensitiveStr::Ascii("erentially"),
        dictgen::InsensitiveStr::Ascii("erred"),
        dictgen::InsensitiveStr::Ascii("erring"),
        dictgen::InsensitiveStr::Ascii("ers"),
        dictgen::InsensitiveStr::Ascii("orm"),
        dictgen::InsensitiveStr::Ascii("ormance"),
        dictgen::InsensitiveStr::Ascii("ormed"),
        dictgen::InsensitiveStr::Ascii("orming"),
    ],
    values: &[
        &["prefer"],
        &["preferable"],
        &["preferably"],
        &["preferred"],
        &["preference"],
        &["preferences"],
        &["preferential"],
        &["preferentially"],
        &["preferred"],
        &["preferring"],
        &["prefers"],
        &["perform"],
        &["performance"],
        &["performed"],
        &["performing"],
    ],
    range: 2..=10,
};

static WORD_PEE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PEE_CHILDREN),
    value: None,
};

pub static WORD_PEE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("dmont"),
        dictgen::InsensitiveStr::Ascii("dmonts"),
        dictgen::InsensitiveStr::Ascii("pel"),
        dictgen::InsensitiveStr::Ascii("pels"),
        dictgen::InsensitiveStr::Ascii("rowet"),
        dictgen::InsensitiveStr::Ascii("rowetes"),
        dictgen::InsensitiveStr::Ascii("rowets"),
    ],
    values: &[
        &["piedmont"],
        &["piedmonts"],
        &["people"],
        &["peoples"],
        &["pirouette"],
        &["pirouettes"],
        &["pirouettes"],
    ],
    range: 3..=7,
};

static WORD_PED_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PED_CHILDREN),
    value: None,
};

pub static WORD_PED_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("antisch"),
        dictgen::InsensitiveStr::Ascii("estiran"),
        dictgen::InsensitiveStr::Ascii("estirans"),
        dictgen::InsensitiveStr::Ascii("estrain"),
        dictgen::InsensitiveStr::Ascii("estrains"),
        dictgen::InsensitiveStr::Ascii("ictions"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("istal"),
        dictgen::InsensitiveStr::Ascii("istals"),
        dictgen::InsensitiveStr::Ascii("ning"),
        dictgen::InsensitiveStr::Ascii("ohpile"),
        dictgen::InsensitiveStr::Ascii("ohpiles"),
        dictgen::InsensitiveStr::Ascii("ohpilia"),
        dictgen::InsensitiveStr::Ascii("ophila"),
        dictgen::InsensitiveStr::Ascii("ophilac"),
        dictgen::InsensitiveStr::Ascii("ophilea"),
        dictgen::InsensitiveStr::Ascii("ophilie"),
        dictgen::InsensitiveStr::Ascii("ophilies"),
        dictgen::InsensitiveStr::Ascii("ophilla"),
        dictgen::InsensitiveStr::Ascii("ophille"),
        dictgen::InsensitiveStr::Ascii("ophilles"),
        dictgen::InsensitiveStr::Ascii("ophils"),
        dictgen::InsensitiveStr::Ascii("opholia"),
    ],
    values: &[
        &["pedantic"],
        &["pedestrian"],
        &["pedestrians"],
        &["pedestrian"],
        &["pedestrians"],
        &["depictions"],
        &["pending"],
        &["pedestal"],
        &["pedestals"],
        &["pending"],
        &["pedophile"],
        &["pedophiles"],
        &["pedophilia"],
        &["pedophilia"],
        &["pedophilia"],
        &["pedophilia"],
        &["pedophile"],
        &["pedophile"],
        &["pedophilia"],
        &["pedophile"],
        &["pedophile"],
        &["pedophiles"],
        &["pedophilia"],
    ],
    range: 3..=8,
};

static WORD_PEC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PEC_CHILDREN),
    value: None,
};

pub static WORD_PEC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("entage"),
        dictgen::InsensitiveStr::Ascii("ified"),
        dictgen::InsensitiveStr::Ascii("iluar"),
        dictgen::InsensitiveStr::Ascii("uilar"),
        dictgen::InsensitiveStr::Ascii("ulair"),
        dictgen::InsensitiveStr::Ascii("ularities"),
        dictgen::InsensitiveStr::Ascii("ularity"),
        dictgen::InsensitiveStr::Ascii("ulure"),
    ],
    values: &[
        &["percentage"],
        &["specified", "pacified"],
        &["peculiar"],
        &["peculiar"],
        &["peculiar"],
        &["peculiarities"],
        &["peculiarity"],
        &["peculiar"],
    ],
    range: 5..=9,
};

static WORD_PEB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PEB_CHILDREN),
    value: None,
};

pub static WORD_PEB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("bels"),
        dictgen::InsensitiveStr::Ascii("bleos"),
        dictgen::InsensitiveStr::Ascii("blers"),
        dictgen::InsensitiveStr::Ascii("blets"),
    ],
    values: &[&["pebbles"], &["pebbles"], &["pebbles"], &["pebbles"]],
    range: 4..=5,
};

static WORD_PEA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PEA_CHILDREN),
    value: None,
};

pub static WORD_PEA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cd"),
        dictgen::InsensitiveStr::Ascii("cefullly"),
        dictgen::InsensitiveStr::Ascii("cefuly"),
        dictgen::InsensitiveStr::Ascii("cify"),
        dictgen::InsensitiveStr::Ascii("geant"),
        dictgen::InsensitiveStr::Ascii("nochle"),
        dictgen::InsensitiveStr::Ascii("nockle"),
        dictgen::InsensitiveStr::Ascii("nuchle"),
        dictgen::InsensitiveStr::Ascii("nuckle"),
        dictgen::InsensitiveStr::Ascii("pel"),
        dictgen::InsensitiveStr::Ascii("pels"),
        dictgen::InsensitiveStr::Ascii("ple"),
        dictgen::InsensitiveStr::Ascii("ples"),
        dictgen::InsensitiveStr::Ascii("se"),
        dictgen::InsensitiveStr::Ascii("sed"),
        dictgen::InsensitiveStr::Ascii("seful"),
        dictgen::InsensitiveStr::Ascii("sefully"),
        dictgen::InsensitiveStr::Ascii("ses"),
        dictgen::InsensitiveStr::Ascii("sing"),
    ],
    values: &[
        &["peace"],
        &["peacefully"],
        &["peacefully"],
        &["pacify"],
        &["pageant"],
        &["pinochle"],
        &["pinochle"],
        &["pinochle"],
        &["pinochle"],
        &["people"],
        &["peoples"],
        &["people"],
        &["peoples"],
        &["lease", "peace", "piece", "please"],
        &["leased", "pieced", "pleased"],
        &["peaceful"],
        &["peacefully"],
        &["leases", "pieces", "pleases"],
        &["leasing", "piecing", "pleasing"],
    ],
    range: 2..=8,
};

static WORD_PB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PB_CHILDREN),
    value: None,
};

pub static WORD_PB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("lisher"),
        dictgen::InsensitiveStr::Ascii("ulisher"),
    ],
    values: &[&["publisher"], &["publisher"]],
    range: 6..=7,
};

static WORD_PA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_PA_CHILDREN),
    value: None,
};

static WORD_PA_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_PAA_NODE),
    None,
    Some(&WORD_PAC_NODE),
    Some(&WORD_PAD_NODE),
    Some(&WORD_PAE_NODE),
    Some(&WORD_PAF_NODE),
    Some(&WORD_PAG_NODE),
    Some(&WORD_PAH_NODE),
    Some(&WORD_PAI_NODE),
    None,
    Some(&WORD_PAK_NODE),
    Some(&WORD_PAL_NODE),
    Some(&WORD_PAM_NODE),
    Some(&WORD_PAN_NODE),
    Some(&WORD_PAO_NODE),
    Some(&WORD_PAP_NODE),
    None,
    Some(&WORD_PAR_NODE),
    Some(&WORD_PAS_NODE),
    Some(&WORD_PAT_NODE),
    None,
    Some(&WORD_PAV_NODE),
    None,
    None,
    Some(&WORD_PAY_NODE),
    None,
];

static WORD_PAY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PAY_CHILDREN),
    value: None,
};

pub static WORD_PAY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("chedelics"),
        dictgen::InsensitiveStr::Ascii("chiatrist"),
        dictgen::InsensitiveStr::Ascii("chiatrists"),
        dictgen::InsensitiveStr::Ascii("chologically"),
        dictgen::InsensitiveStr::Ascii("chologist"),
        dictgen::InsensitiveStr::Ascii("chologists"),
        dictgen::InsensitiveStr::Ascii("chopathic"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("lood"),
    ],
    values: &[
        &["psychedelics"],
        &["psychiatrist"],
        &["psychiatrists"],
        &["psychologically"],
        &["psychologist"],
        &["psychologists"],
        &["psychopathic"],
        &["paid"],
        &["payload"],
    ],
    range: 2..=12,
};

static WORD_PAV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PAV_CHILDREN),
    value: None,
};

pub static WORD_PAV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("illion"),
        dictgen::InsensitiveStr::Ascii("illions"),
    ],
    values: &[&["pavilion"], &["pavilions"]],
    range: 6..=7,
};

static WORD_PAT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_PAT_CHILDREN),
    value: None,
};

static WORD_PAT_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_PATA_NODE),
    None,
    Some(&WORD_PATC_NODE),
    None,
    Some(&WORD_PATE_NODE),
    None,
    None,
    Some(&WORD_PATH_NODE),
    Some(&WORD_PATI_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_PATR_NODE),
    None,
    Some(&WORD_PATT_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_PATT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PATT_CHILDREN),
    value: None,
};

pub static WORD_PATT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("en"),
        dictgen::InsensitiveStr::Ascii("ened"),
        dictgen::InsensitiveStr::Ascii("ens"),
        dictgen::InsensitiveStr::Ascii("ented"),
        dictgen::InsensitiveStr::Ascii("erno"),
        dictgen::InsensitiveStr::Ascii("ersn"),
        dictgen::InsensitiveStr::Ascii("ren"),
        dictgen::InsensitiveStr::Ascii("rens"),
        dictgen::InsensitiveStr::Ascii("rns"),
    ],
    values: &[
        &["pattern", "patent"],
        &["patented", "patterned"],
        &["patterns", "patents"],
        &["patented"],
        &["patterson"],
        &["patterson", "patterns"],
        &["pattern", "patron"],
        &["patterns", "patrons"],
        &["patterns"],
    ],
    range: 2..=5,
};

static WORD_PATR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PATR_CHILDREN),
    value: None,
};

pub static WORD_PATR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("airchy"),
        dictgen::InsensitiveStr::Ascii("cik"),
        dictgen::InsensitiveStr::Ascii("en"),
        dictgen::InsensitiveStr::Ascii("ens"),
        dictgen::InsensitiveStr::Ascii("ent"),
        dictgen::InsensitiveStr::Ascii("iachry"),
        dictgen::InsensitiveStr::Ascii("iarca"),
        dictgen::InsensitiveStr::Ascii("iarcal"),
        dictgen::InsensitiveStr::Ascii("iarchia"),
        dictgen::InsensitiveStr::Ascii("iarcial"),
        dictgen::InsensitiveStr::Ascii("iarcy"),
        dictgen::InsensitiveStr::Ascii("iarh"),
        dictgen::InsensitiveStr::Ascii("iarhal"),
        dictgen::InsensitiveStr::Ascii("iarical"),
        dictgen::InsensitiveStr::Ascii("iatchy"),
        dictgen::InsensitiveStr::Ascii("iatism"),
        dictgen::InsensitiveStr::Ascii("ionism"),
        dictgen::InsensitiveStr::Ascii("ios"),
        dictgen::InsensitiveStr::Ascii("iotas"),
        dictgen::InsensitiveStr::Ascii("iotes"),
        dictgen::InsensitiveStr::Ascii("iotics"),
        dictgen::InsensitiveStr::Ascii("iotisch"),
        dictgen::InsensitiveStr::Ascii("iotisim"),
        dictgen::InsensitiveStr::Ascii("iotisk"),
        dictgen::InsensitiveStr::Ascii("iottism"),
        dictgen::InsensitiveStr::Ascii("oit"),
        dictgen::InsensitiveStr::Ascii("oitic"),
        dictgen::InsensitiveStr::Ascii("oitism"),
        dictgen::InsensitiveStr::Ascii("oits"),
        dictgen::InsensitiveStr::Ascii("olls"),
        dictgen::InsensitiveStr::Ascii("onas"),
        dictgen::InsensitiveStr::Ascii("ones"),
        dictgen::InsensitiveStr::Ascii("onis"),
        dictgen::InsensitiveStr::Ascii("onos"),
        dictgen::InsensitiveStr::Ascii("onozing"),
        dictgen::InsensitiveStr::Ascii("yarchy"),
    ],
    values: &[
        &["patriarchy"],
        &["patrick"],
        &["patron", "pattern"],
        &["patron", "patterns"],
        &["parent", "patent", "patron"],
        &["patriarchy"],
        &["patriarchal"],
        &["patriarchal"],
        &["patriarchal"],
        &["patriarchal"],
        &["patriarchy"],
        &["patriarchy"],
        &["patriarchal"],
        &["patriarchal"],
        &["patriarchy"],
        &["patriotism"],
        &["patriotism"],
        &["patriots"],
        &["patriots"],
        &["patriots"],
        &["patriotism"],
        &["patriotic"],
        &["patriotism"],
        &["patriots"],
        &["patriotism"],
        &["patriot"],
        &["patriotic"],
        &["patriotism"],
        &["patriots"],
        &["patrols"],
        &["patrons"],
        &["patrons"],
        &["patrons"],
        &["patrons"],
        &["patronizing"],
        &["patriarchy"],
    ],
    range: 2..=7,
};

static WORD_PATI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PATI_CHILDREN),
    value: None,
};

pub static WORD_PATI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("al"),
        dictgen::InsensitiveStr::Ascii("cular"),
        dictgen::InsensitiveStr::Ascii("cularly"),
        dictgen::InsensitiveStr::Ascii("ens"),
        dictgen::InsensitiveStr::Ascii("entens"),
        dictgen::InsensitiveStr::Ascii("enty"),
        dictgen::InsensitiveStr::Ascii("netly"),
        dictgen::InsensitiveStr::Ascii("rot"),
        dictgen::InsensitiveStr::Ascii("rots"),
        dictgen::InsensitiveStr::Ascii("tion"),
    ],
    values: &[
        &["spatial"],
        &["particular"],
        &["particularly"],
        &["patients"],
        &["patients"],
        &["patiently"],
        &["patiently"],
        &["patriot"],
        &["patriots"],
        &["partition"],
    ],
    range: 2..=7,
};

static WORD_PATH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PATH_CHILDREN),
    value: None,
};

pub static WORD_PATH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("alogical"),
        dictgen::InsensitiveStr::Ascii("ame"),
        dictgen::InsensitiveStr::Ascii("ames"),
        dictgen::InsensitiveStr::Ascii("ane"),
        dictgen::InsensitiveStr::Ascii("ced"),
        dictgen::InsensitiveStr::Ascii("ces"),
        dictgen::InsensitiveStr::Ascii("eitc"),
        dictgen::InsensitiveStr::Ascii("elogical"),
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("fidner"),
        dictgen::InsensitiveStr::Ascii("findir"),
        dictgen::InsensitiveStr::Ascii("ifnder"),
        dictgen::InsensitiveStr::Ascii("ign"),
        dictgen::InsensitiveStr::Ascii("neame"),
        dictgen::InsensitiveStr::Ascii("nme"),
        dictgen::InsensitiveStr::Ascii("olgoical"),
        dictgen::InsensitiveStr::Ascii("oligical"),
        dictgen::InsensitiveStr::Ascii("ologial"),
    ],
    values: &[
        &["pathological"],
        &["pathname"],
        &["pathnames"],
        &["pathname"],
        &["patched"],
        &["patches"],
        &["pathetic"],
        &["pathological"],
        &["paths"],
        &["pathfinder"],
        &["pathfinder"],
        &["pathfinder"],
        &["pathing"],
        &["pathname"],
        &["pathname"],
        &["pathological"],
        &["pathological"],
        &["pathological"],
    ],
    range: 2..=8,
};

static WORD_PATE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PATE_CHILDREN),
    value: None,
};

pub static WORD_PATE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ince"),
        dictgen::InsensitiveStr::Ascii("int"),
        dictgen::InsensitiveStr::Ascii("intly"),
        dictgen::InsensitiveStr::Ascii("ints"),
        dictgen::InsensitiveStr::Ascii("nterad"),
        dictgen::InsensitiveStr::Ascii("rn"),
        dictgen::InsensitiveStr::Ascii("rns"),
        dictgen::InsensitiveStr::Ascii("thic"),
    ],
    values: &[
        &["patience"],
        &["patient"],
        &["patiently"],
        &["patients"],
        &["patented"],
        &["pattern"],
        &["patterns"],
        &["pathetic"],
    ],
    range: 2..=6,
};

static WORD_PATC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PATC_CHILDREN),
    value: None,
};

pub static WORD_PATC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("hs"),
        dictgen::InsensitiveStr::Ascii("ket"),
        dictgen::InsensitiveStr::Ascii("kets"),
    ],
    values: &[&["patches", "paths"], &["packet"], &["packets"]],
    range: 2..=4,
};

static WORD_PATA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PATA_CHILDREN),
    value: None,
};

pub static WORD_PATA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("meter"),
        dictgen::InsensitiveStr::Ascii("meters"),
    ],
    values: &[&["parameter"], &["parameters"]],
    range: 5..=6,
};

static WORD_PAS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_PAS_CHILDREN),
    value: None,
};

static WORD_PAS_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    Some(&WORD_PASC_NODE),
    None,
    Some(&WORD_PASE_NODE),
    None,
    None,
    Some(&WORD_PASH_NODE),
    Some(&WORD_PASI_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_PASR_NODE),
    Some(&WORD_PASS_NODE),
    Some(&WORD_PAST_NODE),
    Some(&WORD_PASU_NODE),
    None,
    Some(&WORD_PASW_NODE),
    None,
    None,
    None,
];

static WORD_PASW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PASW_CHILDREN),
    value: None,
};

pub static WORD_PASW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ord"),
        dictgen::InsensitiveStr::Ascii("ords"),
    ],
    values: &[&["password"], &["passwords"]],
    range: 3..=4,
};

static WORD_PASU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PASU_CHILDREN),
    value: None,
};

pub static WORD_PASU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ing")],
    values: &[&["pausing"]],
    range: 3..=3,
};

static WORD_PAST_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PAST_CHILDREN),
    value: None,
};

pub static WORD_PAST_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eing"),
        dictgen::InsensitiveStr::Ascii("eries"),
        dictgen::InsensitiveStr::Ascii("ery"),
        dictgen::InsensitiveStr::Ascii("time"),
        dictgen::InsensitiveStr::Ascii("ural"),
        dictgen::InsensitiveStr::Ascii("urisation"),
        dictgen::InsensitiveStr::Ascii("urise"),
        dictgen::InsensitiveStr::Ascii("urised"),
        dictgen::InsensitiveStr::Ascii("urises"),
        dictgen::InsensitiveStr::Ascii("urising"),
        dictgen::InsensitiveStr::Ascii("urization"),
        dictgen::InsensitiveStr::Ascii("urize"),
        dictgen::InsensitiveStr::Ascii("urized"),
        dictgen::InsensitiveStr::Ascii("urizes"),
        dictgen::InsensitiveStr::Ascii("urizing"),
    ],
    values: &[
        &["pasting"],
        &["pastries"],
        &["pastry"],
        &["pastime"],
        &["pastoral"],
        &["pasteurisation"],
        &["pasteurise"],
        &["pasteurised"],
        &["pasteurises"],
        &["pasteurising"],
        &["pasteurization"],
        &["pasteurize"],
        &["pasteurized"],
        &["pasteurizes"],
        &["pasteurizing"],
    ],
    range: 3..=9,
};

static WORD_PASS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PASS_CHILDREN),
    value: None,
};

pub static WORD_PASS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("abe"),
        dictgen::InsensitiveStr::Ascii("abel"),
        dictgen::InsensitiveStr::Ascii("agens"),
        dictgen::InsensitiveStr::Ascii("agers"),
        dictgen::InsensitiveStr::Ascii("erbys"),
        dictgen::InsensitiveStr::Ascii("in"),
        dictgen::InsensitiveStr::Ascii("ionais"),
        dictgen::InsensitiveStr::Ascii("ionale"),
        dictgen::InsensitiveStr::Ascii("ionant"),
        dictgen::InsensitiveStr::Ascii("ionatelly"),
        dictgen::InsensitiveStr::Ascii("ionatley"),
        dictgen::InsensitiveStr::Ascii("ionatly"),
        dictgen::InsensitiveStr::Ascii("ione"),
        dictgen::InsensitiveStr::Ascii("iones"),
        dictgen::InsensitiveStr::Ascii("ionetly"),
        dictgen::InsensitiveStr::Ascii("ionite"),
        dictgen::InsensitiveStr::Ascii("ionnate"),
        dictgen::InsensitiveStr::Ascii("isve"),
        dictgen::InsensitiveStr::Ascii("iv"),
        dictgen::InsensitiveStr::Ascii("ivedns"),
        dictgen::InsensitiveStr::Ascii("ivelly"),
        dictgen::InsensitiveStr::Ascii("ivley"),
        dictgen::InsensitiveStr::Ascii("ivs"),
        dictgen::InsensitiveStr::Ascii("ord"),
        dictgen::InsensitiveStr::Ascii("ords"),
        dictgen::InsensitiveStr::Ascii("owrd"),
        dictgen::InsensitiveStr::Ascii("owrds"),
        dictgen::InsensitiveStr::Ascii("porters"),
        dictgen::InsensitiveStr::Ascii("post"),
        dictgen::InsensitiveStr::Ascii("s"),
        dictgen::InsensitiveStr::Ascii("sed"),
        dictgen::InsensitiveStr::Ascii("sing"),
        dictgen::InsensitiveStr::Ascii("sword"),
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("throught"),
        dictgen::InsensitiveStr::Ascii("thruogh"),
        dictgen::InsensitiveStr::Ascii("time"),
        dictgen::InsensitiveStr::Ascii("trough"),
        dictgen::InsensitiveStr::Ascii("vies"),
        dictgen::InsensitiveStr::Ascii("wird"),
        dictgen::InsensitiveStr::Ascii("wirds"),
        dictgen::InsensitiveStr::Ascii("wors"),
        dictgen::InsensitiveStr::Ascii("wrod"),
        dictgen::InsensitiveStr::Ascii("wrods"),
    ],
    values: &[
        &["passable"],
        &["passable"],
        &["passages"],
        &["passages"],
        &["passersby"],
        &["passing"],
        &["passions"],
        &["passionately"],
        &["passionate"],
        &["passionately"],
        &["passionately"],
        &["passionately"],
        &["passionate"],
        &["passions"],
        &["passionately"],
        &["passionate"],
        &["passionate"],
        &["passives"],
        &["passive"],
        &["passives"],
        &["passively"],
        &["passively"],
        &["passives"],
        &["password"],
        &["passwords"],
        &["password"],
        &["passwords"],
        &["passports"],
        &["passports"],
        &["pass"],
        &["passed"],
        &["passing"],
        &["password"],
        &["passed", "past"],
        &["passthrough"],
        &["passthrough"],
        &["pastime"],
        &["passthrough"],
        &["passives"],
        &["password"],
        &["passwords"],
        &["passwords"],
        &["password"],
        &["passwords"],
    ],
    range: 1..=9,
};

static WORD_PASR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PASR_CHILDREN),
    value: None,
};

pub static WORD_PASR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("sed"),
    ],
    values: &[&["parse"], &["parsed"], &["parses"], &["parsed"]],
    range: 1..=3,
};

static WORD_PASI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PASI_CHILDREN),
    value: None,
};

pub static WORD_PASI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ng"),
        dictgen::InsensitiveStr::Ascii("tioning"),
        dictgen::InsensitiveStr::Ascii("ve"),
    ],
    values: &[&["passing", "posing"], &["positioning"], &["passive"]],
    range: 2..=7,
};

static WORD_PASH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PASH_CHILDREN),
    value: Some(&["hash"]),
};

pub static WORD_PASH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[],
    values: &[],
    range: 0..=0,
};

static WORD_PASE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PASE_CHILDREN),
    value: Some(&["pass", "pace", "parse"]),
};

pub static WORD_PASE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("d"),
        dictgen::InsensitiveStr::Ascii("ngers"),
        dictgen::InsensitiveStr::Ascii("r"),
        dictgen::InsensitiveStr::Ascii("sd"),
    ],
    values: &[
        &["passed", "parsed"],
        &["passengers"],
        &["parser"],
        &["passed"],
    ],
    range: 1..=5,
};

static WORD_PASC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PASC_CHILDREN),
    value: None,
};

pub static WORD_PASC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("heurisation"),
        dictgen::InsensitiveStr::Ascii("heurise"),
        dictgen::InsensitiveStr::Ascii("heurised"),
        dictgen::InsensitiveStr::Ascii("heurises"),
        dictgen::InsensitiveStr::Ascii("heurising"),
        dictgen::InsensitiveStr::Ascii("heurization"),
        dictgen::InsensitiveStr::Ascii("heurize"),
        dictgen::InsensitiveStr::Ascii("heurized"),
        dictgen::InsensitiveStr::Ascii("heurizes"),
        dictgen::InsensitiveStr::Ascii("heurizing"),
        dictgen::InsensitiveStr::Ascii("hurisation"),
        dictgen::InsensitiveStr::Ascii("hurise"),
        dictgen::InsensitiveStr::Ascii("hurised"),
        dictgen::InsensitiveStr::Ascii("hurises"),
        dictgen::InsensitiveStr::Ascii("hurising"),
        dictgen::InsensitiveStr::Ascii("hurization"),
        dictgen::InsensitiveStr::Ascii("hurize"),
        dictgen::InsensitiveStr::Ascii("hurized"),
        dictgen::InsensitiveStr::Ascii("hurizes"),
        dictgen::InsensitiveStr::Ascii("hurizing"),
    ],
    values: &[
        &["pasteurisation"],
        &["pasteurise"],
        &["pasteurised"],
        &["pasteurises"],
        &["pasteurising"],
        &["pasteurization"],
        &["pasteurize"],
        &["pasteurized"],
        &["pasteurizes"],
        &["pasteurizing"],
        &["pasteurisation"],
        &["pasteurise"],
        &["pasteurised"],
        &["pasteurises"],
        &["pasteurising"],
        &["pasteurization"],
        &["pasteurize"],
        &["pasteurized"],
        &["pasteurizes"],
        &["pasteurizing"],
    ],
    range: 6..=11,
};

static WORD_PAR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_PAR_CHILDREN),
    value: None,
};

static WORD_PAR_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_PARA_NODE),
    None,
    Some(&WORD_PARC_NODE),
    Some(&WORD_PARD_NODE),
    Some(&WORD_PARE_NODE),
    Some(&WORD_PARF_NODE),
    Some(&WORD_PARG_NODE),
    None,
    Some(&WORD_PARI_NODE),
    None,
    Some(&WORD_PARK_NODE),
    Some(&WORD_PARL_NODE),
    Some(&WORD_PARM_NODE),
    Some(&WORD_PARN_NODE),
    Some(&WORD_PARO_NODE),
    None,
    None,
    Some(&WORD_PARR_NODE),
    Some(&WORD_PARS_NODE),
    Some(&WORD_PART_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_PARY_NODE),
    None,
];

static WORD_PARY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PARY_CHILDREN),
    value: Some(&["party", "parry"]),
};

pub static WORD_PARY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[],
    values: &[],
    range: 0..=0,
};

static WORD_PART_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_PART_CHILDREN),
    value: None,
};

static WORD_PART_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_PARTA_NODE),
    None,
    Some(&WORD_PARTC_NODE),
    None,
    Some(&WORD_PARTE_NODE),
    None,
    None,
    Some(&WORD_PARTH_NODE),
    Some(&WORD_PARTI_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_PARTN_NODE),
    Some(&WORD_PARTO_NODE),
    None,
    None,
    None,
    Some(&WORD_PARTS_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_PARTS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PARTS_CHILDREN),
    value: None,
};

pub static WORD_PARTS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ian")],
    values: &[&["partisan"]],
    range: 3..=3,
};

static WORD_PARTO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PARTO_CHILDREN),
    value: None,
};

pub static WORD_PARTO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ls"),
        dictgen::InsensitiveStr::Ascii("nizing"),
    ],
    values: &[&["patrols"], &["patronizing"]],
    range: 2..=6,
};

static WORD_PARTN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PARTN_CHILDREN),
    value: None,
};

pub static WORD_PARTN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("erd"),
        dictgen::InsensitiveStr::Ascii("etship"),
    ],
    values: &[&["partnered"], &["partnership"]],
    range: 3..=6,
};

static WORD_PARTI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_PARTI_CHILDREN),
    value: None,
};

static WORD_PARTI_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_PARTIA_NODE),
    None,
    Some(&WORD_PARTIC_NODE),
    None,
    Some(&WORD_PARTIE_NODE),
    Some(&WORD_PARTIF_NODE),
    None,
    None,
    Some(&WORD_PARTII_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_PARTIO_NODE),
    None,
    None,
    Some(&WORD_PARTIR_NODE),
    Some(&WORD_PARTIS_NODE),
    Some(&WORD_PARTIT_NODE),
    Some(&WORD_PARTIU_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_PARTIZ_NODE),
];

static WORD_PARTIZ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PARTIZ_CHILDREN),
    value: None,
};

pub static WORD_PARTIZ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ipation")],
    values: &[&["participation"]],
    range: 7..=7,
};

static WORD_PARTIU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PARTIU_CHILDREN),
    value: None,
};

pub static WORD_PARTIU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("la"),
        dictgen::InsensitiveStr::Ascii("lar"),
        dictgen::InsensitiveStr::Ascii("larly"),
        dictgen::InsensitiveStr::Ascii("lars"),
    ],
    values: &[
        &["particular"],
        &["particular"],
        &["particularly"],
        &["particulars"],
    ],
    range: 2..=5,
};

static WORD_PARTIT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PARTIT_CHILDREN),
    value: None,
};

pub static WORD_PARTIT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ial"),
        dictgen::InsensitiveStr::Ascii("icipant"),
        dictgen::InsensitiveStr::Ascii("icipants"),
        dictgen::InsensitiveStr::Ascii("icular"),
        dictgen::InsensitiveStr::Ascii("inioning"),
        dictgen::InsensitiveStr::Ascii("ioing"),
        dictgen::InsensitiveStr::Ascii("iones"),
        dictgen::InsensitiveStr::Ascii("ionned"),
        dictgen::InsensitiveStr::Ascii("ionning"),
        dictgen::InsensitiveStr::Ascii("ionns"),
        dictgen::InsensitiveStr::Ascii("ionss"),
        dictgen::InsensitiveStr::Ascii("on"),
        dictgen::InsensitiveStr::Ascii("oned"),
        dictgen::InsensitiveStr::Ascii("oning"),
        dictgen::InsensitiveStr::Ascii("ons"),
    ],
    values: &[
        &["partial"],
        &["participant"],
        &["participants"],
        &["particular"],
        &["partitioning"],
        &["partitioning"],
        &["partitions"],
        &["partitioned"],
        &["partitioning"],
        &["partitions"],
        &["partitions"],
        &["partition"],
        &["partitioned"],
        &["partitioning"],
        &["partitions"],
    ],
    range: 2..=8,
};

static WORD_PARTIS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PARTIS_CHILDREN),
    value: None,
};

pub static WORD_PARTIS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ain"),
        dictgen::InsensitiveStr::Ascii("ion"),
        dictgen::InsensitiveStr::Ascii("ioned"),
        dictgen::InsensitiveStr::Ascii("ioning"),
        dictgen::InsensitiveStr::Ascii("ions"),
    ],
    values: &[
        &["partisan"],
        &["partition"],
        &["partitioned"],
        &["partitioning"],
        &["partitions"],
    ],
    range: 3..=6,
};

static WORD_PARTIR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PARTIR_CHILDREN),
    value: None,
};

pub static WORD_PARTIR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ion"),
        dictgen::InsensitiveStr::Ascii("ioned"),
        dictgen::InsensitiveStr::Ascii("ioning"),
        dictgen::InsensitiveStr::Ascii("ions"),
    ],
    values: &[
        &["partition"],
        &["partitioned"],
        &["partitioning"],
        &["partitions"],
    ],
    range: 3..=6,
};

static WORD_PARTIO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PARTIO_CHILDREN),
    value: None,
};

pub static WORD_PARTIO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("n"),
        dictgen::InsensitiveStr::Ascii("ned"),
        dictgen::InsensitiveStr::Ascii("ning"),
        dictgen::InsensitiveStr::Ascii("ns"),
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("tic"),
        dictgen::InsensitiveStr::Ascii("tism"),
        dictgen::InsensitiveStr::Ascii("ts"),
    ],
    values: &[
        &["partition", "portion"],
        &["partitioned"],
        &["partitioning", "portioning"],
        &["partitions", "portions"],
        &["patriot"],
        &["patriotic"],
        &["patriotism"],
        &["patriots"],
    ],
    range: 1..=4,
};

static WORD_PARTII_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PARTII_CHILDREN),
    value: None,
};

pub static WORD_PARTII_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ton"),
        dictgen::InsensitiveStr::Ascii("toned"),
        dictgen::InsensitiveStr::Ascii("toning"),
        dictgen::InsensitiveStr::Ascii("tons"),
    ],
    values: &[
        &["partition"],
        &["partitioned"],
        &["partitioning"],
        &["partitions"],
    ],
    range: 3..=6,
};

static WORD_PARTIF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PARTIF_CHILDREN),
    value: None,
};

pub static WORD_PARTIF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ular")],
    values: &[&["particular"]],
    range: 4..=4,
};

static WORD_PARTIE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PARTIE_CHILDREN),
    value: None,
};

pub static WORD_PARTIE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("l"),
        dictgen::InsensitiveStr::Ascii("ts"),
    ],
    values: &[&["particle"], &["parties"]],
    range: 1..=2,
};

static WORD_PARTIC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_PARTIC_CHILDREN),
    value: None,
};

static WORD_PARTIC_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_PARTICA_NODE),
    None,
    None,
    None,
    Some(&WORD_PARTICE_NODE),
    None,
    None,
    None,
    Some(&WORD_PARTICI_NODE),
    None,
    Some(&WORD_PARTICK_NODE),
    Some(&WORD_PARTICL_NODE),
    None,
    None,
    None,
    Some(&WORD_PARTICP_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_PARTICU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_PARTICU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PARTICU_CHILDREN),
    value: None,
};

pub static WORD_PARTICU_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("ally"),
            dictgen::InsensitiveStr::Ascii("alr"),
            dictgen::InsensitiveStr::Ascii("alrly"),
            dictgen::InsensitiveStr::Ascii("ar"),
            dictgen::InsensitiveStr::Ascii("arly"),
            dictgen::InsensitiveStr::Ascii("lalry"),
            dictgen::InsensitiveStr::Ascii("laly"),
            dictgen::InsensitiveStr::Ascii("larely"),
            dictgen::InsensitiveStr::Ascii("larily"),
            dictgen::InsensitiveStr::Ascii("larlly"),
            dictgen::InsensitiveStr::Ascii("lary"),
            dictgen::InsensitiveStr::Ascii("liar"),
            dictgen::InsensitiveStr::Ascii("llary"),
            dictgen::InsensitiveStr::Ascii("raly"),
        ],
        values: &[
            &["particularly"],
            &["particular"],
            &["particularly"],
            &["particular"],
            &["particularly"],
            &["particularly"],
            &["particularly"],
            &["particularly"],
            &["particularly"],
            &["particularly"],
            &["particularly"],
            &["particular"],
            &["particularly"],
            &["particularly"],
        ],
        range: 2..=6,
    };

static WORD_PARTICP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PARTICP_CHILDREN),
    value: None,
};

pub static WORD_PARTICP_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("ate"),
            dictgen::InsensitiveStr::Ascii("iate"),
        ],
        values: &[&["participate"], &["participated"]],
        range: 3..=4,
    };

static WORD_PARTICL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PARTICL_CHILDREN),
    value: None,
};

pub static WORD_PARTICL_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("ar"),
            dictgen::InsensitiveStr::Ascii("ars"),
        ],
        values: &[&["particular"], &["particulars"]],
        range: 2..=3,
    };

static WORD_PARTICK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PARTICK_CHILDREN),
    value: Some(&["patrick"]),
};

pub static WORD_PARTICK_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[],
        values: &[],
        range: 0..=0,
    };

static WORD_PARTICI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PARTICI_CHILDREN),
    value: None,
};

pub static WORD_PARTICI_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("apnts"),
            dictgen::InsensitiveStr::Ascii("apte"),
            dictgen::InsensitiveStr::Ascii("apted"),
            dictgen::InsensitiveStr::Ascii("aption"),
            dictgen::InsensitiveStr::Ascii("pacion"),
            dictgen::InsensitiveStr::Ascii("pait"),
            dictgen::InsensitiveStr::Ascii("pans"),
            dictgen::InsensitiveStr::Ascii("pante"),
            dictgen::InsensitiveStr::Ascii("pantes"),
            dictgen::InsensitiveStr::Ascii("pare"),
            dictgen::InsensitiveStr::Ascii("pas"),
            dictgen::InsensitiveStr::Ascii("paste"),
            dictgen::InsensitiveStr::Ascii("pat"),
            dictgen::InsensitiveStr::Ascii("patd"),
            dictgen::InsensitiveStr::Ascii("pati"),
            dictgen::InsensitiveStr::Ascii("patie"),
            dictgen::InsensitiveStr::Ascii("patin"),
            dictgen::InsensitiveStr::Ascii("pativo"),
            dictgen::InsensitiveStr::Ascii("patns"),
            dictgen::InsensitiveStr::Ascii("paton"),
            dictgen::InsensitiveStr::Ascii("pats"),
            dictgen::InsensitiveStr::Ascii("pe"),
            dictgen::InsensitiveStr::Ascii("pent"),
            dictgen::InsensitiveStr::Ascii("pents"),
            dictgen::InsensitiveStr::Ascii("pte"),
        ],
        values: &[
            &["participant"],
            &["participate"],
            &["participated"],
            &["participation"],
            &["participation"],
            &["participant"],
            &["participants"],
            &["participate"],
            &["participants"],
            &["participate"],
            &["participants"],
            &["participants"],
            &["participants"],
            &["participant"],
            &["participant"],
            &["participated"],
            &["participation"],
            &["participation"],
            &["participant"],
            &["participant"],
            &["participant"],
            &["participate"],
            &["participant"],
            &["participants"],
            &["participate"],
        ],
        range: 2..=6,
    };

static WORD_PARTICE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PARTICE_CHILDREN),
    value: Some(&["particle"]),
};

pub static WORD_PARTICE_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[dictgen::InsensitiveStr::Ascii("l")],
        values: &[&["particle"]],
        range: 1..=1,
    };

static WORD_PARTICA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PARTICA_CHILDREN),
    value: None,
};

pub static WORD_PARTICA_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("l"),
            dictgen::InsensitiveStr::Ascii("lar"),
            dictgen::InsensitiveStr::Ascii("larly"),
            dictgen::InsensitiveStr::Ascii("le"),
            dictgen::InsensitiveStr::Ascii("les"),
            dictgen::InsensitiveStr::Ascii("lly"),
            dictgen::InsensitiveStr::Ascii("ls"),
            dictgen::InsensitiveStr::Ascii("luar"),
            dictgen::InsensitiveStr::Ascii("luarly"),
            dictgen::InsensitiveStr::Ascii("lur"),
            dictgen::InsensitiveStr::Ascii("lurly"),
            dictgen::InsensitiveStr::Ascii("nt"),
            dictgen::InsensitiveStr::Ascii("pate"),
            dictgen::InsensitiveStr::Ascii("pated"),
            dictgen::InsensitiveStr::Ascii("ular"),
            dictgen::InsensitiveStr::Ascii("ularly"),
            dictgen::InsensitiveStr::Ascii("ulr"),
            dictgen::InsensitiveStr::Ascii("ulrly"),
        ],
        values: &[
            &["particular", "partial", "particle"],
            &["particular"],
            &["particularly"],
            &["particle"],
            &["particles"],
            &["partially"],
            &["particles"],
            &["particular"],
            &["particularly"],
            &["particular"],
            &["particularly"],
            &["participant"],
            &["participate"],
            &["participated"],
            &["particular"],
            &["particularly"],
            &["particular"],
            &["particularly"],
        ],
        range: 1..=6,
    };

static WORD_PARTIA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PARTIA_CHILDREN),
    value: None,
};

pub static WORD_PARTIA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ly"),
        dictgen::InsensitiveStr::Ascii("ns"),
        dictgen::InsensitiveStr::Ascii("rchal"),
        dictgen::InsensitiveStr::Ascii("rchy"),
    ],
    values: &[
        &["partially"],
        &["partisan"],
        &["patriarchal"],
        &["patriarchy"],
    ],
    range: 2..=5,
};

static WORD_PARTH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PARTH_CHILDREN),
    value: Some(&["path"]),
};

pub static WORD_PARTH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[],
    values: &[],
    range: 0..=0,
};

static WORD_PARTE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PARTE_CHILDREN),
    value: None,
};

pub static WORD_PARTE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cipant"),
        dictgen::InsensitiveStr::Ascii("cipants"),
        dictgen::InsensitiveStr::Ascii("cipate"),
        dictgen::InsensitiveStr::Ascii("cipated"),
        dictgen::InsensitiveStr::Ascii("rned"),
        dictgen::InsensitiveStr::Ascii("rns"),
        dictgen::InsensitiveStr::Ascii("rnship"),
        dictgen::InsensitiveStr::Ascii("rnships"),
    ],
    values: &[
        &["participant"],
        &["participants"],
        &["participate"],
        &["participated"],
        &["partnered"],
        &["partners"],
        &["partnership"],
        &["partnership"],
    ],
    range: 3..=7,
};

static WORD_PARTC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PARTC_CHILDREN),
    value: None,
};

pub static WORD_PARTC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("hett"),
        dictgen::InsensitiveStr::Ascii("ular"),
        dictgen::InsensitiveStr::Ascii("ularity"),
        dictgen::InsensitiveStr::Ascii("ularly"),
    ],
    values: &[
        &["pratchett"],
        &["particular"],
        &["particularity"],
        &["particularly"],
    ],
    range: 4..=7,
};

static WORD_PARTA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PARTA_CHILDREN),
    value: None,
};

pub static WORD_PARTA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ining")],
    values: &[&["pertaining"]],
    range: 5..=5,
};

static WORD_PARS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PARS_CHILDREN),
    value: None,
};

pub static WORD_PARS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ef"),
        dictgen::InsensitiveStr::Ascii("eing"),
        dictgen::InsensitiveStr::Ascii("ering"),
        dictgen::InsensitiveStr::Ascii("hal"),
        dictgen::InsensitiveStr::Ascii("hally"),
        dictgen::InsensitiveStr::Ascii("haly"),
        dictgen::InsensitiveStr::Ascii("ial"),
        dictgen::InsensitiveStr::Ascii("ially"),
        dictgen::InsensitiveStr::Ascii("ialy"),
        dictgen::InsensitiveStr::Ascii("in"),
    ],
    values: &[
        &["parsec", "parsed", "parser"],
        &["parsing"],
        &["parsing"],
        &["marshal", "partial"],
        &["partially"],
        &["partially"],
        &["partial"],
        &["partially"],
        &["partially"],
        &["parsing"],
    ],
    range: 2..=5,
};

static WORD_PARR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PARR_CHILDREN),
    value: None,
};

pub static WORD_PARR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("alel"),
        dictgen::InsensitiveStr::Ascii("alell"),
        dictgen::InsensitiveStr::Ascii("alelly"),
        dictgen::InsensitiveStr::Ascii("alely"),
        dictgen::InsensitiveStr::Ascii("allel"),
        dictgen::InsensitiveStr::Ascii("allell"),
        dictgen::InsensitiveStr::Ascii("allelly"),
        dictgen::InsensitiveStr::Ascii("allely"),
        dictgen::InsensitiveStr::Ascii("ent"),
    ],
    values: &[
        &["parallel"],
        &["parallel"],
        &["parallelly"],
        &["parallelly"],
        &["parallel"],
        &["parallel"],
        &["parallelly"],
        &["parallelly"],
        &["parent"],
    ],
    range: 3..=7,
};

static WORD_PARO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PARO_CHILDREN),
    value: None,
};

pub static WORD_PARO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cheal"),
        dictgen::InsensitiveStr::Ascii("cheality"),
        dictgen::InsensitiveStr::Ascii("cheally"),
        dictgen::InsensitiveStr::Ascii("cheel"),
        dictgen::InsensitiveStr::Ascii("cheelity"),
        dictgen::InsensitiveStr::Ascii("cheelly"),
        dictgen::InsensitiveStr::Ascii("keal"),
        dictgen::InsensitiveStr::Ascii("keality"),
        dictgen::InsensitiveStr::Ascii("keally"),
        dictgen::InsensitiveStr::Ascii("keel"),
        dictgen::InsensitiveStr::Ascii("keelity"),
        dictgen::InsensitiveStr::Ascii("keelly"),
    ],
    values: &[
        &["parochial"],
        &["parochiality"],
        &["parochially"],
        &["parochial"],
        &["parochiality"],
        &["parochially"],
        &["parochial"],
        &["parochiality"],
        &["parochially"],
        &["parochial"],
        &["parochiality"],
        &["parochially"],
    ],
    range: 4..=8,
};

static WORD_PARN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PARN_CHILDREN),
    value: None,
};

pub static WORD_PARN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("oia"),
        dictgen::InsensitiveStr::Ascii("ter"),
        dictgen::InsensitiveStr::Ascii("tered"),
        dictgen::InsensitiveStr::Ascii("tering"),
        dictgen::InsensitiveStr::Ascii("ters"),
        dictgen::InsensitiveStr::Ascii("tership"),
        dictgen::InsensitiveStr::Ascii("terships"),
    ],
    values: &[
        &["paranoia"],
        &["partner"],
        &["partnered"],
        &["partnering"],
        &["partners"],
        &["partnership"],
        &["partnerships"],
    ],
    range: 3..=8,
};

static WORD_PARM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PARM_CHILDREN),
    value: Some(&["param", "pram", "parma"]),
};

pub static WORD_PARM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aeter"),
        dictgen::InsensitiveStr::Ascii("aeters"),
        dictgen::InsensitiveStr::Ascii("ameter"),
        dictgen::InsensitiveStr::Ascii("ameters"),
        dictgen::InsensitiveStr::Ascii("asen"),
        dictgen::InsensitiveStr::Ascii("aters"),
        dictgen::InsensitiveStr::Ascii("enas"),
        dictgen::InsensitiveStr::Ascii("esaen"),
        dictgen::InsensitiveStr::Ascii("esian"),
        dictgen::InsensitiveStr::Ascii("eter"),
        dictgen::InsensitiveStr::Ascii("eters"),
        dictgen::InsensitiveStr::Ascii("etian"),
        dictgen::InsensitiveStr::Ascii("isan"),
        dictgen::InsensitiveStr::Ascii("isian"),
        dictgen::InsensitiveStr::Ascii("s"),
        dictgen::InsensitiveStr::Ascii("sean"),
        dictgen::InsensitiveStr::Ascii("ter"),
        dictgen::InsensitiveStr::Ascii("ters"),
    ],
    values: &[
        &["parameter"],
        &["parameters"],
        &["parameter"],
        &["parameters"],
        &["parmesan"],
        &["parameters"],
        &["parmesan"],
        &["parmesan"],
        &["parmesan"],
        &["parameter"],
        &["parameters"],
        &["parmesan"],
        &["parmesan"],
        &["parmesan"],
        &["params", "prams"],
        &["parmesan"],
        &["parameter"],
        &["parameters"],
    ],
    range: 1..=7,
};

static WORD_PARL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PARL_CHILDREN),
    value: None,
};

pub static WORD_PARL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aiment"),
        dictgen::InsensitiveStr::Ascii("aimentary"),
        dictgen::InsensitiveStr::Ascii("ament"),
        dictgen::InsensitiveStr::Ascii("amentary"),
        dictgen::InsensitiveStr::Ascii("aments"),
        dictgen::InsensitiveStr::Ascii("iamant"),
        dictgen::InsensitiveStr::Ascii("iamantary"),
        dictgen::InsensitiveStr::Ascii("iamentery"),
        dictgen::InsensitiveStr::Ascii("iamentiary"),
        dictgen::InsensitiveStr::Ascii("iamentry"),
        dictgen::InsensitiveStr::Ascii("iamenty"),
        dictgen::InsensitiveStr::Ascii("iamnetary"),
        dictgen::InsensitiveStr::Ascii("iamone"),
        dictgen::InsensitiveStr::Ascii("iement"),
        dictgen::InsensitiveStr::Ascii("iementary"),
        dictgen::InsensitiveStr::Ascii("iment"),
        dictgen::InsensitiveStr::Ascii("imentary"),
        dictgen::InsensitiveStr::Ascii("iments"),
    ],
    values: &[
        &["parliament"],
        &["parliamentary"],
        &["parliament"],
        &["parliamentary"],
        &["parliaments"],
        &["parliament"],
        &["parliamentary"],
        &["parliamentary"],
        &["parliamentary"],
        &["parliamentary"],
        &["parliamentary"],
        &["parliamentary"],
        &["parliament"],
        &["parliament"],
        &["parliamentary"],
        &["parliament"],
        &["parliamentary"],
        &["parliaments"],
    ],
    range: 5..=10,
};

static WORD_PARK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PARK_CHILDREN),
    value: None,
};

pub static WORD_PARK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ay"),
        dictgen::InsensitiveStr::Ascii("ays"),
    ],
    values: &[
        &["parkway", "parlay", "parquet"],
        &["parkways", "parlays", "parquets"],
    ],
    range: 2..=3,
};

static WORD_PARI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PARI_CHILDREN),
    value: None,
};

pub static WORD_PARI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("a"),
        dictgen::InsensitiveStr::Ascii("al"),
        dictgen::InsensitiveStr::Ascii("ally"),
        dictgen::InsensitiveStr::Ascii("as"),
        dictgen::InsensitiveStr::Ascii("cular"),
        dictgen::InsensitiveStr::Ascii("cularly"),
        dictgen::InsensitiveStr::Ascii("lament"),
        dictgen::InsensitiveStr::Ascii("lamentary"),
        dictgen::InsensitiveStr::Ascii("ses"),
        dictgen::InsensitiveStr::Ascii("sitic"),
        dictgen::InsensitiveStr::Ascii("stan"),
        dictgen::InsensitiveStr::Ascii("tal"),
        dictgen::InsensitiveStr::Ascii("tally"),
        dictgen::InsensitiveStr::Ascii("tals"),
        dictgen::InsensitiveStr::Ascii("tes"),
        dictgen::InsensitiveStr::Ascii("tial"),
        dictgen::InsensitiveStr::Ascii("tion"),
        dictgen::InsensitiveStr::Ascii("tioning"),
        dictgen::InsensitiveStr::Ascii("tions"),
        dictgen::InsensitiveStr::Ascii("tition"),
        dictgen::InsensitiveStr::Ascii("titioned"),
        dictgen::InsensitiveStr::Ascii("titioner"),
        dictgen::InsensitiveStr::Ascii("titiones"),
        dictgen::InsensitiveStr::Ascii("titioning"),
        dictgen::InsensitiveStr::Ascii("titions"),
        dictgen::InsensitiveStr::Ascii("tiy"),
        dictgen::InsensitiveStr::Ascii("tuclar"),
    ],
    values: &[
        &["pariah", "parka"],
        &["partial"],
        &["partially"],
        &["pariahs", "parkas"],
        &["particular"],
        &["particularly"],
        &["parliament"],
        &["parliamentary"],
        &["praises"],
        &["parasitic"],
        &["partisan"],
        &["parietal", "partial"],
        &["partially"],
        &["partials"],
        &["parties"],
        &["partial"],
        &["partition"],
        &["partitioning"],
        &["partitions"],
        &["partition"],
        &["partitioned"],
        &["partitioner"],
        &["partitions"],
        &["partitioning"],
        &["partitions"],
        &["parity"],
        &["particular"],
    ],
    range: 1..=9,
};

static WORD_PARG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PARG_CHILDREN),
    value: None,
};

pub static WORD_PARG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("e")],
    values: &[&["large"]],
    range: 1..=1,
};

static WORD_PARF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PARF_CHILDREN),
    value: None,
};

pub static WORD_PARF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ay")],
    values: &[&["parfait"]],
    range: 2..=2,
};

static WORD_PARE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PARE_CHILDREN),
    value: None,
};

pub static WORD_PARE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("llel"),
        dictgen::InsensitiveStr::Ascii("llelogram"),
        dictgen::InsensitiveStr::Ascii("llels"),
        dictgen::InsensitiveStr::Ascii("m"),
        dictgen::InsensitiveStr::Ascii("meter"),
        dictgen::InsensitiveStr::Ascii("meters"),
        dictgen::InsensitiveStr::Ascii("msan"),
        dictgen::InsensitiveStr::Ascii("mter"),
        dictgen::InsensitiveStr::Ascii("mters"),
        dictgen::InsensitiveStr::Ascii("ntesis"),
        dictgen::InsensitiveStr::Ascii("nthasis"),
        dictgen::InsensitiveStr::Ascii("ntheesis"),
        dictgen::InsensitiveStr::Ascii("nthese"),
        dictgen::InsensitiveStr::Ascii("nthesed"),
        dictgen::InsensitiveStr::Ascii("nthesees"),
        dictgen::InsensitiveStr::Ascii("nthesies"),
        dictgen::InsensitiveStr::Ascii("nthesys"),
        dictgen::InsensitiveStr::Ascii("nthises"),
        dictgen::InsensitiveStr::Ascii("nthisis"),
        dictgen::InsensitiveStr::Ascii("nthsis"),
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("theses"),
    ],
    values: &[
        &["parallel"],
        &["parallelogram"],
        &["parallels"],
        &["param"],
        &["parameter"],
        &["parameters"],
        &["parmesan"],
        &["parameter"],
        &["parameters"],
        &["parentheses", "parenthesis"],
        &["parenthesis"],
        &["parenthesis"],
        &["parentheses"],
        &["parenthesized"],
        &["parentheses"],
        &["parenthesis", "parentheses"],
        &["parentheses"],
        &["parenthesis", "parentheses"],
        &["parenthesis"],
        &["parenthesis"],
        &["parent", "parrot"],
        &["parentheses"],
    ],
    range: 1..=9,
};

static WORD_PARD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PARD_CHILDREN),
    value: Some(&["part"]),
};

pub static WORD_PARD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[],
    values: &[],
    range: 0..=0,
};

static WORD_PARC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PARC_CHILDREN),
    value: None,
};

pub static WORD_PARC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("tical"),
        dictgen::InsensitiveStr::Ascii("tically"),
        dictgen::InsensitiveStr::Ascii("tise"),
    ],
    values: &[&["practical"], &["practically"], &["practise"]],
    range: 4..=7,
};

static WORD_PARA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_PARA_CHILDREN),
    value: None,
};

static WORD_PARA_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    Some(&WORD_PARAC_NODE),
    Some(&WORD_PARAD_NODE),
    Some(&WORD_PARAE_NODE),
    Some(&WORD_PARAF_NODE),
    Some(&WORD_PARAG_NODE),
    Some(&WORD_PARAH_NODE),
    Some(&WORD_PARAI_NODE),
    None,
    None,
    Some(&WORD_PARAL_NODE),
    Some(&WORD_PARAM_NODE),
    Some(&WORD_PARAN_NODE),
    None,
    Some(&WORD_PARAP_NODE),
    None,
    Some(&WORD_PARAR_NODE),
    Some(&WORD_PARAS_NODE),
    Some(&WORD_PARAT_NODE),
    None,
    Some(&WORD_PARAV_NODE),
    None,
    None,
    Some(&WORD_PARAY_NODE),
    None,
];

static WORD_PARAY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PARAY_CHILDREN),
    value: None,
};

pub static WORD_PARAY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("lsis"),
        dictgen::InsensitiveStr::Ascii("lzed"),
    ],
    values: &[&["paralysis"], &["paralyzed"]],
    range: 4..=4,
};

static WORD_PARAV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PARAV_CHILDREN),
    value: None,
};

pub static WORD_PARAV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("irtualiation"),
        dictgen::InsensitiveStr::Ascii("irtualied"),
        dictgen::InsensitiveStr::Ascii("irutalisation"),
        dictgen::InsensitiveStr::Ascii("irutalise"),
        dictgen::InsensitiveStr::Ascii("irutalised"),
        dictgen::InsensitiveStr::Ascii("irutalization"),
        dictgen::InsensitiveStr::Ascii("irutalize"),
        dictgen::InsensitiveStr::Ascii("irutalized"),
    ],
    values: &[
        &["paravirtualisation", "paravirtualization"],
        &["paravirtualised", "paravirtualized"],
        &["paravirtualisation"],
        &["paravirtualise"],
        &["paravirtualised"],
        &["paravirtualization"],
        &["paravirtualize"],
        &["paravirtualized"],
    ],
    range: 9..=13,
};

static WORD_PARAT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PARAT_CHILDREN),
    value: None,
};

pub static WORD_PARAT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("heses"),
        dictgen::InsensitiveStr::Ascii("mers"),
    ],
    values: &[&["parentheses"], &["parameters"]],
    range: 4..=5,
};

static WORD_PARAS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PARAS_CHILDREN),
    value: None,
};

pub static WORD_PARAS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("er"),
        dictgen::InsensitiveStr::Ascii("ide"),
        dictgen::InsensitiveStr::Ascii("itisme"),
        dictgen::InsensitiveStr::Ascii("its"),
        dictgen::InsensitiveStr::Ascii("itter"),
        dictgen::InsensitiveStr::Ascii("tic"),
        dictgen::InsensitiveStr::Ascii("tics"),
        dictgen::InsensitiveStr::Ascii("tie"),
        dictgen::InsensitiveStr::Ascii("ties"),
    ],
    values: &[
        &["parser"],
        &["paradise"],
        &["parasites"],
        &["parasites"],
        &["parasite"],
        &["parasitic"],
        &["parasitics"],
        &["parasite"],
        &["parasites"],
    ],
    range: 2..=6,
};

static WORD_PARAR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PARAR_CHILDREN),
    value: None,
};

pub static WORD_PARAR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("agraph"),
        dictgen::InsensitiveStr::Ascii("aph"),
        dictgen::InsensitiveStr::Ascii("eter"),
        dictgen::InsensitiveStr::Ascii("gaph"),
        dictgen::InsensitiveStr::Ascii("gaphs"),
        dictgen::InsensitiveStr::Ascii("m"),
        dictgen::InsensitiveStr::Ascii("meter"),
        dictgen::InsensitiveStr::Ascii("meters"),
    ],
    values: &[
        &["paragraph"],
        &["paragraph"],
        &["parameter"],
        &["paragraph"],
        &["paragraphs"],
        &["param"],
        &["parameter"],
        &["parameters"],
    ],
    range: 1..=6,
};

static WORD_PARAP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PARAP_CHILDREN),
    value: None,
};

pub static WORD_PARAP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("hanalia"),
        dictgen::InsensitiveStr::Ascii("harse"),
        dictgen::InsensitiveStr::Ascii("harsed"),
        dictgen::InsensitiveStr::Ascii("harsing"),
        dictgen::InsensitiveStr::Ascii("henalia"),
        dictgen::InsensitiveStr::Ascii("hraseing"),
        dictgen::InsensitiveStr::Ascii("hrashed"),
        dictgen::InsensitiveStr::Ascii("hrashing"),
        dictgen::InsensitiveStr::Ascii("hraze"),
        dictgen::InsensitiveStr::Ascii("hrazing"),
        dictgen::InsensitiveStr::Ascii("rashing"),
        dictgen::InsensitiveStr::Ascii("rhase"),
        dictgen::InsensitiveStr::Ascii("rhased"),
        dictgen::InsensitiveStr::Ascii("rhasing"),
    ],
    values: &[
        &["paraphernalia"],
        &["paraphrase"],
        &["paraphrase"],
        &["paraphrasing"],
        &["paraphernalia"],
        &["paraphrasing"],
        &["paraphrase"],
        &["paraphrasing"],
        &["paraphrase"],
        &["paraphrasing"],
        &["paraphrasing"],
        &["paraphrase"],
        &["paraphrase"],
        &["paraphrasing"],
    ],
    range: 5..=8,
};

static WORD_PARAN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PARAN_CHILDREN),
    value: None,
};

pub static WORD_PARAN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("a"),
        dictgen::InsensitiveStr::Ascii("iac"),
        dictgen::InsensitiveStr::Ascii("ioa"),
        dictgen::InsensitiveStr::Ascii("iod"),
        dictgen::InsensitiveStr::Ascii("oa"),
        dictgen::InsensitiveStr::Ascii("oica"),
        dictgen::InsensitiveStr::Ascii("oicas"),
        dictgen::InsensitiveStr::Ascii("oida"),
        dictgen::InsensitiveStr::Ascii("omral"),
        dictgen::InsensitiveStr::Ascii("ornal"),
        dictgen::InsensitiveStr::Ascii("oya"),
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("thes"),
        dictgen::InsensitiveStr::Ascii("theses"),
        dictgen::InsensitiveStr::Ascii("thesis"),
        dictgen::InsensitiveStr::Ascii("ts"),
    ],
    values: &[
        &["piranha"],
        &["paranoiac"],
        &["paranoia"],
        &["paranoid"],
        &["paranoia"],
        &["paranoia"],
        &["paranoia"],
        &["paranoia"],
        &["paranormal"],
        &["paranormal"],
        &["paranoia"],
        &["parent"],
        &["parentheses", "parenthesis"],
        &["parentheses"],
        &["parenthesis"],
        &["parents"],
    ],
    range: 1..=6,
};

static WORD_PARAM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PARAM_CHILDREN),
    value: None,
};

pub static WORD_PARAM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("adics"),
        dictgen::InsensitiveStr::Ascii("ameter"),
        dictgen::InsensitiveStr::Ascii("ameters"),
        dictgen::InsensitiveStr::Ascii("ater"),
        dictgen::InsensitiveStr::Ascii("aters"),
        dictgen::InsensitiveStr::Ascii("ecias"),
        dictgen::InsensitiveStr::Ascii("edicks"),
        dictgen::InsensitiveStr::Ascii("edicos"),
        dictgen::InsensitiveStr::Ascii("edis"),
        dictgen::InsensitiveStr::Ascii("eds"),
        dictgen::InsensitiveStr::Ascii("eger"),
        dictgen::InsensitiveStr::Ascii("emeter"),
        dictgen::InsensitiveStr::Ascii("emeters"),
        dictgen::InsensitiveStr::Ascii("emter"),
        dictgen::InsensitiveStr::Ascii("emters"),
        dictgen::InsensitiveStr::Ascii("enet"),
        dictgen::InsensitiveStr::Ascii("enets"),
        dictgen::InsensitiveStr::Ascii("enter"),
        dictgen::InsensitiveStr::Ascii("enters"),
        dictgen::InsensitiveStr::Ascii("er"),
        dictgen::InsensitiveStr::Ascii("ert"),
        dictgen::InsensitiveStr::Ascii("erters"),
        dictgen::InsensitiveStr::Ascii("erts"),
        dictgen::InsensitiveStr::Ascii("ete"),
        dictgen::InsensitiveStr::Ascii("eteras"),
        dictgen::InsensitiveStr::Ascii("etere"),
        dictgen::InsensitiveStr::Ascii("eteres"),
        dictgen::InsensitiveStr::Ascii("eterical"),
        dictgen::InsensitiveStr::Ascii("eterr"),
        dictgen::InsensitiveStr::Ascii("eterts"),
        dictgen::InsensitiveStr::Ascii("etes"),
        dictgen::InsensitiveStr::Ascii("etic"),
        dictgen::InsensitiveStr::Ascii("etics"),
        dictgen::InsensitiveStr::Ascii("etised"),
        dictgen::InsensitiveStr::Ascii("etr"),
        dictgen::InsensitiveStr::Ascii("etre"),
        dictgen::InsensitiveStr::Ascii("etreless"),
        dictgen::InsensitiveStr::Ascii("etres"),
        dictgen::InsensitiveStr::Ascii("etros"),
        dictgen::InsensitiveStr::Ascii("etrs"),
        dictgen::InsensitiveStr::Ascii("etter"),
        dictgen::InsensitiveStr::Ascii("etters"),
        dictgen::InsensitiveStr::Ascii("iters"),
        dictgen::InsensitiveStr::Ascii("ormal"),
        dictgen::InsensitiveStr::Ascii("ss"),
        dictgen::InsensitiveStr::Ascii("ter"),
        dictgen::InsensitiveStr::Ascii("terer"),
        dictgen::InsensitiveStr::Ascii("terers"),
        dictgen::InsensitiveStr::Ascii("teres"),
        dictgen::InsensitiveStr::Ascii("terical"),
        dictgen::InsensitiveStr::Ascii("terisation"),
        dictgen::InsensitiveStr::Ascii("terise"),
        dictgen::InsensitiveStr::Ascii("terised"),
        dictgen::InsensitiveStr::Ascii("terises"),
        dictgen::InsensitiveStr::Ascii("terising"),
        dictgen::InsensitiveStr::Ascii("terization"),
        dictgen::InsensitiveStr::Ascii("terize"),
        dictgen::InsensitiveStr::Ascii("terized"),
        dictgen::InsensitiveStr::Ascii("terizes"),
        dictgen::InsensitiveStr::Ascii("terizing"),
        dictgen::InsensitiveStr::Ascii("terless"),
        dictgen::InsensitiveStr::Ascii("ters"),
        dictgen::InsensitiveStr::Ascii("trical"),
    ],
    values: &[
        &["paramedics"],
        &["parameter"],
        &["parameters"],
        &["parameter"],
        &["parameters"],
        &["paramedics"],
        &["paramedics"],
        &["paramedics"],
        &["paramedics"],
        &["paramedics"],
        &["parameter"],
        &["parameter"],
        &["parameters"],
        &["parameter"],
        &["parameters"],
        &["parameter"],
        &["parameters"],
        &["parameter"],
        &["parameters"],
        &["parameter"],
        &["parameter"],
        &["parameters"],
        &["parameters"],
        &["parameter"],
        &["parameters"],
        &["parameter", "parameters"],
        &["parameters"],
        &["parametrical"],
        &["parameter"],
        &["parameters"],
        &["parameters"],
        &["parametric", "paramedic"],
        &["paramedics"],
        &["parametrised"],
        &["parameter"],
        &["parameter"],
        &["parameterless"],
        &["parameters"],
        &["parameters"],
        &["parameters"],
        &["parameter"],
        &["parameters"],
        &["parameters"],
        &["paranormal"],
        &["params"],
        &["parameter"],
        &["parameter"],
        &["parameters"],
        &["parameters"],
        &["parametric", "parametrically"],
        &["parameterisation"],
        &["parameterise"],
        &["parameterised"],
        &["parameterises"],
        &["parameterising"],
        &["parametrization", "parameterization"],
        &["parameterize"],
        &["parameterized"],
        &["parameterizes"],
        &["parameterizing"],
        &["parameterless"],
        &["parameters"],
        &["parametrical"],
    ],
    range: 2..=10,
};

static WORD_PARAL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PARAL_CHILDREN),
    value: None,
};

pub static WORD_PARAL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("el"),
        dictgen::InsensitiveStr::Ascii("elising"),
        dictgen::InsensitiveStr::Ascii("elism"),
        dictgen::InsensitiveStr::Ascii("elizing"),
        dictgen::InsensitiveStr::Ascii("ell"),
        dictgen::InsensitiveStr::Ascii("elle"),
        dictgen::InsensitiveStr::Ascii("ellism"),
        dictgen::InsensitiveStr::Ascii("ellization"),
        dictgen::InsensitiveStr::Ascii("ells"),
        dictgen::InsensitiveStr::Ascii("elly"),
        dictgen::InsensitiveStr::Ascii("ely"),
        dictgen::InsensitiveStr::Ascii("isys"),
        dictgen::InsensitiveStr::Ascii("le"),
        dictgen::InsensitiveStr::Ascii("leles"),
        dictgen::InsensitiveStr::Ascii("lell"),
        dictgen::InsensitiveStr::Ascii("lells"),
        dictgen::InsensitiveStr::Ascii("lely"),
        dictgen::InsensitiveStr::Ascii("les"),
        dictgen::InsensitiveStr::Ascii("lization"),
        dictgen::InsensitiveStr::Ascii("lize"),
        dictgen::InsensitiveStr::Ascii("lized"),
        dictgen::InsensitiveStr::Ascii("lizes"),
        dictgen::InsensitiveStr::Ascii("lizing"),
        dictgen::InsensitiveStr::Ascii("llel"),
        dictgen::InsensitiveStr::Ascii("llels"),
        dictgen::InsensitiveStr::Ascii("zyed"),
    ],
    values: &[
        &["parallel"],
        &["parallelising"],
        &["parallelism"],
        &["parallelizing"],
        &["parallel"],
        &["parallel"],
        &["parallelism"],
        &["parallelization"],
        &["parallels"],
        &["parallelly"],
        &["parallelly"],
        &["paralysis"],
        &["parallel"],
        &["parallels"],
        &["parallel"],
        &["parallels"],
        &["parallelly"],
        &["parallels"],
        &["parallelization"],
        &["parallelize"],
        &["parallelized"],
        &["parallelizes"],
        &["parallelizing"],
        &["parallel"],
        &["parallels"],
        &["paralyzed"],
    ],
    range: 2..=10,
};

static WORD_PARAI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PARAI_CHILDREN),
    value: None,
};

pub static WORD_PARAI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ste")],
    values: &[&["parasite"]],
    range: 3..=3,
};

static WORD_PARAH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PARAH_CHILDREN),
    value: None,
};

pub static WORD_PARAH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aps"),
        dictgen::InsensitiveStr::Ascii("prase"),
    ],
    values: &[&["perhaps"], &["paraphrase"]],
    range: 3..=5,
};

static WORD_PARAG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PARAG_CHILDREN),
    value: None,
};

pub static WORD_PARAG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aph"),
        dictgen::InsensitiveStr::Ascii("araph"),
        dictgen::InsensitiveStr::Ascii("arapha"),
        dictgen::InsensitiveStr::Ascii("arph"),
        dictgen::InsensitiveStr::Ascii("arphs"),
        dictgen::InsensitiveStr::Ascii("ph"),
        dictgen::InsensitiveStr::Ascii("praph"),
        dictgen::InsensitiveStr::Ascii("raghs"),
        dictgen::InsensitiveStr::Ascii("rah"),
        dictgen::InsensitiveStr::Ascii("rahps"),
        dictgen::InsensitiveStr::Ascii("rahs"),
        dictgen::InsensitiveStr::Ascii("rapgh"),
        dictgen::InsensitiveStr::Ascii("raphes"),
        dictgen::InsensitiveStr::Ascii("raphy"),
        dictgen::InsensitiveStr::Ascii("raps"),
        dictgen::InsensitiveStr::Ascii("rpah"),
        dictgen::InsensitiveStr::Ascii("rpahs"),
        dictgen::InsensitiveStr::Ascii("rphs"),
    ],
    values: &[
        &["paragraph"],
        &["paragraph"],
        &["paragraph"],
        &["paragraph"],
        &["paragraphs"],
        &["paragraph"],
        &["paragraph"],
        &["paragraphs"],
        &["paragraph"],
        &["paragraphs"],
        &["paragraphs"],
        &["paragraphs"],
        &["paragraphs"],
        &["paragraph"],
        &["paragraphs"],
        &["paragraph"],
        &["paragraphs"],
        &["paragraphs"],
    ],
    range: 2..=6,
};

static WORD_PARAF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PARAF_CHILDREN),
    value: None,
};

pub static WORD_PARAF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("analia")],
    values: &[&["paraphernalia"]],
    range: 6..=6,
};

static WORD_PARAE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PARAE_CHILDREN),
    value: None,
};

pub static WORD_PARAE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("meter"),
        dictgen::InsensitiveStr::Ascii("meters"),
        dictgen::InsensitiveStr::Ascii("ters"),
    ],
    values: &[&["parameter"], &["parameters"], &["parameters"]],
    range: 4..=6,
};

static WORD_PARAD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PARAD_CHILDREN),
    value: None,
};

pub static WORD_PARAD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("emics"),
        dictgen::InsensitiveStr::Ascii("ies"),
        dictgen::InsensitiveStr::Ascii("iggum"),
        dictgen::InsensitiveStr::Ascii("im"),
        dictgen::InsensitiveStr::Ascii("ime"),
        dictgen::InsensitiveStr::Ascii("imes"),
        dictgen::InsensitiveStr::Ascii("se"),
        dictgen::InsensitiveStr::Ascii("ym"),
        dictgen::InsensitiveStr::Ascii("yse"),
    ],
    values: &[
        &["paramedics"],
        &["paradise"],
        &["paradigm"],
        &["paradigm"],
        &["paradigm"],
        &["paradise"],
        &["parades"],
        &["paradigm"],
        &["parades"],
    ],
    range: 2..=5,
};

static WORD_PARAC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PARAC_CHILDREN),
    value: None,
};

pub static WORD_PARAC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("hutage"),
        dictgen::InsensitiveStr::Ascii("hutte"),
    ],
    values: &[&["parachute"], &["parachute"]],
    range: 5..=6,
};

static WORD_PAP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PAP_CHILDREN),
    value: None,
};

pub static WORD_PAP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("anicalou")],
    values: &[&["papanicolaou"]],
    range: 8..=8,
};

static WORD_PAO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PAO_CHILDREN),
    value: None,
};

pub static WORD_PAO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ition"),
        dictgen::InsensitiveStr::Ascii("r"),
    ],
    values: &[&["position"], &["pair"]],
    range: 1..=5,
};

static WORD_PAN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PAN_CHILDREN),
    value: None,
};

pub static WORD_PAN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("caeks"),
        dictgen::InsensitiveStr::Ascii("cakers"),
        dictgen::InsensitiveStr::Ascii("caks"),
        dictgen::InsensitiveStr::Ascii("ckaes"),
        dictgen::InsensitiveStr::Ascii("doria"),
        dictgen::InsensitiveStr::Ascii("dorra"),
        dictgen::InsensitiveStr::Ascii("droa"),
        dictgen::InsensitiveStr::Ascii("edmic"),
        dictgen::InsensitiveStr::Ascii("ethon"),
        dictgen::InsensitiveStr::Ascii("iced"),
        dictgen::InsensitiveStr::Ascii("icing"),
        dictgen::InsensitiveStr::Ascii("kaces"),
        dictgen::InsensitiveStr::Ascii("medic"),
        dictgen::InsensitiveStr::Ascii("nel"),
        dictgen::InsensitiveStr::Ascii("nels"),
        dictgen::InsensitiveStr::Ascii("tehon"),
        dictgen::InsensitiveStr::Ascii("then"),
        dictgen::InsensitiveStr::Ascii("thoen"),
        dictgen::InsensitiveStr::Ascii("tomine"),
    ],
    values: &[
        &["pancakes"],
        &["pancakes"],
        &["pancakes"],
        &["pancakes"],
        &["pandora"],
        &["pandora"],
        &["pandora"],
        &["pandemic"],
        &["pantheon"],
        &["panicked"],
        &["panicking"],
        &["pancakes"],
        &["pandemic"],
        &["panel"],
        &["panels"],
        &["pantheon"],
        &["pantheon"],
        &["pantheon"],
        &["pantomime"],
    ],
    range: 3..=6,
};

static WORD_PAM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PAM_CHILDREN),
    value: None,
};

pub static WORD_PAM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("flet"),
        dictgen::InsensitiveStr::Ascii("plet"),
    ],
    values: &[&["pamphlet"], &["pamphlet"]],
    range: 4..=4,
};

static WORD_PAL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PAL_CHILDREN),
    value: None,
};

pub static WORD_PAL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("adines"),
        dictgen::InsensitiveStr::Ascii("adinlst"),
        dictgen::InsensitiveStr::Ascii("adinos"),
        dictgen::InsensitiveStr::Ascii("astinians"),
        dictgen::InsensitiveStr::Ascii("atte"),
        dictgen::InsensitiveStr::Ascii("ce"),
        dictgen::InsensitiveStr::Ascii("cebo"),
        dictgen::InsensitiveStr::Ascii("ceholder"),
        dictgen::InsensitiveStr::Ascii("cements"),
        dictgen::InsensitiveStr::Ascii("ces"),
        dictgen::InsensitiveStr::Ascii("eolitic"),
        dictgen::InsensitiveStr::Ascii("esitnian"),
        dictgen::InsensitiveStr::Ascii("esitnians"),
        dictgen::InsensitiveStr::Ascii("estein"),
        dictgen::InsensitiveStr::Ascii("estenian"),
        dictgen::InsensitiveStr::Ascii("estenians"),
        dictgen::InsensitiveStr::Ascii("estina"),
        dictgen::InsensitiveStr::Ascii("estinain"),
        dictgen::InsensitiveStr::Ascii("estinains"),
        dictgen::InsensitiveStr::Ascii("estinan"),
        dictgen::InsensitiveStr::Ascii("estinans"),
        dictgen::InsensitiveStr::Ascii("estiniens"),
        dictgen::InsensitiveStr::Ascii("estinier"),
        dictgen::InsensitiveStr::Ascii("estininan"),
        dictgen::InsensitiveStr::Ascii("estininans"),
        dictgen::InsensitiveStr::Ascii("estininas"),
        dictgen::InsensitiveStr::Ascii("ete"),
        dictgen::InsensitiveStr::Ascii("iamentarian"),
        dictgen::InsensitiveStr::Ascii("idans"),
        dictgen::InsensitiveStr::Ascii("istian"),
        dictgen::InsensitiveStr::Ascii("istinian"),
        dictgen::InsensitiveStr::Ascii("istinians"),
        dictgen::InsensitiveStr::Ascii("lete"),
        dictgen::InsensitiveStr::Ascii("lette"),
        dictgen::InsensitiveStr::Ascii("letted"),
        dictgen::InsensitiveStr::Ascii("n"),
        dictgen::InsensitiveStr::Ascii("ster"),
        dictgen::InsensitiveStr::Ascii("stics"),
        dictgen::InsensitiveStr::Ascii("tette"),
        dictgen::InsensitiveStr::Ascii("tform"),
        dictgen::InsensitiveStr::Ascii("tformer"),
        dictgen::InsensitiveStr::Ascii("tforms"),
        dictgen::InsensitiveStr::Ascii("tinum"),
        dictgen::InsensitiveStr::Ascii("yable"),
        dictgen::InsensitiveStr::Ascii("yboy"),
        dictgen::InsensitiveStr::Ascii("yerbase"),
        dictgen::InsensitiveStr::Ascii("yoffs"),
        dictgen::InsensitiveStr::Ascii("ystyle"),
        dictgen::InsensitiveStr::Ascii("ythrough"),
        dictgen::InsensitiveStr::Ascii("ythroughs"),
    ],
    values: &[
        &["paladins"],
        &["paladins"],
        &["paladins"],
        &["palestinians"],
        &["palette"],
        &["place", "palace"],
        &["placebo"],
        &["placeholder"],
        &["placements"],
        &["places", "pales"],
        &["paleolithic"],
        &["palestinians"],
        &["palestinians"],
        &["palestine"],
        &["palestinian"],
        &["palestinians"],
        &["palestinian"],
        &["palestinians"],
        &["palestinians"],
        &["palestinian"],
        &["palestinians"],
        &["palestinians"],
        &["palestine"],
        &["palestinian"],
        &["palestinians"],
        &["palestinians"],
        &["palette"],
        &["parliamentarian"],
        &["paladins"],
        &["palestinian"],
        &["palestinian"],
        &["palestinians"],
        &["palette"],
        &["palette"],
        &["paletted"],
        &["plan", "pain", "palm"],
        &["plaster"],
        &["plastics"],
        &["palette"],
        &["platform"],
        &["platformer"],
        &["platforms"],
        &["platinum"],
        &["playable"],
        &["playboy"],
        &["playerbase"],
        &["playoffs"],
        &["playstyle"],
        &["playthrough"],
        &["playthroughs"],
    ],
    range: 1..=11,
};

static WORD_PAK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PAK_CHILDREN),
    value: None,
};

pub static WORD_PAK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("age"),
        dictgen::InsensitiveStr::Ascii("ageimpl"),
        dictgen::InsensitiveStr::Ascii("ages"),
        dictgen::InsensitiveStr::Ascii("cage"),
        dictgen::InsensitiveStr::Ascii("cages"),
        dictgen::InsensitiveStr::Ascii("et"),
        dictgen::InsensitiveStr::Ascii("ge"),
        dictgen::InsensitiveStr::Ascii("istain"),
        dictgen::InsensitiveStr::Ascii("istanais"),
        dictgen::InsensitiveStr::Ascii("istanezi"),
        dictgen::InsensitiveStr::Ascii("istanti"),
        dictgen::InsensitiveStr::Ascii("istian"),
        dictgen::InsensitiveStr::Ascii("istnai"),
        dictgen::InsensitiveStr::Ascii("sitani"),
        dictgen::InsensitiveStr::Ascii("vage"),
    ],
    values: &[
        &["package"],
        &["packageimpl"],
        &["packages"],
        &["package"],
        &["packages"],
        &["packet"],
        &["package"],
        &["pakistani"],
        &["pakistani"],
        &["pakistani"],
        &["pakistani"],
        &["pakistani"],
        &["pakistani"],
        &["pakistani"],
        &["package"],
    ],
    range: 2..=8,
};

static WORD_PAI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PAI_CHILDREN),
    value: None,
};

pub static WORD_PAI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("de"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("nfullly"),
        dictgen::InsensitiveStr::Ascii("nfuly"),
        dictgen::InsensitiveStr::Ascii("niting"),
        dictgen::InsensitiveStr::Ascii("nkilers"),
        dictgen::InsensitiveStr::Ascii("nkilllers"),
        dictgen::InsensitiveStr::Ascii("nkills"),
        dictgen::InsensitiveStr::Ascii("ntile"),
        dictgen::InsensitiveStr::Ascii("ntin"),
        dictgen::InsensitiveStr::Ascii("rlament"),
        dictgen::InsensitiveStr::Ascii("rocheal"),
        dictgen::InsensitiveStr::Ascii("rocheality"),
        dictgen::InsensitiveStr::Ascii("rocheally"),
        dictgen::InsensitiveStr::Ascii("rocheel"),
        dictgen::InsensitiveStr::Ascii("rocheelity"),
        dictgen::InsensitiveStr::Ascii("rocheelly"),
        dictgen::InsensitiveStr::Ascii("rokeal"),
        dictgen::InsensitiveStr::Ascii("rokeality"),
        dictgen::InsensitiveStr::Ascii("rokeally"),
        dictgen::InsensitiveStr::Ascii("rokeel"),
        dictgen::InsensitiveStr::Ascii("rokeelity"),
        dictgen::InsensitiveStr::Ascii("rokeelly"),
        dictgen::InsensitiveStr::Ascii("tence"),
        dictgen::InsensitiveStr::Ascii("tent"),
        dictgen::InsensitiveStr::Ascii("tently"),
        dictgen::InsensitiveStr::Ascii("tents"),
        dictgen::InsensitiveStr::Ascii("tience"),
        dictgen::InsensitiveStr::Ascii("ting"),
    ],
    values: &[
        &["paid"],
        &["paid", "paired"],
        &["painfully"],
        &["painfully"],
        &["painting"],
        &["painkillers"],
        &["painkillers"],
        &["painkillers"],
        &["painttile"],
        &["painting"],
        &["parliament"],
        &["parochial"],
        &["parochiality"],
        &["parochially"],
        &["parochial"],
        &["parochiality"],
        &["parochially"],
        &["parochial"],
        &["parochiality"],
        &["parochially"],
        &["parochial"],
        &["parochiality"],
        &["parochially"],
        &["patience"],
        &["patient"],
        &["patiently"],
        &["patients"],
        &["patience"],
        &["painting"],
    ],
    range: 2..=10,
};

static WORD_PAH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PAH_CHILDREN),
    value: None,
};

pub static WORD_PAH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ntom"),
        dictgen::InsensitiveStr::Ascii("ses"),
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("tfinder"),
        dictgen::InsensitiveStr::Ascii("ts"),
    ],
    values: &[
        &["phantom"],
        &["phases"],
        &["path", "pat", "part"],
        &["pathfinder"],
        &["paths", "pats", "parts"],
    ],
    range: 1..=7,
};

static WORD_PAG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PAG_CHILDREN),
    value: None,
};

pub static WORD_PAG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("agraph"),
        dictgen::InsensitiveStr::Ascii("ckage"),
        dictgen::InsensitiveStr::Ascii("ent"),
        dictgen::InsensitiveStr::Ascii("entry"),
        dictgen::InsensitiveStr::Ascii("ents"),
    ],
    values: &[
        &["paragraph"],
        &["package"],
        &["pageant", "plangent"],
        &["pageantry", "plangently"],
        &["pageants", "plangents"],
    ],
    range: 3..=6,
};

static WORD_PAF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PAF_CHILDREN),
    value: None,
};

pub static WORD_PAF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("icist")],
    values: &[&["pacifist"]],
    range: 5..=5,
};

static WORD_PAE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PAE_CHILDREN),
    value: None,
};

pub static WORD_PAE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("rmission"),
        dictgen::InsensitiveStr::Ascii("rmissions"),
        dictgen::InsensitiveStr::Ascii("rnt"),
        dictgen::InsensitiveStr::Ascii("th"),
    ],
    values: &[&["permission"], &["permissions"], &["parent"], &["path"]],
    range: 2..=9,
};

static WORD_PAD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PAD_CHILDREN),
    value: None,
};

pub static WORD_PAD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("am"),
        dictgen::InsensitiveStr::Ascii("d"),
        dictgen::InsensitiveStr::Ascii("ds"),
        dictgen::InsensitiveStr::Ascii("ing"),
    ],
    values: &[&["param"], &["pad", "padded"], &["pads"], &["padding"]],
    range: 1..=3,
};

static WORD_PAC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PAC_CHILDREN),
    value: None,
};

pub static WORD_PAC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("age"),
        dictgen::InsensitiveStr::Ascii("ages"),
        dictgen::InsensitiveStr::Ascii("aging"),
        dictgen::InsensitiveStr::Ascii("akage"),
        dictgen::InsensitiveStr::Ascii("akages"),
        dictgen::InsensitiveStr::Ascii("akaging"),
        dictgen::InsensitiveStr::Ascii("akge"),
        dictgen::InsensitiveStr::Ascii("akged"),
        dictgen::InsensitiveStr::Ascii("akges"),
        dictgen::InsensitiveStr::Ascii("akging"),
        dictgen::InsensitiveStr::Ascii("eholder"),
        dictgen::InsensitiveStr::Ascii("h"),
        dictgen::InsensitiveStr::Ascii("hage"),
        dictgen::InsensitiveStr::Ascii("hes"),
        dictgen::InsensitiveStr::Ascii("hooly"),
        dictgen::InsensitiveStr::Ascii("ht"),
        dictgen::InsensitiveStr::Ascii("htches"),
        dictgen::InsensitiveStr::Ascii("htes"),
        dictgen::InsensitiveStr::Ascii("ificts"),
        dictgen::InsensitiveStr::Ascii("ifit"),
        dictgen::InsensitiveStr::Ascii("jage"),
        dictgen::InsensitiveStr::Ascii("jages"),
        dictgen::InsensitiveStr::Ascii("kacge"),
        dictgen::InsensitiveStr::Ascii("kade"),
        dictgen::InsensitiveStr::Ascii("kadge"),
        dictgen::InsensitiveStr::Ascii("kaeg"),
        dictgen::InsensitiveStr::Ascii("kaege"),
        dictgen::InsensitiveStr::Ascii("kaeges"),
        dictgen::InsensitiveStr::Ascii("kaegs"),
        dictgen::InsensitiveStr::Ascii("kag"),
        dictgen::InsensitiveStr::Ascii("kageid"),
        dictgen::InsensitiveStr::Ascii("kags"),
        dictgen::InsensitiveStr::Ascii("kaing"),
        dictgen::InsensitiveStr::Ascii("kats"),
        dictgen::InsensitiveStr::Ascii("ke"),
        dictgen::InsensitiveStr::Ascii("kege"),
        dictgen::InsensitiveStr::Ascii("kes"),
        dictgen::InsensitiveStr::Ascii("kge"),
        dictgen::InsensitiveStr::Ascii("kged"),
        dictgen::InsensitiveStr::Ascii("kgement"),
        dictgen::InsensitiveStr::Ascii("kges"),
        dictgen::InsensitiveStr::Ascii("kgs"),
        dictgen::InsensitiveStr::Ascii("khage"),
        dictgen::InsensitiveStr::Ascii("khages"),
        dictgen::InsensitiveStr::Ascii("kkage"),
        dictgen::InsensitiveStr::Ascii("kkaged"),
        dictgen::InsensitiveStr::Ascii("kkages"),
        dictgen::InsensitiveStr::Ascii("kkaging"),
        dictgen::InsensitiveStr::Ascii("ktes"),
        dictgen::InsensitiveStr::Ascii("tch"),
        dictgen::InsensitiveStr::Ascii("tched"),
        dictgen::InsensitiveStr::Ascii("tches"),
        dictgen::InsensitiveStr::Ascii("thes"),
        dictgen::InsensitiveStr::Ascii("tivity"),
        dictgen::InsensitiveStr::Ascii("ulier"),
        dictgen::InsensitiveStr::Ascii("ulierly"),
    ],
    values: &[
        &["package"],
        &["packages"],
        &["packaging"],
        &["package"],
        &["packages"],
        &["packaging"],
        &["package"],
        &["packaged"],
        &["packages"],
        &["packaging"],
        &["placeholder"],
        &["patch", "path"],
        &["package"],
        &["patches"],
        &["patchouli"],
        &["patch"],
        &["patches"],
        &["patches"],
        &["pacifist"],
        &["pacifist"],
        &["package"],
        &["packages"],
        &["package"],
        &["packaged"],
        &["packaged"],
        &["package"],
        &["package"],
        &["packages"],
        &["packages"],
        &["package"],
        &["packaged"],
        &["packages"],
        &["packaging"],
        &["packets"],
        &["packed", "packet"],
        &["package"],
        &["packages", "packed", "packs"],
        &["package"],
        &["packaged"],
        &["packaging"],
        &["packages"],
        &["packages"],
        &["package"],
        &["packages"],
        &["package"],
        &["packaged"],
        &["packages"],
        &["packaging"],
        &["packets"],
        &["patch"],
        &["patched"],
        &["patches"],
        &["patches"],
        &["captivity"],
        &["peculiar"],
        &["peculiarly"],
    ],
    range: 1..=7,
};

static WORD_PAA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_PAA_CHILDREN),
    value: None,
};

pub static WORD_PAA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ckage"),
        dictgen::InsensitiveStr::Ascii("ckages"),
        dictgen::InsensitiveStr::Ascii("ckaging"),
    ],
    values: &[&["package"], &["packages"], &["packaging"]],
    range: 5..=7,
};

static WORD_O_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_O_CHILDREN),
    value: None,
};

static WORD_O_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_OA_NODE),
    Some(&WORD_OB_NODE),
    Some(&WORD_OC_NODE),
    Some(&WORD_OD_NODE),
    Some(&WORD_OE_NODE),
    Some(&WORD_OF_NODE),
    Some(&WORD_OG_NODE),
    Some(&WORD_OH_NODE),
    Some(&WORD_OI_NODE),
    Some(&WORD_OJ_NODE),
    Some(&WORD_OK_NODE),
    Some(&WORD_OL_NODE),
    Some(&WORD_OM_NODE),
    Some(&WORD_ON_NODE),
    Some(&WORD_OO_NODE),
    Some(&WORD_OP_NODE),
    None,
    Some(&WORD_OR_NODE),
    Some(&WORD_OS_NODE),
    Some(&WORD_OT_NODE),
    Some(&WORD_OU_NODE),
    Some(&WORD_OV_NODE),
    Some(&WORD_OW_NODE),
    Some(&WORD_OX_NODE),
    Some(&WORD_OY_NODE),
    None,
];

static WORD_OY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OY_CHILDREN),
    value: None,
};

pub static WORD_OY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("lmpic"),
        dictgen::InsensitiveStr::Ascii("lmpics"),
        dictgen::InsensitiveStr::Ascii("u"),
    ],
    values: &[&["olympic"], &["olympics"], &["you"]],
    range: 1..=6,
};

static WORD_OX_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OX_CHILDREN),
    value: None,
};

pub static WORD_OX_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("igen"),
        dictgen::InsensitiveStr::Ascii("imoron"),
        dictgen::InsensitiveStr::Ascii("zillary"),
    ],
    values: &[&["oxygen"], &["oxymoron"], &["auxiliary"]],
    range: 4..=7,
};

static WORD_OW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OW_CHILDREN),
    value: None,
};

pub static WORD_OW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ener"),
        dictgen::InsensitiveStr::Ascii("erflow"),
        dictgen::InsensitiveStr::Ascii("erflowed"),
        dictgen::InsensitiveStr::Ascii("erflowing"),
        dictgen::InsensitiveStr::Ascii("erflows"),
        dictgen::InsensitiveStr::Ascii("ernship"),
        dictgen::InsensitiveStr::Ascii("erpowering"),
        dictgen::InsensitiveStr::Ascii("ership"),
        dictgen::InsensitiveStr::Ascii("ervrite"),
        dictgen::InsensitiveStr::Ascii("ervrites"),
        dictgen::InsensitiveStr::Ascii("erwrite"),
        dictgen::InsensitiveStr::Ascii("erwrites"),
        dictgen::InsensitiveStr::Ascii("ful"),
        dictgen::InsensitiveStr::Ascii("nder"),
        dictgen::InsensitiveStr::Ascii("nders"),
        dictgen::InsensitiveStr::Ascii("nerhsip"),
        dictgen::InsensitiveStr::Ascii("nersip"),
        dictgen::InsensitiveStr::Ascii("nes"),
        dictgen::InsensitiveStr::Ascii("nner"),
        dictgen::InsensitiveStr::Ascii("nward"),
        dictgen::InsensitiveStr::Ascii("nwer"),
        dictgen::InsensitiveStr::Ascii("nwership"),
        dictgen::InsensitiveStr::Ascii("rk"),
        dictgen::InsensitiveStr::Ascii("udl"),
        dictgen::InsensitiveStr::Ascii("uldve"),
    ],
    values: &[
        &["owner"],
        &["overflow"],
        &["overflowed"],
        &["overflowing"],
        &["overflows"],
        &["ownership"],
        &["overpowering"],
        &["ownership"],
        &["overwrite"],
        &["overwrites"],
        &["overwrite"],
        &["overwrites"],
        &["awful"],
        &["owner"],
        &["wonders"],
        &["ownership"],
        &["ownership"],
        &["owns", "ones"],
        &["owner"],
        &["onward"],
        &["owner"],
        &["ownership"],
        &["work"],
        &["would"],
        &["wouldve"],
    ],
    range: 2..=10,
};

static WORD_OV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_OV_CHILDREN),
    value: None,
};

static WORD_OV_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    None,
    None,
    Some(&WORD_OVE_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_OVR_NODE),
    Some(&WORD_OVS_NODE),
    None,
    None,
    Some(&WORD_OVV_NODE),
    None,
    None,
    None,
    None,
];

static WORD_OVV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OVV_CHILDREN),
    value: None,
};

pub static WORD_OVV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eride"),
        dictgen::InsensitiveStr::Ascii("erridden"),
        dictgen::InsensitiveStr::Ascii("erride"),
        dictgen::InsensitiveStr::Ascii("errides"),
        dictgen::InsensitiveStr::Ascii("erriding"),
    ],
    values: &[
        &["override"],
        &["overridden"],
        &["override"],
        &["overrides"],
        &["overriding"],
    ],
    range: 5..=8,
};

static WORD_OVS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OVS_CHILDREN),
    value: None,
};

pub static WORD_OVS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ervable"),
        dictgen::InsensitiveStr::Ascii("ervation"),
        dictgen::InsensitiveStr::Ascii("erve"),
    ],
    values: &[&["observable"], &["observation"], &["observe"]],
    range: 4..=8,
};

static WORD_OVR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OVR_CHILDREN),
    value: None,
};

pub static WORD_OVR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ide"),
        dictgen::InsensitiveStr::Ascii("ides"),
        dictgen::InsensitiveStr::Ascii("lapped"),
        dictgen::InsensitiveStr::Ascii("ridable"),
        dictgen::InsensitiveStr::Ascii("ridables"),
        dictgen::InsensitiveStr::Ascii("wrt"),
    ],
    values: &[
        &["override"],
        &["overrides"],
        &["overlapped"],
        &["overridable"],
        &["overridables"],
        &["overwrite"],
    ],
    range: 3..=8,
};

static WORD_OVE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_OVE_CHILDREN),
    value: Some(&["oven", "over"]),
};

static WORD_OVE_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    None,
    None,
    Some(&WORD_OVEE_NODE),
    Some(&WORD_OVEF_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_OVEL_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_OVER_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_OVEW_NODE),
    None,
    None,
    None,
];

static WORD_OVEW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OVEW_CHILDREN),
    value: None,
};

pub static WORD_OVEW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("rite"),
        dictgen::InsensitiveStr::Ascii("rites"),
        dictgen::InsensitiveStr::Ascii("riting"),
        dictgen::InsensitiveStr::Ascii("ritten"),
        dictgen::InsensitiveStr::Ascii("rote"),
    ],
    values: &[
        &["overwrite"],
        &["overwrites"],
        &["overwriting"],
        &["overwritten"],
        &["overwrote"],
    ],
    range: 4..=6,
};

static WORD_OVER_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_OVER_CHILDREN),
    value: None,
};

static WORD_OVER_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_OVERA_NODE),
    Some(&WORD_OVERB_NODE),
    Some(&WORD_OVERC_NODE),
    Some(&WORD_OVERD_NODE),
    Some(&WORD_OVERE_NODE),
    Some(&WORD_OVERF_NODE),
    None,
    Some(&WORD_OVERH_NODE),
    Some(&WORD_OVERI_NODE),
    None,
    Some(&WORD_OVERK_NODE),
    Some(&WORD_OVERL_NODE),
    Some(&WORD_OVERM_NODE),
    Some(&WORD_OVERN_NODE),
    None,
    Some(&WORD_OVERP_NODE),
    None,
    Some(&WORD_OVERR_NODE),
    Some(&WORD_OVERS_NODE),
    Some(&WORD_OVERT_NODE),
    Some(&WORD_OVERU_NODE),
    Some(&WORD_OVERV_NODE),
    Some(&WORD_OVERW_NODE),
    None,
    Some(&WORD_OVERY_NODE),
    Some(&WORD_OVERZ_NODE),
];

static WORD_OVERZ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OVERZ_CHILDREN),
    value: None,
};

pub static WORD_OVERZ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ealis"),
        dictgen::InsensitiveStr::Ascii("ealisly"),
        dictgen::InsensitiveStr::Ascii("ealos"),
        dictgen::InsensitiveStr::Ascii("ealosly"),
        dictgen::InsensitiveStr::Ascii("ealus"),
        dictgen::InsensitiveStr::Ascii("ealusly"),
        dictgen::InsensitiveStr::Ascii("elis"),
        dictgen::InsensitiveStr::Ascii("elisly"),
        dictgen::InsensitiveStr::Ascii("elos"),
        dictgen::InsensitiveStr::Ascii("elosly"),
        dictgen::InsensitiveStr::Ascii("elous"),
        dictgen::InsensitiveStr::Ascii("elously"),
        dictgen::InsensitiveStr::Ascii("elus"),
        dictgen::InsensitiveStr::Ascii("elusly"),
    ],
    values: &[
        &["overzealous"],
        &["overzealously"],
        &["overzealous"],
        &["overzealously"],
        &["overzealous"],
        &["overzealously"],
        &["overzealous"],
        &["overzealously"],
        &["overzealous"],
        &["overzealously"],
        &["overzealous"],
        &["overzealously"],
        &["overzealous"],
        &["overzealously"],
    ],
    range: 4..=7,
};

static WORD_OVERY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OVERY_CHILDREN),
    value: None,
};

pub static WORD_OVERY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("hped")],
    values: &[&["overhyped"]],
    range: 4..=4,
};

static WORD_OVERW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OVERW_CHILDREN),
    value: None,
};

pub static WORD_OVERW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ath"),
        dictgen::InsensitiveStr::Ascii("ealmed"),
        dictgen::InsensitiveStr::Ascii("ealming"),
        dictgen::InsensitiveStr::Ascii("eigth"),
        dictgen::InsensitiveStr::Ascii("elm"),
        dictgen::InsensitiveStr::Ascii("elming"),
        dictgen::InsensitiveStr::Ascii("helemd"),
        dictgen::InsensitiveStr::Ascii("helemed"),
        dictgen::InsensitiveStr::Ascii("helimg"),
        dictgen::InsensitiveStr::Ascii("heliming"),
        dictgen::InsensitiveStr::Ascii("heling"),
        dictgen::InsensitiveStr::Ascii("helmigly"),
        dictgen::InsensitiveStr::Ascii("helmingy"),
        dictgen::InsensitiveStr::Ascii("helminly"),
        dictgen::InsensitiveStr::Ascii("hem"),
        dictgen::InsensitiveStr::Ascii("hemed"),
        dictgen::InsensitiveStr::Ascii("hemled"),
        dictgen::InsensitiveStr::Ascii("hemling"),
        dictgen::InsensitiveStr::Ascii("hemlingly"),
        dictgen::InsensitiveStr::Ascii("hlem"),
        dictgen::InsensitiveStr::Ascii("hlemed"),
        dictgen::InsensitiveStr::Ascii("hleming"),
        dictgen::InsensitiveStr::Ascii("hlemingly"),
        dictgen::InsensitiveStr::Ascii("ieght"),
        dictgen::InsensitiveStr::Ascii("iew"),
        dictgen::InsensitiveStr::Ascii("irte"),
        dictgen::InsensitiveStr::Ascii("irting"),
        dictgen::InsensitiveStr::Ascii("irtten"),
        dictgen::InsensitiveStr::Ascii("ise"),
        dictgen::InsensitiveStr::Ascii("ite"),
        dictgen::InsensitiveStr::Ascii("ites"),
        dictgen::InsensitiveStr::Ascii("itten"),
        dictgen::InsensitiveStr::Ascii("ize"),
        dictgen::InsensitiveStr::Ascii("ridden"),
        dictgen::InsensitiveStr::Ascii("ride"),
        dictgen::InsensitiveStr::Ascii("riteable"),
        dictgen::InsensitiveStr::Ascii("rited"),
        dictgen::InsensitiveStr::Ascii("riten"),
        dictgen::InsensitiveStr::Ascii("ritren"),
        dictgen::InsensitiveStr::Ascii("ritte"),
        dictgen::InsensitiveStr::Ascii("ritted"),
        dictgen::InsensitiveStr::Ascii("rittes"),
        dictgen::InsensitiveStr::Ascii("rittin"),
        dictgen::InsensitiveStr::Ascii("ritting"),
        dictgen::InsensitiveStr::Ascii("tach"),
    ],
    values: &[
        &["overwatch"],
        &["overwhelmed"],
        &["overwhelming"],
        &["overweight"],
        &["overwhelm"],
        &["overwhelming"],
        &["overwhelmed"],
        &["overwhelmed"],
        &["overwhelm"],
        &["overwhelming"],
        &["overwhelming"],
        &["overwhelmingly"],
        &["overwhelmingly"],
        &["overwhelmingly"],
        &["overwhelm"],
        &["overwhelmed"],
        &["overwhelmed"],
        &["overwhelming"],
        &["overwhelmingly"],
        &["overwhelm"],
        &["overwhelmed"],
        &["overwhelming"],
        &["overwhelmingly"],
        &["overweight"],
        &["overview"],
        &["overwrite"],
        &["overwriting"],
        &["overwritten"],
        &["otherwise"],
        &["overwrite"],
        &["overwrites"],
        &["overwritten"],
        &["otherwise"],
        &["overridden", "overwritten"],
        &["overwrite"],
        &["overwritable"],
        &["overwritten", "overwrote"],
        &["overwritten"],
        &["overwritten"],
        &["overwrite"],
        &["overwrite"],
        &["overwrites"],
        &["overwriting"],
        &["overwriting"],
        &["overwatch"],
    ],
    range: 3..=9,
};

static WORD_OVERV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OVERV_CHILDREN),
    value: None,
};

pub static WORD_OVERV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ise"),
        dictgen::InsensitiveStr::Ascii("ize"),
        dictgen::InsensitiveStr::Ascii("locked"),
        dictgen::InsensitiveStr::Ascii("ride"),
        dictgen::InsensitiveStr::Ascii("rides"),
        dictgen::InsensitiveStr::Ascii("rite"),
        dictgen::InsensitiveStr::Ascii("rites"),
    ],
    values: &[
        &["otherwise"],
        &["otherwise"],
        &["overclocked"],
        &["override"],
        &["overrides"],
        &["overwrite"],
        &["overwrites"],
    ],
    range: 3..=6,
};

static WORD_OVERU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OVERU_CHILDREN),
    value: None,
};

pub static WORD_OVERU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("les"),
        dictgen::InsensitiveStr::Ascii("n"),
    ],
    values: &[&["overuse"], &["overrun"]],
    range: 1..=3,
};

static WORD_OVERT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OVERT_CHILDREN),
    value: None,
};

pub static WORD_OVERT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("apping"),
        dictgen::InsensitiveStr::Ascii("hining"),
        dictgen::InsensitiveStr::Ascii("hinkig"),
        dictgen::InsensitiveStr::Ascii("un"),
        dictgen::InsensitiveStr::Ascii("unned"),
        dictgen::InsensitiveStr::Ascii("unred"),
        dictgen::InsensitiveStr::Ascii("uring"),
    ],
    values: &[
        &["overlapping"],
        &["overthinking"],
        &["overthinking"],
        &["overturn"],
        &["overturned"],
        &["overturned"],
        &["overturn"],
    ],
    range: 2..=6,
};

static WORD_OVERS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OVERS_CHILDREN),
    value: None,
};

pub static WORD_OVERS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("emplification"),
        dictgen::InsensitiveStr::Ascii("etimating"),
        dictgen::InsensitiveStr::Ascii("haddow"),
        dictgen::InsensitiveStr::Ascii("haddowed"),
        dictgen::InsensitiveStr::Ascii("hadowd"),
        dictgen::InsensitiveStr::Ascii("hadowered"),
        dictgen::InsensitiveStr::Ascii("implifacation"),
        dictgen::InsensitiveStr::Ascii("implifaction"),
        dictgen::InsensitiveStr::Ascii("implificaiton"),
        dictgen::InsensitiveStr::Ascii("implificating"),
        dictgen::InsensitiveStr::Ascii("implificaton"),
        dictgen::InsensitiveStr::Ascii("implificiation"),
        dictgen::InsensitiveStr::Ascii("implifiction"),
        dictgen::InsensitiveStr::Ascii("implyfication"),
        dictgen::InsensitiveStr::Ascii("ubcribe"),
        dictgen::InsensitiveStr::Ascii("ubcribed"),
        dictgen::InsensitiveStr::Ascii("ubcribes"),
        dictgen::InsensitiveStr::Ascii("ubcribing"),
        dictgen::InsensitiveStr::Ascii("ubscibe"),
        dictgen::InsensitiveStr::Ascii("ubscibed"),
        dictgen::InsensitiveStr::Ascii("ubscirbe"),
        dictgen::InsensitiveStr::Ascii("ubscirbed"),
        dictgen::InsensitiveStr::Ascii("ue"),
    ],
    values: &[
        &["oversimplification"],
        &["overestimating"],
        &["overshadowed"],
        &["overshadowed"],
        &["overshadowed"],
        &["overshadowed"],
        &["oversimplification"],
        &["oversimplification"],
        &["oversimplification"],
        &["oversimplification"],
        &["oversimplification"],
        &["oversimplification"],
        &["oversimplification"],
        &["oversimplification"],
        &["oversubscribe"],
        &["oversubscribed"],
        &["oversubscribes"],
        &["oversubscribing"],
        &["oversubscribe"],
        &["oversubscribed"],
        &["oversubscribe"],
        &["oversubscribed"],
        &["overuse"],
    ],
    range: 2..=14,
};

static WORD_OVERR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OVERR_CHILDREN),
    value: None,
};

pub static WORD_OVERR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ading"),
        dictgen::InsensitiveStr::Ascii("eacing"),
        dictgen::InsensitiveStr::Ascii("eactin"),
        dictgen::InsensitiveStr::Ascii("eactiong"),
        dictgen::InsensitiveStr::Ascii("eacton"),
        dictgen::InsensitiveStr::Ascii("eaktion"),
        dictgen::InsensitiveStr::Ascii("eidden"),
        dictgen::InsensitiveStr::Ascii("eide"),
        dictgen::InsensitiveStr::Ascii("eides"),
        dictgen::InsensitiveStr::Ascii("iabled"),
        dictgen::InsensitiveStr::Ascii("iddable"),
        dictgen::InsensitiveStr::Ascii("iddden"),
        dictgen::InsensitiveStr::Ascii("idde"),
        dictgen::InsensitiveStr::Ascii("idded"),
        dictgen::InsensitiveStr::Ascii("iddes"),
        dictgen::InsensitiveStr::Ascii("idding"),
        dictgen::InsensitiveStr::Ascii("ideable"),
        dictgen::InsensitiveStr::Ascii("ided"),
        dictgen::InsensitiveStr::Ascii("iden"),
        dictgen::InsensitiveStr::Ascii("ident"),
        dictgen::InsensitiveStr::Ascii("idiing"),
        dictgen::InsensitiveStr::Ascii("ids"),
        dictgen::InsensitiveStr::Ascii("ie"),
        dictgen::InsensitiveStr::Ascii("ies"),
        dictgen::InsensitiveStr::Ascii("ite"),
        dictgen::InsensitiveStr::Ascii("riddden"),
        dictgen::InsensitiveStr::Ascii("ridden"),
        dictgen::InsensitiveStr::Ascii("ride"),
        dictgen::InsensitiveStr::Ascii("riden"),
        dictgen::InsensitiveStr::Ascii("rides"),
        dictgen::InsensitiveStr::Ascii("riding"),
        dictgen::InsensitiveStr::Ascii("run"),
    ],
    values: &[
        &["overriding"],
        &["overreacting"],
        &["overreaction"],
        &["overreacting"],
        &["overreaction"],
        &["overreaction"],
        &["overridden"],
        &["override"],
        &["overrides"],
        &["overridable"],
        &["overridable"],
        &["overridden"],
        &["overridden", "override"],
        &["overrode", "overridden"],
        &["overrides"],
        &["overriding"],
        &["overridable"],
        &["overrode", "overridden"],
        &["overridden"],
        &["overridden"],
        &["overriding"],
        &["overrides"],
        &["override", "ovary"],
        &["overrides", "ovaries"],
        &["overwrite", "override", "overrate"],
        &["overridden"],
        &["overridden"],
        &["override"],
        &["overridden"],
        &["overrides"],
        &["overriding"],
        &["overrun"],
    ],
    range: 2..=8,
};

static WORD_OVERP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OVERP_CHILDREN),
    value: None,
};

pub static WORD_OVERP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ad"),
        dictgen::InsensitiveStr::Ascii("aied"),
        dictgen::InsensitiveStr::Ascii("iad"),
        dictgen::InsensitiveStr::Ascii("irced"),
        dictgen::InsensitiveStr::Ascii("olulation"),
        dictgen::InsensitiveStr::Ascii("ooling"),
        dictgen::InsensitiveStr::Ascii("opluation"),
        dictgen::InsensitiveStr::Ascii("opulaton"),
        dictgen::InsensitiveStr::Ascii("overed"),
        dictgen::InsensitiveStr::Ascii("owed"),
        dictgen::InsensitiveStr::Ascii("oweing"),
        dictgen::InsensitiveStr::Ascii("owerd"),
        dictgen::InsensitiveStr::Ascii("owred"),
        dictgen::InsensitiveStr::Ascii("rised"),
    ],
    values: &[
        &["overpaid"],
        &["overpaid"],
        &["overpaid"],
        &["overpriced"],
        &["overpopulation"],
        &["overlooking"],
        &["overpopulation"],
        &["overpopulation"],
        &["overpowered"],
        &["overpowered"],
        &["overpowering"],
        &["overpowered"],
        &["overpowered"],
        &["overpriced"],
    ],
    range: 2..=9,
};

static WORD_OVERN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OVERN_CHILDREN),
    value: None,
};

pub static WORD_OVERN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("urfed")],
    values: &[&["overturned"]],
    range: 5..=5,
};

static WORD_OVERM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OVERM_CHILDREN),
    value: None,
};

pub static WORD_OVERM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("apping")],
    values: &[&["overlapping"]],
    range: 6..=6,
};

static WORD_OVERL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OVERL_CHILDREN),
    value: None,
};

pub static WORD_OVERL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("anded"),
        dictgen::InsensitiveStr::Ascii("aod"),
        dictgen::InsensitiveStr::Ascii("aoded"),
        dictgen::InsensitiveStr::Ascii("aped"),
        dictgen::InsensitiveStr::Ascii("aping"),
        dictgen::InsensitiveStr::Ascii("app"),
        dictgen::InsensitiveStr::Ascii("appping"),
        dictgen::InsensitiveStr::Ascii("apsing"),
        dictgen::InsensitiveStr::Ascii("auded"),
        dictgen::InsensitiveStr::Ascii("ayed"),
        dictgen::InsensitiveStr::Ascii("cock"),
        dictgen::InsensitiveStr::Ascii("cocked"),
        dictgen::InsensitiveStr::Ascii("cocking"),
        dictgen::InsensitiveStr::Ascii("coking"),
        dictgen::InsensitiveStr::Ascii("flow"),
        dictgen::InsensitiveStr::Ascii("flowed"),
        dictgen::InsensitiveStr::Ascii("flowing"),
        dictgen::InsensitiveStr::Ascii("flows"),
        dictgen::InsensitiveStr::Ascii("fow"),
        dictgen::InsensitiveStr::Ascii("fowed"),
        dictgen::InsensitiveStr::Ascii("fowing"),
        dictgen::InsensitiveStr::Ascii("fows"),
        dictgen::InsensitiveStr::Ascii("oard"),
        dictgen::InsensitiveStr::Ascii("oards"),
        dictgen::InsensitiveStr::Ascii("odaded"),
        dictgen::InsensitiveStr::Ascii("oded"),
        dictgen::InsensitiveStr::Ascii("odes"),
        dictgen::InsensitiveStr::Ascii("ooming"),
        dictgen::InsensitiveStr::Ascii("oooked"),
        dictgen::InsensitiveStr::Ascii("orded"),
        dictgen::InsensitiveStr::Ascii("ordes"),
        dictgen::InsensitiveStr::Ascii("ordess"),
        dictgen::InsensitiveStr::Ascii("ow"),
        dictgen::InsensitiveStr::Ascii("owed"),
        dictgen::InsensitiveStr::Ascii("owing"),
        dictgen::InsensitiveStr::Ascii("ows"),
    ],
    values: &[
        &["overloaded"],
        &["overload"],
        &["overloaded"],
        &["overlapped"],
        &["overlapping"],
        &["overlap"],
        &["overlapping"],
        &["overlapping"],
        &["overloaded"],
        &["overlaid"],
        &["overclock"],
        &["overclocked"],
        &["overclocking"],
        &["overlooking"],
        &["overflow"],
        &["overflowed"],
        &["overflowing"],
        &["overflows"],
        &["overflow"],
        &["overflowed"],
        &["overflowing"],
        &["overflows"],
        &["overload"],
        &["overload"],
        &["overloaded"],
        &["overloaded"],
        &["overloads"],
        &["overlooking"],
        &["overlooked"],
        &["overloaded"],
        &["overlords"],
        &["overlords"],
        &["overflow"],
        &["overflowed", "overloaded"],
        &["overflowing"],
        &["overflows"],
    ],
    range: 2..=7,
};

static WORD_OVERK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OVERK_CHILDREN),
    value: None,
};

pub static WORD_OVERK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("apping"),
        dictgen::InsensitiveStr::Ascii("locked"),
    ],
    values: &[&["overlapping"], &["overclocked"]],
    range: 6..=6,
};

static WORD_OVERI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OVERI_CHILDREN),
    value: None,
};

pub static WORD_OVERI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ddden"),
        dictgen::InsensitiveStr::Ascii("dden"),
        dictgen::InsensitiveStr::Ascii("de"),
        dictgen::InsensitiveStr::Ascii("den"),
        dictgen::InsensitiveStr::Ascii("des"),
        dictgen::InsensitiveStr::Ascii("ding"),
    ],
    values: &[
        &["overridden"],
        &["overridden"],
        &["override"],
        &["overridden"],
        &["overrides"],
        &["overriding"],
    ],
    range: 2..=5,
};

static WORD_OVERH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OVERH_CHILDREN),
    value: None,
};

pub static WORD_OVERH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("al"),
        dictgen::InsensitiveStr::Ascii("eading"),
        dictgen::InsensitiveStr::Ascii("eards"),
        dictgen::InsensitiveStr::Ascii("eared"),
        dictgen::InsensitiveStr::Ascii("earting"),
        dictgen::InsensitiveStr::Ascii("eathing"),
        dictgen::InsensitiveStr::Ascii("ooked"),
        dictgen::InsensitiveStr::Ascii("ooking"),
        dictgen::InsensitiveStr::Ascii("pyed"),
        dictgen::InsensitiveStr::Ascii("read"),
        dictgen::InsensitiveStr::Ascii("tinking"),
        dictgen::InsensitiveStr::Ascii("ual"),
        dictgen::InsensitiveStr::Ascii("welm"),
        dictgen::InsensitiveStr::Ascii("welmed"),
        dictgen::InsensitiveStr::Ascii("welming"),
        dictgen::InsensitiveStr::Ascii("welmingly"),
        dictgen::InsensitiveStr::Ascii("wlemingly"),
    ],
    values: &[
        &["overhaul"],
        &["overheating"],
        &["overhead"],
        &["overhead"],
        &["overreacting"],
        &["overheating"],
        &["overlooked"],
        &["overlooking"],
        &["overhyped"],
        &["overhead"],
        &["overthinking"],
        &["overhaul"],
        &["overwhelm"],
        &["overwhelmed"],
        &["overwhelming"],
        &["overwhelmingly"],
        &["overwhelmingly"],
    ],
    range: 2..=9,
};

static WORD_OVERF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OVERF_CHILDREN),
    value: None,
};

pub static WORD_OVERF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("apping"),
        dictgen::InsensitiveStr::Ascii("l"),
        dictgen::InsensitiveStr::Ascii("lw"),
        dictgen::InsensitiveStr::Ascii("ow"),
        dictgen::InsensitiveStr::Ascii("owed"),
        dictgen::InsensitiveStr::Ascii("owing"),
        dictgen::InsensitiveStr::Ascii("ows"),
    ],
    values: &[
        &["overlapping"],
        &["overflow"],
        &["overflow"],
        &["overflow"],
        &["overflowed"],
        &["overflowing"],
        &["overflows"],
    ],
    range: 1..=6,
};

static WORD_OVERE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OVERE_CHILDREN),
    value: None,
};

pub static WORD_OVERE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aching"),
        dictgen::InsensitiveStr::Ascii("ngeneer"),
        dictgen::InsensitiveStr::Ascii("ngeneering"),
        dictgen::InsensitiveStr::Ascii("stemating"),
        dictgen::InsensitiveStr::Ascii("stimateing"),
        dictgen::InsensitiveStr::Ascii("xtimating"),
    ],
    values: &[
        &["overarching"],
        &["overengineer"],
        &["overengineering"],
        &["overestimating"],
        &["overestimating"],
        &["overestimating"],
    ],
    range: 6..=10,
};

static WORD_OVERD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OVERD_CHILDREN),
    value: None,
};

pub static WORD_OVERD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("irve"),
        dictgen::InsensitiveStr::Ascii("rev"),
    ],
    values: &[&["overdrive"], &["overdrive"]],
    range: 3..=4,
};

static WORD_OVERC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OVERC_CHILDREN),
    value: None,
};

pub static WORD_OVERC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("apping"),
        dictgen::InsensitiveStr::Ascii("haring"),
        dictgen::InsensitiveStr::Ascii("lcok"),
        dictgen::InsensitiveStr::Ascii("lcoked"),
        dictgen::InsensitiveStr::Ascii("lcoking"),
        dictgen::InsensitiveStr::Ascii("licked"),
        dictgen::InsensitiveStr::Ascii("licking"),
        dictgen::InsensitiveStr::Ascii("loaked"),
        dictgen::InsensitiveStr::Ascii("loaking"),
        dictgen::InsensitiveStr::Ascii("locing"),
        dictgen::InsensitiveStr::Ascii("lockd"),
        dictgen::InsensitiveStr::Ascii("lockig"),
        dictgen::InsensitiveStr::Ascii("lockign"),
        dictgen::InsensitiveStr::Ascii("locled"),
        dictgen::InsensitiveStr::Ascii("lok"),
        dictgen::InsensitiveStr::Ascii("lokcing"),
        dictgen::InsensitiveStr::Ascii("loked"),
        dictgen::InsensitiveStr::Ascii("oding"),
        dictgen::InsensitiveStr::Ascii("omeing"),
        dictgen::InsensitiveStr::Ascii("omming"),
        dictgen::InsensitiveStr::Ascii("ompansate"),
        dictgen::InsensitiveStr::Ascii("ompansated"),
        dictgen::InsensitiveStr::Ascii("ompansates"),
        dictgen::InsensitiveStr::Ascii("ompansating"),
        dictgen::InsensitiveStr::Ascii("ompansation"),
        dictgen::InsensitiveStr::Ascii("ompansations"),
    ],
    values: &[
        &["overlapping"],
        &["overarching"],
        &["overclock"],
        &["overclocked"],
        &["overclocking"],
        &["overclocked"],
        &["overclocking"],
        &["overclocked"],
        &["overclocking"],
        &["overclocking"],
        &["overclocked"],
        &["overclocking"],
        &["overclocking"],
        &["overclocked"],
        &["overclock"],
        &["overclocking"],
        &["overclocked"],
        &["overcoming"],
        &["overcoming"],
        &["overcoming"],
        &["overcompensate"],
        &["overcompensated"],
        &["overcompensates"],
        &["overcompensating"],
        &["overcompensation"],
        &["overcompensations"],
    ],
    range: 3..=12,
};

static WORD_OVERB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OVERB_CHILDREN),
    value: None,
};

pub static WORD_OVERB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aord"),
        dictgen::InsensitiveStr::Ascii("earring"),
        dictgen::InsensitiveStr::Ascii("locking"),
        dictgen::InsensitiveStr::Ascii("oad"),
        dictgen::InsensitiveStr::Ascii("raking"),
    ],
    values: &[
        &["overboard"],
        &["overbearing"],
        &["overclocking"],
        &["overboard"],
        &["overbearing"],
    ],
    range: 3..=7,
};

static WORD_OVERA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OVERA_CHILDREN),
    value: None,
};

pub static WORD_OVERA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("all"),
        dictgen::InsensitiveStr::Ascii("l"),
        dictgen::InsensitiveStr::Ascii("nd"),
        dictgen::InsensitiveStr::Ascii("nds"),
        dictgen::InsensitiveStr::Ascii("rcing"),
    ],
    values: &[
        &["overall"],
        &["overall"],
        &["operand"],
        &["operands"],
        &["overarching"],
    ],
    range: 1..=5,
};

static WORD_OVEL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OVEL_CHILDREN),
    value: None,
};

pub static WORD_OVEL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ap"),
        dictgen::InsensitiveStr::Ascii("apping"),
    ],
    values: &[&["overlap"], &["overlapping"]],
    range: 2..=6,
};

static WORD_OVEF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OVEF_CHILDREN),
    value: None,
};

pub static WORD_OVEF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("low"),
        dictgen::InsensitiveStr::Ascii("lowed"),
        dictgen::InsensitiveStr::Ascii("lowing"),
        dictgen::InsensitiveStr::Ascii("lows"),
    ],
    values: &[
        &["overflow"],
        &["overflowed"],
        &["overflowing"],
        &["overflows"],
    ],
    range: 3..=6,
};

static WORD_OVEE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OVEE_CHILDREN),
    value: None,
};

pub static WORD_OVEE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("run")],
    values: &[&["overrun"]],
    range: 3..=3,
};

static WORD_OU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_OU_CHILDREN),
    value: None,
};

static WORD_OU_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    Some(&WORD_OUB_NODE),
    None,
    None,
    Some(&WORD_OUE_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_OUL_NODE),
    None,
    Some(&WORD_OUN_NODE),
    None,
    Some(&WORD_OUP_NODE),
    None,
    Some(&WORD_OUR_NODE),
    Some(&WORD_OUS_NODE),
    Some(&WORD_OUT_NODE),
    Some(&WORD_OUU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_OUU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OUU_CHILDREN),
    value: None,
};

pub static WORD_OUU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("r"),
        dictgen::InsensitiveStr::Ascii("rs"),
    ],
    values: &[&["our"], &["ours"]],
    range: 1..=2,
};

static WORD_OUT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_OUT_CHILDREN),
    value: None,
};

static WORD_OUT_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    Some(&WORD_OUTB_NODE),
    Some(&WORD_OUTC_NODE),
    None,
    None,
    Some(&WORD_OUTF_NODE),
    Some(&WORD_OUTG_NODE),
    Some(&WORD_OUTH_NODE),
    Some(&WORD_OUTI_NODE),
    None,
    None,
    Some(&WORD_OUTL_NODE),
    None,
    Some(&WORD_OUTN_NODE),
    Some(&WORD_OUTO_NODE),
    Some(&WORD_OUTP_NODE),
    None,
    Some(&WORD_OUTR_NODE),
    Some(&WORD_OUTS_NODE),
    Some(&WORD_OUTT_NODE),
    Some(&WORD_OUTU_NODE),
    None,
    Some(&WORD_OUTW_NODE),
    None,
    None,
    None,
];

static WORD_OUTW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OUTW_CHILDREN),
    value: None,
};

pub static WORD_OUTW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eighes"),
        dictgen::InsensitiveStr::Ascii("eight"),
        dictgen::InsensitiveStr::Ascii("eights"),
        dictgen::InsensitiveStr::Ascii("ieghs"),
    ],
    values: &[
        &["outweighs"],
        &["outweigh"],
        &["outweighs"],
        &["outweighs"],
    ],
    range: 5..=6,
};

static WORD_OUTU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OUTU_CHILDREN),
    value: None,
};

pub static WORD_OUTU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("pt"),
        dictgen::InsensitiveStr::Ascii("pts"),
        dictgen::InsensitiveStr::Ascii("put"),
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("ts"),
    ],
    values: &[
        &["output"],
        &["outputs"],
        &["output"],
        &["output"],
        &["outputs"],
    ],
    range: 1..=3,
};

static WORD_OUTT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OUTT_CHILDREN),
    value: None,
};

pub static WORD_OUTT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("er"),
        dictgen::InsensitiveStr::Ascii("ermost"),
    ],
    values: &[&["outer"], &["outermost"]],
    range: 2..=6,
};

static WORD_OUTS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OUTS_CHILDREN),
    value: None,
};

pub static WORD_OUTS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("elves"),
        dictgen::InsensitiveStr::Ascii("id"),
        dictgen::InsensitiveStr::Ascii("idr"),
        dictgen::InsensitiveStr::Ascii("kirst"),
        dictgen::InsensitiveStr::Ascii("kirters"),
        dictgen::InsensitiveStr::Ascii("krits"),
        dictgen::InsensitiveStr::Ascii("orucing"),
        dictgen::InsensitiveStr::Ascii("ourcad"),
        dictgen::InsensitiveStr::Ascii("ourcade"),
        dictgen::InsensitiveStr::Ascii("ourceing"),
        dictgen::InsensitiveStr::Ascii("oure"),
        dictgen::InsensitiveStr::Ascii("ouring"),
        dictgen::InsensitiveStr::Ascii("oursed"),
        dictgen::InsensitiveStr::Ascii("oursing"),
    ],
    values: &[
        &["ourselves"],
        &["outside"],
        &["outsider"],
        &["outskirts"],
        &["outskirts"],
        &["outskirts"],
        &["outsourcing"],
        &["outsourced"],
        &["outsourced"],
        &["outsourcing"],
        &["outsourced"],
        &["outsourcing"],
        &["outsourced"],
        &["outsourcing"],
    ],
    range: 2..=8,
};

static WORD_OUTR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OUTR_CHILDREN),
    value: None,
};

pub static WORD_OUTR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aegously"),
        dictgen::InsensitiveStr::Ascii("ageos"),
        dictgen::InsensitiveStr::Ascii("ageosly"),
        dictgen::InsensitiveStr::Ascii("ageoulsy"),
        dictgen::InsensitiveStr::Ascii("ageouly"),
        dictgen::InsensitiveStr::Ascii("agerous"),
        dictgen::InsensitiveStr::Ascii("agesouly"),
        dictgen::InsensitiveStr::Ascii("ageuos"),
        dictgen::InsensitiveStr::Ascii("ageuosly"),
        dictgen::InsensitiveStr::Ascii("agious"),
        dictgen::InsensitiveStr::Ascii("agiously"),
        dictgen::InsensitiveStr::Ascii("agoues"),
        dictgen::InsensitiveStr::Ascii("eagous"),
        dictgen::InsensitiveStr::Ascii("side"),
    ],
    values: &[
        &["outrageously"],
        &["outrageous"],
        &["outrageously"],
        &["outrageously"],
        &["outrageously"],
        &["outrageous"],
        &["outrageously"],
        &["outrageous"],
        &["outrageously"],
        &["outrageous"],
        &["outrageously"],
        &["outrageous"],
        &["outrageous"],
        &["outside"],
    ],
    range: 4..=8,
};

static WORD_OUTP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OUTP_CHILDREN),
    value: None,
};

pub static WORD_OUTP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("alyed"),
        dictgen::InsensitiveStr::Ascii("erfoem"),
        dictgen::InsensitiveStr::Ascii("erfoeming"),
        dictgen::InsensitiveStr::Ascii("erfom"),
        dictgen::InsensitiveStr::Ascii("erfome"),
        dictgen::InsensitiveStr::Ascii("erfomeing"),
        dictgen::InsensitiveStr::Ascii("erfoming"),
        dictgen::InsensitiveStr::Ascii("erfomr"),
        dictgen::InsensitiveStr::Ascii("erfomring"),
        dictgen::InsensitiveStr::Ascii("erfoms"),
        dictgen::InsensitiveStr::Ascii("erfrom"),
        dictgen::InsensitiveStr::Ascii("erfroms"),
        dictgen::InsensitiveStr::Ascii("layd"),
        dictgen::InsensitiveStr::Ascii("out"),
        dictgen::InsensitiveStr::Ascii("outs"),
        dictgen::InsensitiveStr::Ascii("reform"),
        dictgen::InsensitiveStr::Ascii("reforms"),
        dictgen::InsensitiveStr::Ascii("soken"),
        dictgen::InsensitiveStr::Ascii("upt"),
        dictgen::InsensitiveStr::Ascii("us"),
        dictgen::InsensitiveStr::Ascii("ust"),
        dictgen::InsensitiveStr::Ascii("usts"),
        dictgen::InsensitiveStr::Ascii("uted"),
        dictgen::InsensitiveStr::Ascii("uting"),
    ],
    values: &[
        &["outplayed"],
        &["outperform"],
        &["outperforming"],
        &["outperform"],
        &["outperform"],
        &["outperforming"],
        &["outperforming"],
        &["outperform"],
        &["outperforming"],
        &["outperform"],
        &["outperform"],
        &["outperform"],
        &["outplayed"],
        &["output"],
        &["outputs"],
        &["outperform"],
        &["outperform"],
        &["outspoken"],
        &["output"],
        &["output", "outputs"],
        &["output", "outputs"],
        &["outputs"],
        &["outputted"],
        &["outputting"],
    ],
    range: 2..=9,
};

static WORD_OUTO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OUTO_CHILDREN),
    value: None,
};

pub static WORD_OUTO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ign"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("ut"),
    ],
    values: &[
        &["outgoing"],
        &["outdoing", "outgoing", "outing"],
        &["output"],
    ],
    range: 2..=3,
};

static WORD_OUTN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OUTN_CHILDREN),
    value: None,
};

pub static WORD_OUTN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("umbed"),
        dictgen::InsensitiveStr::Ascii("umberd"),
        dictgen::InsensitiveStr::Ascii("umbred"),
        dictgen::InsensitiveStr::Ascii("unbered"),
    ],
    values: &[
        &["outnumbered"],
        &["outnumbered"],
        &["outnumbered"],
        &["outnumbered"],
    ],
    range: 5..=7,
};

static WORD_OUTL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OUTL_CHILDREN),
    value: None,
};

pub static WORD_OUTL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cassed"),
        dictgen::InsensitiveStr::Ascii("look"),
    ],
    values: &[&["outclassed"], &["outlook"]],
    range: 4..=6,
};

static WORD_OUTI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OUTI_CHILDREN),
    value: None,
};

pub static WORD_OUTI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("sde"),
        dictgen::InsensitiveStr::Ascii("sder"),
        dictgen::InsensitiveStr::Ascii("sders"),
    ],
    values: &[&["outside"], &["outsider"], &["outsiders"]],
    range: 3..=5,
};

static WORD_OUTH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OUTH_CHILDREN),
    value: None,
};

pub static WORD_OUTH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("er")],
    values: &[&["other", "outer"]],
    range: 2..=2,
};

static WORD_OUTG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OUTG_CHILDREN),
    value: None,
};

pub static WORD_OUTG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("oign")],
    values: &[&["outgoing"]],
    range: 4..=4,
};

static WORD_OUTF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OUTF_CHILDREN),
    value: None,
};

pub static WORD_OUTF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eild"),
        dictgen::InsensitiveStr::Ascii("idel"),
        dictgen::InsensitiveStr::Ascii("ied"),
        dictgen::InsensitiveStr::Ascii("iled"),
    ],
    values: &[&["outfield"], &["outfield"], &["outfield"], &["outfield"]],
    range: 3..=4,
};

static WORD_OUTC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OUTC_CHILDREN),
    value: None,
};

pub static WORD_OUTC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("alssed"),
        dictgen::InsensitiveStr::Ascii("lasssed"),
    ],
    values: &[&["outclassed"], &["outclassed"]],
    range: 6..=7,
};

static WORD_OUTB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OUTB_CHILDREN),
    value: None,
};

pub static WORD_OUTB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ut"),
        dictgen::InsensitiveStr::Ascii("uts"),
    ],
    values: &[&["output"], &["outputs"]],
    range: 2..=3,
};

static WORD_OUS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OUS_CHILDREN),
    value: None,
};

pub static WORD_OUS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ide"),
        dictgen::InsensitiveStr::Ascii("tanding"),
        dictgen::InsensitiveStr::Ascii("tide"),
        dictgen::InsensitiveStr::Ascii("tider"),
        dictgen::InsensitiveStr::Ascii("tiders"),
        dictgen::InsensitiveStr::Ascii("tpoken"),
    ],
    values: &[
        &["outside"],
        &["outstanding"],
        &["outside"],
        &["outsider"],
        &["outsiders"],
        &["outspoken"],
    ],
    range: 3..=7,
};

static WORD_OUR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OUR_CHILDREN),
    value: None,
};

pub static WORD_OUR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("selfe"),
        dictgen::InsensitiveStr::Ascii("selfes"),
        dictgen::InsensitiveStr::Ascii("selfs"),
        dictgen::InsensitiveStr::Ascii("selv"),
        dictgen::InsensitiveStr::Ascii("selve"),
        dictgen::InsensitiveStr::Ascii("selvs"),
        dictgen::InsensitiveStr::Ascii("sleves"),
    ],
    values: &[
        &["ourselves", "ourself"],
        &["ourselves"],
        &["ourselves"],
        &["ourself", "ourselves"],
        &["ourself", "ourselves"],
        &["ourselves"],
        &["ourselves"],
    ],
    range: 4..=6,
};

static WORD_OUP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OUP_CHILDREN),
    value: None,
};

pub static WORD_OUP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("tut"),
        dictgen::InsensitiveStr::Ascii("tuted"),
        dictgen::InsensitiveStr::Ascii("tuting"),
        dictgen::InsensitiveStr::Ascii("tuts"),
        dictgen::InsensitiveStr::Ascii("ut"),
        dictgen::InsensitiveStr::Ascii("utarea"),
        dictgen::InsensitiveStr::Ascii("uts"),
        dictgen::InsensitiveStr::Ascii("utted"),
        dictgen::InsensitiveStr::Ascii("utting"),
    ],
    values: &[
        &["output"],
        &["outputted"],
        &["outputting"],
        &["outputs"],
        &["output"],
        &["outputarea"],
        &["outputs"],
        &["outputted"],
        &["outputting"],
    ],
    range: 2..=6,
};

static WORD_OUN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OUN_CHILDREN),
    value: None,
};

pub static WORD_OUN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("tline")],
    values: &[&["outline"]],
    range: 5..=5,
};

static WORD_OUL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OUL_CHILDREN),
    value: None,
};

pub static WORD_OUL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("tinenodes"),
        dictgen::InsensitiveStr::Ascii("tiner"),
        dictgen::InsensitiveStr::Ascii("tline"),
        dictgen::InsensitiveStr::Ascii("tlines"),
    ],
    values: &[
        &["outlinenodes"],
        &["outliner"],
        &["outline"],
        &["outlines"],
    ],
    range: 5..=9,
};

static WORD_OUE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OUE_CHILDREN),
    value: None,
};

pub static WORD_OUE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("r"),
        dictgen::InsensitiveStr::Ascii("vre"),
    ],
    values: &[&["outer"], &["oeuvre"]],
    range: 1..=3,
};

static WORD_OUB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OUB_CHILDREN),
    value: None,
};

pub static WORD_OUB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("lisher")],
    values: &[&["publisher"]],
    range: 6..=6,
};

static WORD_OT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_OT_CHILDREN),
    value: Some(&["to", "of", "or", "not"]),
};

static WORD_OT_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_OTA_NODE),
    None,
    None,
    None,
    Some(&WORD_OTE_NODE),
    None,
    None,
    Some(&WORD_OTH_NODE),
    Some(&WORD_OTI_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_OTP_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_OTU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_OTU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OTU_CHILDREN),
    value: Some(&["out"]),
};

pub static WORD_OTU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[],
    values: &[],
    range: 0..=0,
};

static WORD_OTP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OTP_CHILDREN),
    value: None,
};

pub static WORD_OTP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ion"),
        dictgen::InsensitiveStr::Ascii("ions"),
        dictgen::InsensitiveStr::Ascii("ut"),
    ],
    values: &[&["option"], &["options"], &["output"]],
    range: 2..=4,
};

static WORD_OTI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OTI_CHILDREN),
    value: None,
};

pub static WORD_OTI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("fication"),
        dictgen::InsensitiveStr::Ascii("fications"),
        dictgen::InsensitiveStr::Ascii("ginal"),
        dictgen::InsensitiveStr::Ascii("on"),
        dictgen::InsensitiveStr::Ascii("onal"),
        dictgen::InsensitiveStr::Ascii("onally"),
        dictgen::InsensitiveStr::Ascii("ons"),
    ],
    values: &[
        &["notification"],
        &["notifications"],
        &["original"],
        &["option"],
        &["optional", "notional"],
        &["optionally"],
        &["options"],
    ],
    range: 2..=9,
};

static WORD_OTH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OTH_CHILDREN),
    value: None,
};

pub static WORD_OTH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("ere"),
        dictgen::InsensitiveStr::Ascii("erewise"),
        dictgen::InsensitiveStr::Ascii("erise"),
        dictgen::InsensitiveStr::Ascii("eriwse"),
        dictgen::InsensitiveStr::Ascii("ersie"),
        dictgen::InsensitiveStr::Ascii("erwaise"),
        dictgen::InsensitiveStr::Ascii("erways"),
        dictgen::InsensitiveStr::Ascii("erweis"),
        dictgen::InsensitiveStr::Ascii("erweise"),
        dictgen::InsensitiveStr::Ascii("erwhere"),
        dictgen::InsensitiveStr::Ascii("erwhile"),
        dictgen::InsensitiveStr::Ascii("erwhise"),
        dictgen::InsensitiveStr::Ascii("erwice"),
        dictgen::InsensitiveStr::Ascii("erwide"),
        dictgen::InsensitiveStr::Ascii("erwis"),
        dictgen::InsensitiveStr::Ascii("erwize"),
        dictgen::InsensitiveStr::Ascii("erwordly"),
        dictgen::InsensitiveStr::Ascii("erwose"),
        dictgen::InsensitiveStr::Ascii("erwrite"),
        dictgen::InsensitiveStr::Ascii("erws"),
        dictgen::InsensitiveStr::Ascii("erwse"),
        dictgen::InsensitiveStr::Ascii("erwsie"),
        dictgen::InsensitiveStr::Ascii("erwsise"),
        dictgen::InsensitiveStr::Ascii("erwuise"),
        dictgen::InsensitiveStr::Ascii("erwwise"),
        dictgen::InsensitiveStr::Ascii("erwyse"),
        dictgen::InsensitiveStr::Ascii("ewice"),
        dictgen::InsensitiveStr::Ascii("ewise"),
        dictgen::InsensitiveStr::Ascii("ewize"),
        dictgen::InsensitiveStr::Ascii("o"),
        dictgen::InsensitiveStr::Ascii("ographic"),
        dictgen::InsensitiveStr::Ascii("rodox"),
        dictgen::InsensitiveStr::Ascii("werise"),
        dictgen::InsensitiveStr::Ascii("werwise"),
        dictgen::InsensitiveStr::Ascii("whise"),
    ],
    values: &[
        &["other"],
        &["other"],
        &["otherwise"],
        &["otherwise"],
        &["otherwise"],
        &["otherwise"],
        &["otherwise"],
        &["otherwise"],
        &["otherwise"],
        &["otherwise"],
        &["elsewhere"],
        &["otherwise"],
        &["otherwise"],
        &["otherwise"],
        &["otherwise"],
        &["otherwise"],
        &["otherwise"],
        &["otherworldly"],
        &["otherwise"],
        &["overwrite"],
        &["otherwise"],
        &["otherwise"],
        &["otherwise"],
        &["otherwise"],
        &["otherwise"],
        &["otherwise"],
        &["otherwise"],
        &["otherwise"],
        &["otherwise"],
        &["otherwise"],
        &["otoh"],
        &["orthographic"],
        &["orthodox"],
        &["otherwise"],
        &["otherwise"],
        &["otherwise"],
    ],
    range: 1..=8,
};

static WORD_OTE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OTE_CHILDREN),
    value: None,
};

pub static WORD_OTE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("hr"),
        dictgen::InsensitiveStr::Ascii("hrwice"),
        dictgen::InsensitiveStr::Ascii("hrwise"),
        dictgen::InsensitiveStr::Ascii("hrwize"),
        dictgen::InsensitiveStr::Ascii("r"),
        dictgen::InsensitiveStr::Ascii("rwice"),
        dictgen::InsensitiveStr::Ascii("rwise"),
        dictgen::InsensitiveStr::Ascii("rwize"),
    ],
    values: &[
        &["other"],
        &["otherwise"],
        &["otherwise"],
        &["otherwise"],
        &["other", "otter"],
        &["otherwise"],
        &["otherwise"],
        &["otherwise"],
    ],
    range: 1..=6,
};

static WORD_OTA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OTA_CHILDREN),
    value: None,
};

pub static WORD_OTA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("in"),
        dictgen::InsensitiveStr::Ascii("ined"),
        dictgen::InsensitiveStr::Ascii("ins"),
        dictgen::InsensitiveStr::Ascii("te"),
        dictgen::InsensitiveStr::Ascii("ted"),
        dictgen::InsensitiveStr::Ascii("tes"),
        dictgen::InsensitiveStr::Ascii("ting"),
        dictgen::InsensitiveStr::Ascii("tion"),
        dictgen::InsensitiveStr::Ascii("tions"),
    ],
    values: &[
        &["obtain"],
        &["obtained"],
        &["obtains"],
        &["notate", "rotate"],
        &["notated", "rotated"],
        &["notates", "rotates"],
        &["notating", "rotating"],
        &["notation", "rotation"],
        &["notations", "rotations"],
    ],
    range: 2..=5,
};

static WORD_OS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OS_CHILDREN),
    value: None,
};

pub static WORD_OS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("bidian"),
        dictgen::InsensitiveStr::Ascii("bscure"),
        dictgen::InsensitiveStr::Ascii("ciallator"),
        dictgen::InsensitiveStr::Ascii("cilate"),
        dictgen::InsensitiveStr::Ascii("cilated"),
        dictgen::InsensitiveStr::Ascii("cilating"),
        dictgen::InsensitiveStr::Ascii("cilator"),
        dictgen::InsensitiveStr::Ascii("cillater"),
        dictgen::InsensitiveStr::Ascii("cillaters"),
        dictgen::InsensitiveStr::Ascii("cilliscope"),
        dictgen::InsensitiveStr::Ascii("cilliscopes"),
        dictgen::InsensitiveStr::Ascii("ffset"),
        dictgen::InsensitiveStr::Ascii("ffsets"),
        dictgen::InsensitiveStr::Ascii("ffsetting"),
        dictgen::InsensitiveStr::Ascii("icllations"),
        dictgen::InsensitiveStr::Ascii("tencibly"),
        dictgen::InsensitiveStr::Ascii("tenisbly"),
        dictgen::InsensitiveStr::Ascii("tensably"),
        dictgen::InsensitiveStr::Ascii("tensiably"),
        dictgen::InsensitiveStr::Ascii("tensibily"),
        dictgen::InsensitiveStr::Ascii("tentibly"),
        dictgen::InsensitiveStr::Ascii("terage"),
        dictgen::InsensitiveStr::Ascii("terages"),
        dictgen::InsensitiveStr::Ascii("trasiced"),
        dictgen::InsensitiveStr::Ascii("trasized"),
        dictgen::InsensitiveStr::Ascii("traziced"),
        dictgen::InsensitiveStr::Ascii("trazised"),
        dictgen::InsensitiveStr::Ascii("trecized"),
        dictgen::InsensitiveStr::Ascii("tricized"),
        dictgen::InsensitiveStr::Ascii("tridge"),
        dictgen::InsensitiveStr::Ascii("tridges"),
        dictgen::InsensitiveStr::Ascii("trocized"),
    ],
    values: &[
        &["obsidian"],
        &["obscure"],
        &["oscillator"],
        &["oscillate"],
        &["oscillated"],
        &["oscillating"],
        &["oscillator"],
        &["oscillator"],
        &["oscillators"],
        &["oscilloscope"],
        &["oscilloscopes"],
        &["offset"],
        &["offsets"],
        &["offsetting"],
        &["oscillations"],
        &["ostensibly"],
        &["ostensibly"],
        &["ostensibly"],
        &["ostensibly"],
        &["ostensibly"],
        &["ostensibly"],
        &["ostrich"],
        &["ostriches"],
        &["ostracized"],
        &["ostracized"],
        &["ostracized"],
        &["ostracised"],
        &["ostracized"],
        &["ostracized"],
        &["ostrich"],
        &["ostriches"],
        &["ostracized"],
    ],
    range: 5..=11,
};

static WORD_OR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_OR_CHILDREN),
    value: None,
};

static WORD_OR_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_ORA_NODE),
    Some(&WORD_ORB_NODE),
    Some(&WORD_ORC_NODE),
    Some(&WORD_ORD_NODE),
    Some(&WORD_ORE_NODE),
    Some(&WORD_ORF_NODE),
    Some(&WORD_ORG_NODE),
    Some(&WORD_ORH_NODE),
    Some(&WORD_ORI_NODE),
    None,
    Some(&WORD_ORK_NODE),
    Some(&WORD_ORL_NODE),
    None,
    None,
    None,
    Some(&WORD_ORP_NODE),
    None,
    Some(&WORD_ORR_NODE),
    None,
    Some(&WORD_ORT_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_ORT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ORT_CHILDREN),
    value: None,
};

pub static WORD_ORT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("hagnal"),
        dictgen::InsensitiveStr::Ascii("hagonal"),
        dictgen::InsensitiveStr::Ascii("hagonalize"),
        dictgen::InsensitiveStr::Ascii("hodx"),
        dictgen::InsensitiveStr::Ascii("hoganal"),
        dictgen::InsensitiveStr::Ascii("hoganalize"),
        dictgen::InsensitiveStr::Ascii("hognal"),
        dictgen::InsensitiveStr::Ascii("honormalizatin"),
        dictgen::InsensitiveStr::Ascii("ogonal"),
        dictgen::InsensitiveStr::Ascii("ogonality"),
    ],
    values: &[
        &["orthogonal"],
        &["orthogonal"],
        &["orthogonalize"],
        &["orthodox"],
        &["orthogonal"],
        &["orthogonalize"],
        &["orthogonal"],
        &["orthonormalization"],
        &["orthogonal"],
        &["orthogonality"],
    ],
    range: 4..=14,
};

static WORD_ORR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ORR_CHILDREN),
    value: None,
};

pub static WORD_ORR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("iginal")],
    values: &[&["original"]],
    range: 6..=6,
};

static WORD_ORP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ORP_CHILDREN),
    value: None,
};

pub static WORD_ORP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ahns"),
        dictgen::InsensitiveStr::Ascii("an"),
        dictgen::InsensitiveStr::Ascii("anage"),
        dictgen::InsensitiveStr::Ascii("aned"),
        dictgen::InsensitiveStr::Ascii("ans"),
        dictgen::InsensitiveStr::Ascii("hanes"),
    ],
    values: &[
        &["orphans"],
        &["orphan"],
        &["orphanage"],
        &["orphaned"],
        &["orphans"],
        &["orphans"],
    ],
    range: 2..=5,
};

static WORD_ORL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ORL_CHILDREN),
    value: None,
};

pub static WORD_ORL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("enas")],
    values: &[&["orleans"]],
    range: 4..=4,
};

static WORD_ORK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ORK_CHILDREN),
    value: None,
};

pub static WORD_ORK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("id"),
        dictgen::InsensitiveStr::Ascii("ids"),
    ],
    values: &[&["orchid"], &["orchids"]],
    range: 2..=3,
};

static WORD_ORI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_ORI_CHILDREN),
    value: None,
};

static WORD_ORI_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_ORIA_NODE),
    Some(&WORD_ORIB_NODE),
    Some(&WORD_ORIC_NODE),
    Some(&WORD_ORID_NODE),
    Some(&WORD_ORIE_NODE),
    None,
    Some(&WORD_ORIG_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_ORIN_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_ORIN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ORIN_CHILDREN),
    value: None,
};

pub static WORD_ORIN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("gal"),
        dictgen::InsensitiveStr::Ascii("gally"),
        dictgen::InsensitiveStr::Ascii("ginal"),
    ],
    values: &[&["original"], &["originally"], &["original"]],
    range: 3..=5,
};

static WORD_ORIG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ORIG_CHILDREN),
    value: None,
};

pub static WORD_ORIG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("analy"),
        dictgen::InsensitiveStr::Ascii("ial"),
        dictgen::InsensitiveStr::Ascii("ially"),
        dictgen::InsensitiveStr::Ascii("ianal"),
        dictgen::InsensitiveStr::Ascii("ianally"),
        dictgen::InsensitiveStr::Ascii("ianaly"),
        dictgen::InsensitiveStr::Ascii("ianl"),
        dictgen::InsensitiveStr::Ascii("ianlly"),
        dictgen::InsensitiveStr::Ascii("ianls"),
        dictgen::InsensitiveStr::Ascii("igin"),
        dictgen::InsensitiveStr::Ascii("iginal"),
        dictgen::InsensitiveStr::Ascii("iginally"),
        dictgen::InsensitiveStr::Ascii("iginals"),
        dictgen::InsensitiveStr::Ascii("inales"),
        dictgen::InsensitiveStr::Ascii("inalet"),
        dictgen::InsensitiveStr::Ascii("inalis"),
        dictgen::InsensitiveStr::Ascii("inall"),
        dictgen::InsensitiveStr::Ascii("inallity"),
        dictgen::InsensitiveStr::Ascii("inalt"),
        dictgen::InsensitiveStr::Ascii("inalty"),
        dictgen::InsensitiveStr::Ascii("inaly"),
        dictgen::InsensitiveStr::Ascii("inas"),
        dictgen::InsensitiveStr::Ascii("ines"),
        dictgen::InsensitiveStr::Ascii("inial"),
        dictgen::InsensitiveStr::Ascii("inially"),
        dictgen::InsensitiveStr::Ascii("iniated"),
        dictgen::InsensitiveStr::Ascii("iniating"),
        dictgen::InsensitiveStr::Ascii("ininal"),
        dictgen::InsensitiveStr::Ascii("ininate"),
        dictgen::InsensitiveStr::Ascii("ininated"),
        dictgen::InsensitiveStr::Ascii("ininates"),
        dictgen::InsensitiveStr::Ascii("ininating"),
        dictgen::InsensitiveStr::Ascii("ining"),
        dictgen::InsensitiveStr::Ascii("innally"),
        dictgen::InsensitiveStr::Ascii("insl"),
        dictgen::InsensitiveStr::Ascii("intea"),
        dictgen::InsensitiveStr::Ascii("ion"),
        dictgen::InsensitiveStr::Ascii("ional"),
        dictgen::InsensitiveStr::Ascii("ionally"),
        dictgen::InsensitiveStr::Ascii("n"),
        dictgen::InsensitiveStr::Ascii("nal"),
        dictgen::InsensitiveStr::Ascii("nally"),
        dictgen::InsensitiveStr::Ascii("nate"),
        dictgen::InsensitiveStr::Ascii("nated"),
        dictgen::InsensitiveStr::Ascii("nates"),
        dictgen::InsensitiveStr::Ascii("nial"),
        dictgen::InsensitiveStr::Ascii("niality"),
        dictgen::InsensitiveStr::Ascii("nially"),
        dictgen::InsensitiveStr::Ascii("nials"),
        dictgen::InsensitiveStr::Ascii("niated"),
        dictgen::InsensitiveStr::Ascii("ninal"),
        dictgen::InsensitiveStr::Ascii("onally"),
        dictgen::InsensitiveStr::Ascii("onated"),
    ],
    values: &[
        &["originally"],
        &["original"],
        &["originally"],
        &["original"],
        &["originally"],
        &["originally"],
        &["original"],
        &["originally"],
        &["originals"],
        &["origin"],
        &["original"],
        &["originally"],
        &["originals"],
        &["originals"],
        &["originated"],
        &["originals"],
        &["original", "originally"],
        &["originality"],
        &["originality"],
        &["originality"],
        &["originally"],
        &["origins"],
        &["origins"],
        &["original"],
        &["originally"],
        &["originated"],
        &["originating"],
        &["original"],
        &["originate"],
        &["originated"],
        &["originates"],
        &["originating"],
        &["originating"],
        &["originally"],
        &["originals"],
        &["originate"],
        &["origin"],
        &["original"],
        &["originally"],
        &["origin"],
        &["original"],
        &["originally"],
        &["originate"],
        &["originated"],
        &["originates"],
        &["original"],
        &["originality"],
        &["originally"],
        &["originals"],
        &["originated"],
        &["original"],
        &["originally"],
        &["originated"],
    ],
    range: 1..=9,
};

static WORD_ORIE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ORIE_CHILDREN),
    value: None,
};

pub static WORD_ORIE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ation"),
        dictgen::InsensitiveStr::Ascii("ations"),
        dictgen::InsensitiveStr::Ascii("natate"),
        dictgen::InsensitiveStr::Ascii("natated"),
        dictgen::InsensitiveStr::Ascii("natation"),
        dictgen::InsensitiveStr::Ascii("nate"),
        dictgen::InsensitiveStr::Ascii("nation"),
        dictgen::InsensitiveStr::Ascii("ntacion"),
        dictgen::InsensitiveStr::Ascii("ntaion"),
        dictgen::InsensitiveStr::Ascii("ntarla"),
        dictgen::InsensitiveStr::Ascii("ntarlo"),
        dictgen::InsensitiveStr::Ascii("ntatied"),
        dictgen::InsensitiveStr::Ascii("ntato"),
        dictgen::InsensitiveStr::Ascii("nte"),
        dictgen::InsensitiveStr::Ascii("ntiation"),
        dictgen::InsensitiveStr::Ascii("ntied"),
        dictgen::InsensitiveStr::Ascii("ntned"),
        dictgen::InsensitiveStr::Ascii("tation"),
        dictgen::InsensitiveStr::Ascii("tations"),
    ],
    values: &[
        &["orientation"],
        &["orientations"],
        &["orientate"],
        &["orientated"],
        &["orientation"],
        &["orientate", "orient", "ornate"],
        &["orientation"],
        &["orientation"],
        &["orientation"],
        &["oriental"],
        &["oriental"],
        &["orientated"],
        &["orientation"],
        &["oriented"],
        &["orientation"],
        &["oriented"],
        &["oriented"],
        &["orientation"],
        &["orientations"],
    ],
    range: 3..=8,
};

static WORD_ORID_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ORID_CHILDREN),
    value: None,
};

pub static WORD_ORID_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("inal"),
        dictgen::InsensitiveStr::Ascii("inals"),
        dictgen::InsensitiveStr::Ascii("inarily"),
        dictgen::InsensitiveStr::Ascii("nary"),
    ],
    values: &[
        &["ordinal", "original"],
        &["ordinals"],
        &["ordinarily"],
        &["ordinary"],
    ],
    range: 4..=7,
};

static WORD_ORIC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ORIC_CHILDREN),
    value: None,
};

pub static WORD_ORIC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("le"),
        dictgen::InsensitiveStr::Ascii("les"),
    ],
    values: &[&["oracle"], &["oracles"]],
    range: 2..=3,
};

static WORD_ORIB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ORIB_CHILDREN),
    value: None,
};

pub static WORD_ORIB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("tal")],
    values: &[&["orbital"]],
    range: 3..=3,
};

static WORD_ORIA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ORIA_CHILDREN),
    value: None,
};

pub static WORD_ORIA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("nt"),
        dictgen::InsensitiveStr::Ascii("ntate"),
        dictgen::InsensitiveStr::Ascii("ntated"),
        dictgen::InsensitiveStr::Ascii("ntation"),
    ],
    values: &[
        &["orient"],
        &["orientate"],
        &["orientated"],
        &["orientation"],
    ],
    range: 2..=7,
};

static WORD_ORH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ORH_CHILDREN),
    value: None,
};

pub static WORD_ORH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cestra"),
        dictgen::InsensitiveStr::Ascii("pan"),
        dictgen::InsensitiveStr::Ascii("pans"),
        dictgen::InsensitiveStr::Ascii("todox"),
        dictgen::InsensitiveStr::Ascii("togonal"),
        dictgen::InsensitiveStr::Ascii("togonality"),
        dictgen::InsensitiveStr::Ascii("togonally"),
    ],
    values: &[
        &["orchestra"],
        &["orphan"],
        &["orphans"],
        &["orthodox"],
        &["orthogonal"],
        &["orthogonality"],
        &["orthogonally"],
    ],
    range: 3..=10,
};

static WORD_ORG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_ORG_CHILDREN),
    value: None,
};

static WORD_ORG_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_ORGA_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_ORGI_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_ORGN_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_ORGN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ORGN_CHILDREN),
    value: None,
};

pub static WORD_ORGN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aisation"),
        dictgen::InsensitiveStr::Ascii("aised"),
    ],
    values: &[&["organisations"], &["organised"]],
    range: 5..=8,
};

static WORD_ORGI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ORGI_CHILDREN),
    value: None,
};

pub static WORD_ORGI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ginal"),
        dictgen::InsensitiveStr::Ascii("ginally"),
        dictgen::InsensitiveStr::Ascii("ginals"),
        dictgen::InsensitiveStr::Ascii("n"),
        dictgen::InsensitiveStr::Ascii("nal"),
        dictgen::InsensitiveStr::Ascii("nally"),
        dictgen::InsensitiveStr::Ascii("nals"),
        dictgen::InsensitiveStr::Ascii("nasation"),
        dictgen::InsensitiveStr::Ascii("nasations"),
        dictgen::InsensitiveStr::Ascii("nate"),
        dictgen::InsensitiveStr::Ascii("nated"),
        dictgen::InsensitiveStr::Ascii("nates"),
        dictgen::InsensitiveStr::Ascii("nating"),
        dictgen::InsensitiveStr::Ascii("nazation"),
        dictgen::InsensitiveStr::Ascii("nazational"),
        dictgen::InsensitiveStr::Ascii("nazations"),
        dictgen::InsensitiveStr::Ascii("nial"),
        dictgen::InsensitiveStr::Ascii("nially"),
        dictgen::InsensitiveStr::Ascii("nials"),
        dictgen::InsensitiveStr::Ascii("niate"),
        dictgen::InsensitiveStr::Ascii("niated"),
        dictgen::InsensitiveStr::Ascii("niates"),
        dictgen::InsensitiveStr::Ascii("ninal"),
        dictgen::InsensitiveStr::Ascii("ninals"),
        dictgen::InsensitiveStr::Ascii("nisation"),
        dictgen::InsensitiveStr::Ascii("nisations"),
        dictgen::InsensitiveStr::Ascii("nised"),
        dictgen::InsensitiveStr::Ascii("nization"),
        dictgen::InsensitiveStr::Ascii("nizations"),
        dictgen::InsensitiveStr::Ascii("nize"),
        dictgen::InsensitiveStr::Ascii("nized"),
        dictgen::InsensitiveStr::Ascii("ns"),
        dictgen::InsensitiveStr::Ascii("nx"),
        dictgen::InsensitiveStr::Ascii("ny"),
    ],
    values: &[
        &["original"],
        &["originally"],
        &["originals"],
        &["origin", "organ"],
        &["original"],
        &["originally"],
        &["originals"],
        &["organisation"],
        &["organisations"],
        &["originate"],
        &["originated"],
        &["originates"],
        &["originating"],
        &["organization"],
        &["organizational"],
        &["organizations"],
        &["original"],
        &["originally"],
        &["originals"],
        &["originate"],
        &["originated"],
        &["originates"],
        &["original"],
        &["originals"],
        &["organisation"],
        &["organisations"],
        &["organised"],
        &["organization"],
        &["organizations"],
        &["organize"],
        &["organized"],
        &["origins", "organs"],
        &["originx"],
        &["originy"],
    ],
    range: 1..=10,
};

static WORD_ORGA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_ORGA_CHILDREN),
    value: None,
};

static WORD_ORGA_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_ORGAI_NODE),
    None,
    None,
    None,
    Some(&WORD_ORGAM_NODE),
    Some(&WORD_ORGAN_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_ORGAS_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_ORGAS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ORGAS_CHILDREN),
    value: None,
};

pub static WORD_ORGAS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("mes"),
        dictgen::InsensitiveStr::Ascii("mos"),
        dictgen::InsensitiveStr::Ascii("mus"),
    ],
    values: &[&["orgasms"], &["orgasms"], &["orgasms"]],
    range: 3..=3,
};

static WORD_ORGAN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_ORGAN_CHILDREN),
    value: None,
};

static WORD_ORGAN_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    None,
    None,
    Some(&WORD_ORGANE_NODE),
    None,
    None,
    None,
    Some(&WORD_ORGANI_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_ORGANS_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_ORGANZ_NODE),
];

static WORD_ORGANZ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ORGANZ_CHILDREN),
    value: None,
};

pub static WORD_ORGANZ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("iation"),
        dictgen::InsensitiveStr::Ascii("iational"),
        dictgen::InsensitiveStr::Ascii("iations"),
        dictgen::InsensitiveStr::Ascii("ie"),
        dictgen::InsensitiveStr::Ascii("ied"),
        dictgen::InsensitiveStr::Ascii("ier"),
        dictgen::InsensitiveStr::Ascii("iers"),
        dictgen::InsensitiveStr::Ascii("ies"),
        dictgen::InsensitiveStr::Ascii("iing"),
    ],
    values: &[
        &["organization"],
        &["organizational"],
        &["organizations"],
        &["organize"],
        &["organized"],
        &["organizer"],
        &["organizers"],
        &["organizes"],
        &["organizing"],
    ],
    range: 2..=8,
};

static WORD_ORGANS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ORGANS_CHILDREN),
    value: None,
};

pub static WORD_ORGANS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("iation"),
        dictgen::InsensitiveStr::Ascii("iations"),
        dictgen::InsensitiveStr::Ascii("ie"),
        dictgen::InsensitiveStr::Ascii("ied"),
        dictgen::InsensitiveStr::Ascii("ier"),
        dictgen::InsensitiveStr::Ascii("iers"),
        dictgen::InsensitiveStr::Ascii("ies"),
        dictgen::InsensitiveStr::Ascii("iing"),
        dictgen::InsensitiveStr::Ascii("im"),
        dictgen::InsensitiveStr::Ascii("ims"),
    ],
    values: &[
        &["organisation"],
        &["organisations"],
        &["organise"],
        &["organised"],
        &["organiser"],
        &["organisers"],
        &["organises"],
        &["organising"],
        &["organism"],
        &["organisms"],
    ],
    range: 2..=7,
};

static WORD_ORGANI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ORGANI_CHILDREN),
    value: None,
};

pub static WORD_ORGANI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("caly"),
        dictgen::InsensitiveStr::Ascii("ces"),
        dictgen::InsensitiveStr::Ascii("clly"),
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("m"),
        dictgen::InsensitiveStr::Ascii("ms"),
        dictgen::InsensitiveStr::Ascii("saion"),
        dictgen::InsensitiveStr::Ascii("saions"),
        dictgen::InsensitiveStr::Ascii("saiton"),
        dictgen::InsensitiveStr::Ascii("sate"),
        dictgen::InsensitiveStr::Ascii("sationens"),
        dictgen::InsensitiveStr::Ascii("sationers"),
        dictgen::InsensitiveStr::Ascii("sationnels"),
        dictgen::InsensitiveStr::Ascii("saton"),
        dictgen::InsensitiveStr::Ascii("satons"),
        dictgen::InsensitiveStr::Ascii("sche"),
        dictgen::InsensitiveStr::Ascii("sera"),
        dictgen::InsensitiveStr::Ascii("serad"),
        dictgen::InsensitiveStr::Ascii("sere"),
        dictgen::InsensitiveStr::Ascii("sert"),
        dictgen::InsensitiveStr::Ascii("sier"),
        dictgen::InsensitiveStr::Ascii("sim"),
        dictgen::InsensitiveStr::Ascii("sims"),
        dictgen::InsensitiveStr::Ascii("ske"),
        dictgen::InsensitiveStr::Ascii("smed"),
        dictgen::InsensitiveStr::Ascii("smen"),
        dictgen::InsensitiveStr::Ascii("smer"),
        dictgen::InsensitiveStr::Ascii("smes"),
        dictgen::InsensitiveStr::Ascii("smus"),
        dictgen::InsensitiveStr::Ascii("staion"),
        dictgen::InsensitiveStr::Ascii("staions"),
        dictgen::InsensitiveStr::Ascii("ste"),
        dictgen::InsensitiveStr::Ascii("sten"),
        dictgen::InsensitiveStr::Ascii("stion"),
        dictgen::InsensitiveStr::Ascii("stions"),
        dictgen::InsensitiveStr::Ascii("szed"),
        dictgen::InsensitiveStr::Ascii("tes"),
        dictgen::InsensitiveStr::Ascii("zacion"),
        dictgen::InsensitiveStr::Ascii("zacional"),
        dictgen::InsensitiveStr::Ascii("zaed"),
        dictgen::InsensitiveStr::Ascii("zaion"),
        dictgen::InsensitiveStr::Ascii("zaions"),
        dictgen::InsensitiveStr::Ascii("zaiton"),
        dictgen::InsensitiveStr::Ascii("zaitonal"),
        dictgen::InsensitiveStr::Ascii("zare"),
        dictgen::InsensitiveStr::Ascii("zarea"),
        dictgen::InsensitiveStr::Ascii("zarem"),
        dictgen::InsensitiveStr::Ascii("zarme"),
        dictgen::InsensitiveStr::Ascii("zarte"),
        dictgen::InsensitiveStr::Ascii("zate"),
        dictgen::InsensitiveStr::Ascii("zatinal"),
        dictgen::InsensitiveStr::Ascii("zativo"),
        dictgen::InsensitiveStr::Ascii("zativos"),
        dictgen::InsensitiveStr::Ascii("zatons"),
        dictgen::InsensitiveStr::Ascii("zms"),
        dictgen::InsensitiveStr::Ascii("zors"),
        dictgen::InsensitiveStr::Ascii("ztion"),
        dictgen::InsensitiveStr::Ascii("ztions"),
        dictgen::InsensitiveStr::Ascii("zuje"),
    ],
    values: &[
        &["organically"],
        &["organise"],
        &["organically"],
        &["organise"],
        &["organism"],
        &["organism"],
        &["organisation"],
        &["organisations"],
        &["organisation"],
        &["organise"],
        &["organisations"],
        &["organisations"],
        &["organisations"],
        &["organisation"],
        &["organisations"],
        &["organise"],
        &["organisers"],
        &["organised"],
        &["organisers"],
        &["organisers"],
        &["organise"],
        &["organism"],
        &["organism"],
        &["organise"],
        &["organise"],
        &["organise"],
        &["organise"],
        &["organisms"],
        &["organisms"],
        &["organisation"],
        &["organisations"],
        &["organise"],
        &["organise"],
        &["organisation"],
        &["organisations"],
        &["organise"],
        &["organise"],
        &["organization"],
        &["organizational"],
        &["organize"],
        &["organization"],
        &["organizations"],
        &["organization"],
        &["organizational"],
        &["organizer"],
        &["organizer"],
        &["organizer"],
        &["organizer"],
        &["organizer"],
        &["organize"],
        &["organizational"],
        &["organization"],
        &["organizations"],
        &["organizations"],
        &["organism"],
        &["organizers"],
        &["organization"],
        &["organizations"],
        &["organize"],
    ],
    range: 1..=10,
};

static WORD_ORGANE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ORGANE_CHILDREN),
    value: None,
};

pub static WORD_ORGANE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("red"),
        dictgen::InsensitiveStr::Ascii("s"),
    ],
    values: &[&["orangered"], &["organise"]],
    range: 1..=3,
};

static WORD_ORGAM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ORGAM_CHILDREN),
    value: None,
};

pub static WORD_ORGAM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ise")],
    values: &[&["organise"]],
    range: 3..=3,
};

static WORD_ORGAI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ORGAI_CHILDREN),
    value: None,
};

pub static WORD_ORGAI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("nsation"),
        dictgen::InsensitiveStr::Ascii("nse"),
        dictgen::InsensitiveStr::Ascii("nsed"),
        dictgen::InsensitiveStr::Ascii("nzation"),
        dictgen::InsensitiveStr::Ascii("nze"),
        dictgen::InsensitiveStr::Ascii("nzer"),
    ],
    values: &[
        &["organisation"],
        &["organise"],
        &["organised"],
        &["organizations"],
        &["organize"],
        &["organizer"],
    ],
    range: 3..=7,
};

static WORD_ORF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ORF_CHILDREN),
    value: None,
};

pub static WORD_ORF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("er")],
    values: &[&["offer", "order"]],
    range: 2..=2,
};

static WORD_ORE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ORE_CHILDREN),
    value: None,
};

pub static WORD_ORE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("de"),
        dictgen::InsensitiveStr::Ascii("des"),
        dictgen::InsensitiveStr::Ascii("ding"),
        dictgen::InsensitiveStr::Ascii("dred"),
        dictgen::InsensitiveStr::Ascii("geno"),
        dictgen::InsensitiveStr::Ascii("intal"),
        dictgen::InsensitiveStr::Ascii("intation"),
        dictgen::InsensitiveStr::Ascii("lans"),
    ],
    values: &[
        &["order"],
        &["orders"],
        &["ordering"],
        &["ordered"],
        &["oregano"],
        &["oriental"],
        &["orientation"],
        &["orleans"],
    ],
    range: 2..=8,
};

static WORD_ORD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ORD_CHILDREN),
    value: None,
};

pub static WORD_ORD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("erd"),
        dictgen::InsensitiveStr::Ascii("ert"),
        dictgen::InsensitiveStr::Ascii("ianry"),
        dictgen::InsensitiveStr::Ascii("inarly"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("ner"),
    ],
    values: &[
        &["ordered"],
        &["ordered"],
        &["ordered"],
        &["ordinary"],
        &["ordinary"],
        &["ordering"],
        &["order"],
    ],
    range: 2..=6,
};

static WORD_ORC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ORC_CHILDREN),
    value: None,
};

pub static WORD_ORC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ale"),
        dictgen::InsensitiveStr::Ascii("ales"),
        dictgen::InsensitiveStr::Ascii("ehstra"),
        dictgen::InsensitiveStr::Ascii("estra"),
        dictgen::InsensitiveStr::Ascii("estras"),
        dictgen::InsensitiveStr::Ascii("estrate"),
        dictgen::InsensitiveStr::Ascii("estrated"),
        dictgen::InsensitiveStr::Ascii("estrates"),
        dictgen::InsensitiveStr::Ascii("estrating"),
        dictgen::InsensitiveStr::Ascii("estrator"),
        dictgen::InsensitiveStr::Ascii("hastrated"),
        dictgen::InsensitiveStr::Ascii("hesta"),
        dictgen::InsensitiveStr::Ascii("hestarted"),
        dictgen::InsensitiveStr::Ascii("hestraded"),
        dictgen::InsensitiveStr::Ascii("hestraed"),
        dictgen::InsensitiveStr::Ascii("hestrial"),
        dictgen::InsensitiveStr::Ascii("histrated"),
    ],
    values: &[
        &["oracle"],
        &["oracles"],
        &["orchestra"],
        &["orchestra"],
        &["orchestras"],
        &["orchestrate"],
        &["orchestrated"],
        &["orchestrates"],
        &["orchestrating"],
        &["orchestrator"],
        &["orchestrated"],
        &["orchestra"],
        &["orchestrated"],
        &["orchestrated"],
        &["orchestrated"],
        &["orchestra"],
        &["orchestrated"],
    ],
    range: 3..=9,
};

static WORD_ORB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ORB_CHILDREN),
    value: None,
};

pub static WORD_ORB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("tial")],
    values: &[&["orbital"]],
    range: 4..=4,
};

static WORD_ORA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ORA_CHILDREN),
    value: None,
};

pub static WORD_ORA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cels"),
        dictgen::InsensitiveStr::Ascii("gnered"),
        dictgen::InsensitiveStr::Ascii("gnes"),
        dictgen::InsensitiveStr::Ascii("gnisation"),
        dictgen::InsensitiveStr::Ascii("gnise"),
        dictgen::InsensitiveStr::Ascii("gnised"),
        dictgen::InsensitiveStr::Ascii("gnizer"),
        dictgen::InsensitiveStr::Ascii("gsms"),
        dictgen::InsensitiveStr::Ascii("lces"),
        dictgen::InsensitiveStr::Ascii("ngatang"),
        dictgen::InsensitiveStr::Ascii("ngatangs"),
        dictgen::InsensitiveStr::Ascii("ngerd"),
        dictgen::InsensitiveStr::Ascii("ngers"),
        dictgen::InsensitiveStr::Ascii("ngism"),
    ],
    values: &[
        &["oracles"],
        &["orangered"],
        &["oranges"],
        &["organisation"],
        &["organise"],
        &["organised"],
        &["organizer"],
        &["orgasms"],
        &["oracles"],
        &["orangutang"],
        &["orangutangs"],
        &["orangered"],
        &["oranges"],
        &["organism"],
    ],
    range: 4..=9,
};

static WORD_OP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_OP_CHILDREN),
    value: None,
};

static WORD_OP_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_OPA_NODE),
    Some(&WORD_OPB_NODE),
    None,
    None,
    Some(&WORD_OPE_NODE),
    None,
    None,
    Some(&WORD_OPH_NODE),
    Some(&WORD_OPI_NODE),
    Some(&WORD_OPJ_NODE),
    None,
    None,
    None,
    Some(&WORD_OPN_NODE),
    Some(&WORD_OPO_NODE),
    Some(&WORD_OPP_NODE),
    None,
    Some(&WORD_OPR_NODE),
    None,
    Some(&WORD_OPT_NODE),
    Some(&WORD_OPU_NODE),
    None,
    None,
    None,
    Some(&WORD_OPY_NODE),
    None,
];

static WORD_OPY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OPY_CHILDREN),
    value: None,
};

pub static WORD_OPY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ion"),
        dictgen::InsensitiveStr::Ascii("ions"),
    ],
    values: &[&["option"], &["options"]],
    range: 3..=4,
};

static WORD_OPU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OPU_CHILDREN),
    value: None,
};

pub static WORD_OPU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("late"),
        dictgen::InsensitiveStr::Ascii("lates"),
        dictgen::InsensitiveStr::Ascii("tput"),
    ],
    values: &[
        &["populate", "opiate", "opulent"],
        &["populates", "opiates"],
        &["output"],
    ],
    range: 4..=5,
};

static WORD_OPT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_OPT_CHILDREN),
    value: None,
};

static WORD_OPT_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_OPTA_NODE),
    None,
    None,
    None,
    Some(&WORD_OPTE_NODE),
    None,
    None,
    Some(&WORD_OPTH_NODE),
    Some(&WORD_OPTI_NODE),
    None,
    None,
    None,
    Some(&WORD_OPTM_NODE),
    None,
    Some(&WORD_OPTO_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_OPTO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OPTO_CHILDREN),
    value: None,
};

pub static WORD_OPTO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("in"),
        dictgen::InsensitiveStr::Ascii("ins"),
        dictgen::InsensitiveStr::Ascii("mism"),
        dictgen::InsensitiveStr::Ascii("n"),
        dictgen::InsensitiveStr::Ascii("nal"),
        dictgen::InsensitiveStr::Ascii("nally"),
        dictgen::InsensitiveStr::Ascii("ns"),
    ],
    values: &[
        &["option"],
        &["options"],
        &["optimism"],
        &["option"],
        &["optional"],
        &["optionally"],
        &["options"],
    ],
    range: 1..=5,
};

static WORD_OPTM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OPTM_CHILDREN),
    value: None,
};

pub static WORD_OPTM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("isation"),
        dictgen::InsensitiveStr::Ascii("isations"),
        dictgen::InsensitiveStr::Ascii("ization"),
        dictgen::InsensitiveStr::Ascii("izations"),
        dictgen::InsensitiveStr::Ascii("ize"),
        dictgen::InsensitiveStr::Ascii("ized"),
    ],
    values: &[
        &["optimisation"],
        &["optimisations"],
        &["optimization"],
        &["optimizations"],
        &["optimize"],
        &["optimized"],
    ],
    range: 3..=8,
};

static WORD_OPTI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OPTI_CHILDREN),
    value: None,
};

pub static WORD_OPTI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ional"),
        dictgen::InsensitiveStr::Ascii("maal"),
        dictgen::InsensitiveStr::Ascii("masation"),
        dictgen::InsensitiveStr::Ascii("mation"),
        dictgen::InsensitiveStr::Ascii("mazation"),
        dictgen::InsensitiveStr::Ascii("mial"),
        dictgen::InsensitiveStr::Ascii("miality"),
        dictgen::InsensitiveStr::Ascii("mice"),
        dictgen::InsensitiveStr::Ascii("miced"),
        dictgen::InsensitiveStr::Ascii("mier"),
        dictgen::InsensitiveStr::Ascii("mim"),
        dictgen::InsensitiveStr::Ascii("mimum"),
        dictgen::InsensitiveStr::Ascii("misim"),
        dictgen::InsensitiveStr::Ascii("misitc"),
        dictgen::InsensitiveStr::Ascii("misitic"),
        dictgen::InsensitiveStr::Ascii("missm"),
        dictgen::InsensitiveStr::Ascii("mistc"),
        dictgen::InsensitiveStr::Ascii("mistisch"),
        dictgen::InsensitiveStr::Ascii("mitation"),
        dictgen::InsensitiveStr::Ascii("mizacion"),
        dictgen::InsensitiveStr::Ascii("mizaing"),
        dictgen::InsensitiveStr::Ascii("mizare"),
        dictgen::InsensitiveStr::Ascii("mizate"),
        dictgen::InsensitiveStr::Ascii("mizating"),
        dictgen::InsensitiveStr::Ascii("mizaton"),
        dictgen::InsensitiveStr::Ascii("mizied"),
        dictgen::InsensitiveStr::Ascii("mizier"),
        dictgen::InsensitiveStr::Ascii("miztion"),
        dictgen::InsensitiveStr::Ascii("miztions"),
        dictgen::InsensitiveStr::Ascii("msitic"),
        dictgen::InsensitiveStr::Ascii("myze"),
        dictgen::InsensitiveStr::Ascii("mzation"),
        dictgen::InsensitiveStr::Ascii("mze"),
        dictgen::InsensitiveStr::Ascii("mziation"),
        dictgen::InsensitiveStr::Ascii("mzie"),
        dictgen::InsensitiveStr::Ascii("n"),
        dictgen::InsensitiveStr::Ascii("nal"),
        dictgen::InsensitiveStr::Ascii("nally"),
        dictgen::InsensitiveStr::Ascii("ns"),
        dictgen::InsensitiveStr::Ascii("o"),
        dictgen::InsensitiveStr::Ascii("oanl"),
        dictgen::InsensitiveStr::Ascii("oin"),
        dictgen::InsensitiveStr::Ascii("oinal"),
        dictgen::InsensitiveStr::Ascii("oins"),
        dictgen::InsensitiveStr::Ascii("onall"),
        dictgen::InsensitiveStr::Ascii("onalliy"),
        dictgen::InsensitiveStr::Ascii("onallly"),
        dictgen::InsensitiveStr::Ascii("onaly"),
        dictgen::InsensitiveStr::Ascii("onel"),
        dictgen::InsensitiveStr::Ascii("ones"),
        dictgen::InsensitiveStr::Ascii("onial"),
        dictgen::InsensitiveStr::Ascii("onn"),
        dictgen::InsensitiveStr::Ascii("onnal"),
        dictgen::InsensitiveStr::Ascii("onnally"),
        dictgen::InsensitiveStr::Ascii("onnaly"),
        dictgen::InsensitiveStr::Ascii("onss"),
        dictgen::InsensitiveStr::Ascii("os"),
        dictgen::InsensitiveStr::Ascii("smied"),
        dictgen::InsensitiveStr::Ascii("zmied"),
    ],
    values: &[
        &["optional"],
        &["optimal"],
        &["optimisation"],
        &["optimization", "optimisation"],
        &["optimization"],
        &["optimal"],
        &["optimality"],
        &["optimise", "optimize"],
        &["optimised", "optimized"],
        &["optimizer", "optimiser"],
        &["optimism"],
        &["optimum"],
        &["optimism"],
        &["optimistic"],
        &["optimistic"],
        &["optimism"],
        &["optimistic"],
        &["optimistic"],
        &["optimization"],
        &["optimization"],
        &["optimizing"],
        &["optimize"],
        &["optimize"],
        &["optimization"],
        &["optimization"],
        &["optimize"],
        &["optimizer"],
        &["optimization"],
        &["optimizations"],
        &["optimistic"],
        &["optimize"],
        &["optimization"],
        &["optimize"],
        &["optimization"],
        &["optimize"],
        &["option"],
        &["optional"],
        &["optimally", "optionally"],
        &["options"],
        &["option"],
        &["optional"],
        &["option"],
        &["optional"],
        &["options"],
        &["optional", "optionally"],
        &["optionally"],
        &["optionally"],
        &["optionally"],
        &["optional"],
        &["options"],
        &["optional"],
        &["option"],
        &["optional"],
        &["optionally"],
        &["optionally"],
        &["options"],
        &["options"],
        &["optimised"],
        &["optimized"],
    ],
    range: 1..=8,
};

static WORD_OPTH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OPTH_CHILDREN),
    value: None,
};

pub static WORD_OPTH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("almic"),
        dictgen::InsensitiveStr::Ascii("almologist"),
        dictgen::InsensitiveStr::Ascii("almology"),
        dictgen::InsensitiveStr::Ascii("amologist"),
    ],
    values: &[
        &["ophthalmic"],
        &["ophthalmologist"],
        &["ophthalmology"],
        &["ophthalmologist"],
    ],
    range: 5..=10,
};

static WORD_OPTE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OPTE_CHILDREN),
    value: None,
};

pub static WORD_OPTE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("n"),
        dictgen::InsensitiveStr::Ascii("ning"),
        dictgen::InsensitiveStr::Ascii("t"),
    ],
    values: &[&["often", "open"], &["opening"], &["opted"]],
    range: 1..=4,
};

static WORD_OPTA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OPTA_CHILDREN),
    value: None,
};

pub static WORD_OPTA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("in"),
        dictgen::InsensitiveStr::Ascii("ined"),
        dictgen::InsensitiveStr::Ascii("ins"),
        dictgen::InsensitiveStr::Ascii("ionl"),
    ],
    values: &[&["obtain"], &["obtained"], &["obtains"], &["optional"]],
    range: 2..=4,
};

static WORD_OPR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OPR_CHILDREN),
    value: None,
};

pub static WORD_OPR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ation"),
        dictgen::InsensitiveStr::Ascii("ations"),
        dictgen::InsensitiveStr::Ascii("eating"),
        dictgen::InsensitiveStr::Ascii("eation"),
        dictgen::InsensitiveStr::Ascii("eations"),
        dictgen::InsensitiveStr::Ascii("ession"),
        dictgen::InsensitiveStr::Ascii("essive"),
        dictgen::InsensitiveStr::Ascii("hans"),
        dictgen::InsensitiveStr::Ascii("imization"),
        dictgen::InsensitiveStr::Ascii("imizations"),
        dictgen::InsensitiveStr::Ascii("imize"),
        dictgen::InsensitiveStr::Ascii("imized"),
        dictgen::InsensitiveStr::Ascii("imizes"),
    ],
    values: &[
        &["operation"],
        &["operations"],
        &["operating"],
        &["operation"],
        &["operations"],
        &["oppression"],
        &["oppressive"],
        &["orphans"],
        &["optimization"],
        &["optimizations"],
        &["optimize"],
        &["optimized"],
        &["optimizes"],
    ],
    range: 4..=10,
};

static WORD_OPP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OPP_CHILDREN),
    value: None,
};

pub static WORD_OPP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("enly"),
        dictgen::InsensitiveStr::Ascii("erate"),
        dictgen::InsensitiveStr::Ascii("erated"),
        dictgen::InsensitiveStr::Ascii("erates"),
        dictgen::InsensitiveStr::Ascii("eration"),
        dictgen::InsensitiveStr::Ascii("erational"),
        dictgen::InsensitiveStr::Ascii("erations"),
        dictgen::InsensitiveStr::Ascii("ertunist"),
        dictgen::InsensitiveStr::Ascii("ertunities"),
        dictgen::InsensitiveStr::Ascii("ertunity"),
        dictgen::InsensitiveStr::Ascii("inion"),
        dictgen::InsensitiveStr::Ascii("inions"),
        dictgen::InsensitiveStr::Ascii("onant"),
        dictgen::InsensitiveStr::Ascii("onenet"),
        dictgen::InsensitiveStr::Ascii("onenets"),
        dictgen::InsensitiveStr::Ascii("onet"),
        dictgen::InsensitiveStr::Ascii("ononent"),
        dictgen::InsensitiveStr::Ascii("ortunies"),
        dictgen::InsensitiveStr::Ascii("ortuniste"),
        dictgen::InsensitiveStr::Ascii("ortunisticly"),
        dictgen::InsensitiveStr::Ascii("ortunistly"),
        dictgen::InsensitiveStr::Ascii("ortunites"),
        dictgen::InsensitiveStr::Ascii("ortunties"),
        dictgen::InsensitiveStr::Ascii("orunity"),
        dictgen::InsensitiveStr::Ascii("osiste"),
        dictgen::InsensitiveStr::Ascii("ositition"),
        dictgen::InsensitiveStr::Ascii("osits"),
        dictgen::InsensitiveStr::Ascii("ossed"),
        dictgen::InsensitiveStr::Ascii("osties"),
        dictgen::InsensitiveStr::Ascii("ressin"),
        dictgen::InsensitiveStr::Ascii("ressiun"),
        dictgen::InsensitiveStr::Ascii("resso"),
        dictgen::InsensitiveStr::Ascii("resssing"),
        dictgen::InsensitiveStr::Ascii("resssion"),
        dictgen::InsensitiveStr::Ascii("rotunities"),
        dictgen::InsensitiveStr::Ascii("rotunity"),
        dictgen::InsensitiveStr::Ascii("roximate"),
        dictgen::InsensitiveStr::Ascii("s"),
        dictgen::InsensitiveStr::Ascii("sofite"),
        dictgen::InsensitiveStr::Ascii("urtinity"),
        dictgen::InsensitiveStr::Ascii("urtunities"),
        dictgen::InsensitiveStr::Ascii("urtunity"),
    ],
    values: &[
        &["openly"],
        &["operate"],
        &["operated"],
        &["operates"],
        &["operation"],
        &["operational"],
        &["operations"],
        &["opportunist"],
        &["opportunities"],
        &["opportunity"],
        &["opinion"],
        &["opinions"],
        &["opponent"],
        &["opponent"],
        &["opponent"],
        &["opponent"],
        &["opponent"],
        &["opportunities"],
        &["opportunities"],
        &["opportunistically"],
        &["opportunistically"],
        &["opportunities"],
        &["opportunities"],
        &["opportunity"],
        &["opposites"],
        &["opposition"],
        &["opposites"],
        &["opposed"],
        &["opposites"],
        &["oppression"],
        &["oppressing"],
        &["oppression"],
        &["oppressing"],
        &["oppression"],
        &["opportunities"],
        &["opportunity"],
        &["approximate"],
        &["oops"],
        &["opposite"],
        &["opportunity"],
        &["opportunities"],
        &["opportunity"],
    ],
    range: 1..=12,
};

static WORD_OPO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OPO_CHILDREN),
    value: None,
};

pub static WORD_OPO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("en"),
        dictgen::InsensitiveStr::Ascii("nent"),
        dictgen::InsensitiveStr::Ascii("rtions"),
        dictgen::InsensitiveStr::Ascii("rtunity"),
        dictgen::InsensitiveStr::Ascii("se"),
        dictgen::InsensitiveStr::Ascii("sed"),
        dictgen::InsensitiveStr::Ascii("site"),
        dictgen::InsensitiveStr::Ascii("sition"),
    ],
    values: &[
        &["open"],
        &["opponent"],
        &["options", "apportions"],
        &["opportunity"],
        &["oppose"],
        &["opposed"],
        &["opposite"],
        &["opposition"],
    ],
    range: 2..=7,
};

static WORD_OPN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OPN_CHILDREN),
    value: None,
};

pub static WORD_OPN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("egroup"),
        dictgen::InsensitiveStr::Ascii("ssl"),
    ],
    values: &[&["open"], &["opened"], &["opengroup"], &["openssl"]],
    range: 1..=6,
};

static WORD_OPJ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OPJ_CHILDREN),
    value: None,
};

pub static WORD_OPJ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ect"),
        dictgen::InsensitiveStr::Ascii("ected"),
        dictgen::InsensitiveStr::Ascii("ecteing"),
        dictgen::InsensitiveStr::Ascii("ectification"),
        dictgen::InsensitiveStr::Ascii("ectifications"),
        dictgen::InsensitiveStr::Ascii("ectified"),
        dictgen::InsensitiveStr::Ascii("ecting"),
        dictgen::InsensitiveStr::Ascii("ection"),
        dictgen::InsensitiveStr::Ascii("ections"),
        dictgen::InsensitiveStr::Ascii("ective"),
        dictgen::InsensitiveStr::Ascii("ectively"),
        dictgen::InsensitiveStr::Ascii("ects"),
    ],
    values: &[
        &["object"],
        &["objected"],
        &["objecting"],
        &["objectification"],
        &["objectifications"],
        &["objectified"],
        &["objecting"],
        &["objection"],
        &["objections"],
        &["objective"],
        &["objectively"],
        &["objects"],
    ],
    range: 3..=13,
};

static WORD_OPI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OPI_CHILDREN),
    value: None,
};

pub static WORD_OPI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("mized"),
        dictgen::InsensitiveStr::Ascii("niones"),
        dictgen::InsensitiveStr::Ascii("noins"),
        dictgen::InsensitiveStr::Ascii("nyon"),
        dictgen::InsensitiveStr::Ascii("nyonable"),
        dictgen::InsensitiveStr::Ascii("nyonaire"),
        dictgen::InsensitiveStr::Ascii("nyonal"),
        dictgen::InsensitiveStr::Ascii("nyonate"),
        dictgen::InsensitiveStr::Ascii("nyonated"),
        dictgen::InsensitiveStr::Ascii("nyonatedly"),
        dictgen::InsensitiveStr::Ascii("nyonative"),
        dictgen::InsensitiveStr::Ascii("nyonator"),
        dictgen::InsensitiveStr::Ascii("nyonators"),
        dictgen::InsensitiveStr::Ascii("nyonist"),
        dictgen::InsensitiveStr::Ascii("nyonists"),
        dictgen::InsensitiveStr::Ascii("nyonnaire"),
        dictgen::InsensitiveStr::Ascii("nyons"),
        dictgen::InsensitiveStr::Ascii("on"),
        dictgen::InsensitiveStr::Ascii("onal"),
        dictgen::InsensitiveStr::Ascii("onally"),
        dictgen::InsensitiveStr::Ascii("onated"),
        dictgen::InsensitiveStr::Ascii("ons"),
        dictgen::InsensitiveStr::Ascii("tcal"),
        dictgen::InsensitiveStr::Ascii("tional"),
        dictgen::InsensitiveStr::Ascii("tionally"),
        dictgen::InsensitiveStr::Ascii("tmal"),
        dictgen::InsensitiveStr::Ascii("ton"),
        dictgen::InsensitiveStr::Ascii("tons"),
    ],
    values: &[
        &["optimized"],
        &["opinions"],
        &["opinions"],
        &["opinion"],
        &["opinionable"],
        &["opinionnaire"],
        &["opinional"],
        &["opinionated"],
        &["opinionated"],
        &["opinionatedly"],
        &["opinionative"],
        &["opinionator"],
        &["opinionators"],
        &["opinionist"],
        &["opinionists"],
        &["opinionnaire"],
        &["opinions"],
        &["option"],
        &["optional"],
        &["optionally"],
        &["opinionated"],
        &["options"],
        &["optical"],
        &["optional"],
        &["optionally"],
        &["optimal"],
        &["option"],
        &["options"],
    ],
    range: 2..=10,
};

static WORD_OPH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OPH_CHILDREN),
    value: None,
};

pub static WORD_OPH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("an"),
        dictgen::InsensitiveStr::Ascii("talmology"),
    ],
    values: &[&["orphan"], &["ophthalmology"]],
    range: 2..=9,
};

static WORD_OPE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_OPE_CHILDREN),
    value: None,
};

static WORD_OPE_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_OPEA_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_OPEG_NODE),
    None,
    Some(&WORD_OPEI_NODE),
    None,
    None,
    None,
    Some(&WORD_OPEM_NODE),
    Some(&WORD_OPEN_NODE),
    None,
    None,
    None,
    Some(&WORD_OPER_NODE),
    None,
    Some(&WORD_OPET_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_OPET_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OPET_CHILDREN),
    value: None,
};

pub static WORD_OPET_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ional")],
    values: &[&["optional"]],
    range: 5..=5,
};

static WORD_OPER_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OPER_CHILDREN),
    value: None,
};

pub static WORD_OPER_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aand"),
        dictgen::InsensitiveStr::Ascii("aands"),
        dictgen::InsensitiveStr::Ascii("acional"),
        dictgen::InsensitiveStr::Ascii("aion"),
        dictgen::InsensitiveStr::Ascii("aions"),
        dictgen::InsensitiveStr::Ascii("aiton"),
        dictgen::InsensitiveStr::Ascii("andes"),
        dictgen::InsensitiveStr::Ascii("aror"),
        dictgen::InsensitiveStr::Ascii("asional"),
        dictgen::InsensitiveStr::Ascii("atation"),
        dictgen::InsensitiveStr::Ascii("atations"),
        dictgen::InsensitiveStr::Ascii("ater"),
        dictgen::InsensitiveStr::Ascii("atie"),
        dictgen::InsensitiveStr::Ascii("atin"),
        dictgen::InsensitiveStr::Ascii("atings"),
        dictgen::InsensitiveStr::Ascii("atio"),
        dictgen::InsensitiveStr::Ascii("ationable"),
        dictgen::InsensitiveStr::Ascii("atione"),
        dictgen::InsensitiveStr::Ascii("ationel"),
        dictgen::InsensitiveStr::Ascii("ationnal"),
        dictgen::InsensitiveStr::Ascii("atior"),
        dictgen::InsensitiveStr::Ascii("ativne"),
        dictgen::InsensitiveStr::Ascii("ativos"),
        dictgen::InsensitiveStr::Ascii("atng"),
        dictgen::InsensitiveStr::Ascii("ato"),
        dictgen::InsensitiveStr::Ascii("aton"),
        dictgen::InsensitiveStr::Ascii("atons"),
        dictgen::InsensitiveStr::Ascii("attion"),
        dictgen::InsensitiveStr::Ascii("attions"),
        dictgen::InsensitiveStr::Ascii("eation"),
        dictgen::InsensitiveStr::Ascii("n"),
        dictgen::InsensitiveStr::Ascii("ration"),
        dictgen::InsensitiveStr::Ascii("rations"),
        dictgen::InsensitiveStr::Ascii("taion"),
        dictgen::InsensitiveStr::Ascii("taions"),
        dictgen::InsensitiveStr::Ascii("tion"),
        dictgen::InsensitiveStr::Ascii("tional"),
        dictgen::InsensitiveStr::Ascii("tions"),
        dictgen::InsensitiveStr::Ascii("tor"),
        dictgen::InsensitiveStr::Ascii("tors"),
    ],
    values: &[
        &["operand"],
        &["operands"],
        &["operational"],
        &["operation"],
        &["operations"],
        &["operation"],
        &["operands"],
        &["operator"],
        &["operational"],
        &["operation"],
        &["operations"],
        &["operator"],
        &["operative"],
        &["operating", "operation"],
        &["operations", "operating"],
        &["operation"],
        &["operational"],
        &["operation"],
        &["operational"],
        &["operational"],
        &["operator"],
        &["operative"],
        &["operations"],
        &["operating"],
        &["operator"],
        &["operation"],
        &["operations"],
        &["operation"],
        &["operations"],
        &["operation"],
        &["open"],
        &["operation"],
        &["operations"],
        &["operation"],
        &["operations"],
        &["operation"],
        &["operational"],
        &["operations"],
        &["operator"],
        &["operators"],
    ],
    range: 1..=9,
};

static WORD_OPEN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OPEN_CHILDREN),
    value: None,
};

pub static WORD_OPEN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("apig"),
        dictgen::InsensitiveStr::Ascii("brower"),
        dictgen::InsensitiveStr::Ascii("ded"),
        dictgen::InsensitiveStr::Ascii("eing"),
        dictgen::InsensitiveStr::Ascii("en"),
        dictgen::InsensitiveStr::Ascii("end"),
        dictgen::InsensitiveStr::Ascii("ened"),
        dictgen::InsensitiveStr::Ascii("ening"),
        dictgen::InsensitiveStr::Ascii("ess"),
        dictgen::InsensitiveStr::Ascii("in"),
        dictgen::InsensitiveStr::Ascii("ned"),
        dictgen::InsensitiveStr::Ascii("ning"),
        dictgen::InsensitiveStr::Ascii("scource"),
        dictgen::InsensitiveStr::Ascii("scourced"),
    ],
    values: &[
        &["openapi"],
        &["openbrowser"],
        &["opened"],
        &["opening"],
        &["opened", "opening"],
        &["opened"],
        &["opened"],
        &["opening"],
        &["openness"],
        &["opening"],
        &["opened"],
        &["opening"],
        &["opensource"],
        &["opensourced"],
    ],
    range: 2..=8,
};

static WORD_OPEM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OPEM_CHILDREN),
    value: Some(&["open"]),
};

pub static WORD_OPEM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("ess"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("s"),
    ],
    values: &[&["opened"], &["openness"], &["opening"], &["opens"]],
    range: 1..=3,
};

static WORD_OPEI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OPEI_CHILDREN),
    value: None,
};

pub static WORD_OPEI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ng"),
        dictgen::InsensitiveStr::Ascii("nging"),
        dictgen::InsensitiveStr::Ascii("ngs"),
    ],
    values: &[&["opening"], &["opening"], &["openings"]],
    range: 2..=5,
};

static WORD_OPEG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OPEG_CHILDREN),
    value: Some(&["open"]),
};

pub static WORD_OPEG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ing")],
    values: &[&["opening"]],
    range: 3..=3,
};

static WORD_OPEA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OPEA_CHILDREN),
    value: None,
};

pub static WORD_OPEA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aration"),
        dictgen::InsensitiveStr::Ascii("arations"),
        dictgen::InsensitiveStr::Ascii("bcration"),
        dictgen::InsensitiveStr::Ascii("bcrations"),
        dictgen::InsensitiveStr::Ascii("rand"),
        dictgen::InsensitiveStr::Ascii("rands"),
        dictgen::InsensitiveStr::Ascii("rate"),
        dictgen::InsensitiveStr::Ascii("rates"),
        dictgen::InsensitiveStr::Ascii("rating"),
        dictgen::InsensitiveStr::Ascii("ration"),
        dictgen::InsensitiveStr::Ascii("rations"),
        dictgen::InsensitiveStr::Ascii("ratios"),
        dictgen::InsensitiveStr::Ascii("rator"),
        dictgen::InsensitiveStr::Ascii("rators"),
        dictgen::InsensitiveStr::Ascii("rion"),
        dictgen::InsensitiveStr::Ascii("rions"),
        dictgen::InsensitiveStr::Ascii("rios"),
        dictgen::InsensitiveStr::Ascii("riton"),
        dictgen::InsensitiveStr::Ascii("ritons"),
        dictgen::InsensitiveStr::Ascii("ritos"),
        dictgen::InsensitiveStr::Ascii("rnd"),
        dictgen::InsensitiveStr::Ascii("rnds"),
        dictgen::InsensitiveStr::Ascii("ror"),
        dictgen::InsensitiveStr::Ascii("rors"),
        dictgen::InsensitiveStr::Ascii("rte"),
        dictgen::InsensitiveStr::Ascii("rted"),
        dictgen::InsensitiveStr::Ascii("rtes"),
        dictgen::InsensitiveStr::Ascii("rting"),
        dictgen::InsensitiveStr::Ascii("rtion"),
        dictgen::InsensitiveStr::Ascii("rtions"),
        dictgen::InsensitiveStr::Ascii("rtios"),
        dictgen::InsensitiveStr::Ascii("rtor"),
        dictgen::InsensitiveStr::Ascii("rtors"),
        dictgen::InsensitiveStr::Ascii("te"),
        dictgen::InsensitiveStr::Ascii("tes"),
        dictgen::InsensitiveStr::Ascii("tion"),
        dictgen::InsensitiveStr::Ascii("tional"),
        dictgen::InsensitiveStr::Ascii("tions"),
        dictgen::InsensitiveStr::Ascii("tios"),
        dictgen::InsensitiveStr::Ascii("tor"),
        dictgen::InsensitiveStr::Ascii("tors"),
        dictgen::InsensitiveStr::Ascii("tror"),
        dictgen::InsensitiveStr::Ascii("trors"),
    ],
    values: &[
        &["operation"],
        &["operations"],
        &["operation"],
        &["operations"],
        &["operand"],
        &["operands"],
        &["operate"],
        &["operates"],
        &["operating"],
        &["operation"],
        &["operations"],
        &["operations"],
        &["operator"],
        &["operators"],
        &["operation"],
        &["operations"],
        &["operations"],
        &["operation"],
        &["operations"],
        &["operations"],
        &["operand"],
        &["operands"],
        &["operator"],
        &["operators"],
        &["operate"],
        &["operated"],
        &["operates"],
        &["operating"],
        &["operation"],
        &["operations"],
        &["operations"],
        &["operator"],
        &["operators"],
        &["operate"],
        &["operates"],
        &["operation"],
        &["operational"],
        &["operations"],
        &["operations"],
        &["operator"],
        &["operators"],
        &["operator"],
        &["operators"],
    ],
    range: 2..=9,
};

static WORD_OPB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OPB_CHILDREN),
    value: None,
};

pub static WORD_OPB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ject"),
        dictgen::InsensitiveStr::Ascii("jective"),
        dictgen::InsensitiveStr::Ascii("jects"),
    ],
    values: &[&["object"], &["objective"], &["objects"]],
    range: 4..=7,
};

static WORD_OPA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OPA_CHILDREN),
    value: None,
};

pub static WORD_OPA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ctity"),
        dictgen::InsensitiveStr::Ascii("ctiy"),
        dictgen::InsensitiveStr::Ascii("cy"),
        dictgen::InsensitiveStr::Ascii("gue"),
        dictgen::InsensitiveStr::Ascii("rtor"),
        dictgen::InsensitiveStr::Ascii("tque"),
        dictgen::InsensitiveStr::Ascii("uqe"),
        dictgen::InsensitiveStr::Ascii("yk"),
        dictgen::InsensitiveStr::Ascii("ykely"),
        dictgen::InsensitiveStr::Ascii("ykes"),
    ],
    values: &[
        &["opacity"],
        &["opacity"],
        &["opacity"],
        &["opaque"],
        &["operator"],
        &["opaque"],
        &["opaque"],
        &["opaque"],
        &["opaquely"],
        &["opaques"],
    ],
    range: 2..=5,
};

static WORD_OO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OO_CHILDREN),
    value: None,
};

pub static WORD_OO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("mmits"),
        dictgen::InsensitiveStr::Ascii("utput"),
        dictgen::InsensitiveStr::Ascii("utputs"),
    ],
    values: &[&["commits"], &["output"], &["outputs"]],
    range: 5..=6,
};

static WORD_ON_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ON_CHILDREN),
    value: None,
};

pub static WORD_ON_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("atrio"),
        dictgen::InsensitiveStr::Ascii("baord"),
        dictgen::InsensitiveStr::Ascii("borad"),
        dictgen::InsensitiveStr::Ascii("ces"),
        dictgen::InsensitiveStr::Ascii("chage"),
        dictgen::InsensitiveStr::Ascii("d"),
        dictgen::InsensitiveStr::Ascii("ece"),
        dictgen::InsensitiveStr::Ascii("eyway"),
        dictgen::InsensitiveStr::Ascii("figure"),
        dictgen::InsensitiveStr::Ascii("gewild"),
        dictgen::InsensitiveStr::Ascii("gly"),
        dictgen::InsensitiveStr::Ascii("l"),
        dictgen::InsensitiveStr::Ascii("lie"),
        dictgen::InsensitiveStr::Ascii("liene"),
        dictgen::InsensitiveStr::Ascii("lly"),
        dictgen::InsensitiveStr::Ascii("lsaught"),
        dictgen::InsensitiveStr::Ascii("lye"),
        dictgen::InsensitiveStr::Ascii("mipotent"),
        dictgen::InsensitiveStr::Ascii("miscient"),
        dictgen::InsensitiveStr::Ascii("mishience"),
        dictgen::InsensitiveStr::Ascii("mishiences"),
        dictgen::InsensitiveStr::Ascii("mishients"),
        dictgen::InsensitiveStr::Ascii("mishints"),
        dictgen::InsensitiveStr::Ascii("misience"),
        dictgen::InsensitiveStr::Ascii("misiences"),
        dictgen::InsensitiveStr::Ascii("o"),
        dictgen::InsensitiveStr::Ascii("oly"),
        dictgen::InsensitiveStr::Ascii("omanopea"),
        dictgen::InsensitiveStr::Ascii("omonopea"),
        dictgen::InsensitiveStr::Ascii("ot"),
        dictgen::InsensitiveStr::Ascii("other"),
        dictgen::InsensitiveStr::Ascii("salught"),
        dictgen::InsensitiveStr::Ascii("self"),
        dictgen::InsensitiveStr::Ascii("servation"),
        dictgen::InsensitiveStr::Ascii("slaugt"),
        dictgen::InsensitiveStr::Ascii("slaugth"),
        dictgen::InsensitiveStr::Ascii("sluaght"),
        dictgen::InsensitiveStr::Ascii("tain"),
        dictgen::InsensitiveStr::Ascii("tained"),
        dictgen::InsensitiveStr::Ascii("tainer"),
        dictgen::InsensitiveStr::Ascii("tainers"),
        dictgen::InsensitiveStr::Ascii("tainging"),
        dictgen::InsensitiveStr::Ascii("taining"),
        dictgen::InsensitiveStr::Ascii("tainor"),
        dictgen::InsensitiveStr::Ascii("tainors"),
        dictgen::InsensitiveStr::Ascii("tains"),
        dictgen::InsensitiveStr::Ascii("tairo"),
        dictgen::InsensitiveStr::Ascii("text"),
        dictgen::InsensitiveStr::Ascii("traio"),
        dictgen::InsensitiveStr::Ascii("trolled"),
        dictgen::InsensitiveStr::Ascii("veience"),
        dictgen::InsensitiveStr::Ascii("ventions"),
        dictgen::InsensitiveStr::Ascii("w"),
        dictgen::InsensitiveStr::Ascii("wed"),
        dictgen::InsensitiveStr::Ascii("wee"),
        dictgen::InsensitiveStr::Ascii("wer"),
        dictgen::InsensitiveStr::Ascii("wership"),
        dictgen::InsensitiveStr::Ascii("wing"),
        dictgen::InsensitiveStr::Ascii("ws"),
        dictgen::InsensitiveStr::Ascii("y"),
        dictgen::InsensitiveStr::Ascii("yl"),
    ],
    values: &[
        &["ontario"],
        &["onboard"],
        &["onboard"],
        &["ounces", "once", "ones"],
        &["onchange"],
        &["one", "and"],
        &["once"],
        &["oneway"],
        &["configure"],
        &["gonewild"],
        &["only"],
        &["only"],
        &["online", "only"],
        &["online"],
        &["only"],
        &["onslaught"],
        &["only"],
        &["omnipotent"],
        &["omniscient"],
        &["omniscience"],
        &["omnisciences"],
        &["omniscience"],
        &["omniscience"],
        &["omniscience"],
        &["omnisciences"],
        &["one"],
        &["only"],
        &["onomatopoeia"],
        &["onomatopoeia"],
        &["note", "not"],
        &["another"],
        &["onslaught"],
        &["oneself"],
        &["conservation", "observation"],
        &["onslaught"],
        &["onslaught"],
        &["onslaught"],
        &["contain"],
        &["contained"],
        &["container"],
        &["containers"],
        &["containing"],
        &["containing"],
        &["container"],
        &["containers"],
        &["contains"],
        &["ontario"],
        &["context"],
        &["ontario"],
        &["controlled"],
        &["convenience"],
        &["conventions"],
        &["own", "now"],
        &["owned"],
        &["ennui"],
        &["owner"],
        &["ownership"],
        &["owning"],
        &["owns"],
        &["only", "on", "one"],
        &["only"],
    ],
    range: 1..=10,
};

static WORD_OM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OM_CHILDREN),
    value: None,
};

pub static WORD_OM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("age"),
        dictgen::InsensitiveStr::Ascii("ages"),
        dictgen::InsensitiveStr::Ascii("aj"),
        dictgen::InsensitiveStr::Ascii("aje"),
        dictgen::InsensitiveStr::Ascii("ajes"),
        dictgen::InsensitiveStr::Ascii("inpotent"),
        dictgen::InsensitiveStr::Ascii("inscient"),
        dictgen::InsensitiveStr::Ascii("ishience"),
        dictgen::InsensitiveStr::Ascii("ishiences"),
        dictgen::InsensitiveStr::Ascii("ishients"),
        dictgen::InsensitiveStr::Ascii("ishints"),
        dictgen::InsensitiveStr::Ascii("isience"),
        dictgen::InsensitiveStr::Ascii("isiences"),
        dictgen::InsensitiveStr::Ascii("ision"),
        dictgen::InsensitiveStr::Ascii("ited"),
        dictgen::InsensitiveStr::Ascii("iting"),
        dictgen::InsensitiveStr::Ascii("itt"),
        dictgen::InsensitiveStr::Ascii("let"),
        dictgen::InsensitiveStr::Ascii("lets"),
        dictgen::InsensitiveStr::Ascii("lette"),
        dictgen::InsensitiveStr::Ascii("lettes"),
        dictgen::InsensitiveStr::Ascii("mishience"),
        dictgen::InsensitiveStr::Ascii("mishiences"),
        dictgen::InsensitiveStr::Ascii("mishients"),
        dictgen::InsensitiveStr::Ascii("mishints"),
        dictgen::InsensitiveStr::Ascii("misience"),
        dictgen::InsensitiveStr::Ascii("misiences"),
        dictgen::InsensitiveStr::Ascii("mision"),
        dictgen::InsensitiveStr::Ascii("mission"),
        dictgen::InsensitiveStr::Ascii("mit"),
        dictgen::InsensitiveStr::Ascii("mited"),
        dictgen::InsensitiveStr::Ascii("miting"),
        dictgen::InsensitiveStr::Ascii("mits"),
        dictgen::InsensitiveStr::Ascii("mitted"),
        dictgen::InsensitiveStr::Ascii("mitting"),
        dictgen::InsensitiveStr::Ascii("nipetent"),
        dictgen::InsensitiveStr::Ascii("nipitent"),
        dictgen::InsensitiveStr::Ascii("nipotant"),
        dictgen::InsensitiveStr::Ascii("niscienct"),
        dictgen::InsensitiveStr::Ascii("nishience"),
        dictgen::InsensitiveStr::Ascii("nishiences"),
        dictgen::InsensitiveStr::Ascii("nishients"),
        dictgen::InsensitiveStr::Ascii("nishints"),
        dictgen::InsensitiveStr::Ascii("nisicent"),
        dictgen::InsensitiveStr::Ascii("nisience"),
        dictgen::InsensitiveStr::Ascii("nisiences"),
        dictgen::InsensitiveStr::Ascii("niverous"),
        dictgen::InsensitiveStr::Ascii("niverously"),
        dictgen::InsensitiveStr::Ascii("nsicient"),
        dictgen::InsensitiveStr::Ascii("plementaion"),
        dictgen::InsensitiveStr::Ascii("plementation"),
        dictgen::InsensitiveStr::Ascii("re"),
    ],
    values: &[
        &["homage"],
        &["homages"],
        &["homage", "oman"],
        &["homage"],
        &["homages"],
        &["omnipotent"],
        &["omniscient"],
        &["omniscience"],
        &["omnisciences"],
        &["omniscience"],
        &["omniscience"],
        &["omniscience"],
        &["omnisciences"],
        &["omission"],
        &["omitted"],
        &["omitting"],
        &["omit"],
        &["omelet"],
        &["omelets"],
        &["omelette"],
        &["omelettes"],
        &["omniscience"],
        &["omnisciences"],
        &["omniscience"],
        &["omniscience"],
        &["omniscience"],
        &["omnisciences"],
        &["omission"],
        &["omission"],
        &["omit"],
        &["omitted"],
        &["omitting"],
        &["omits"],
        &["omitted"],
        &["omitting"],
        &["omnipotent"],
        &["omnipotent"],
        &["omnipotent"],
        &["omniscient"],
        &["omniscience"],
        &["omnisciences"],
        &["omniscience"],
        &["omniscience"],
        &["omniscient"],
        &["omniscience"],
        &["omnisciences"],
        &["omnivorous"],
        &["omnivorously"],
        &["omniscient"],
        &["implementation"],
        &["implementation"],
        &["more"],
    ],
    range: 2..=12,
};

static WORD_OL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OL_CHILDREN),
    value: None,
};

pub static WORD_OL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("bigatory"),
        dictgen::InsensitiveStr::Ascii("biterated"),
        dictgen::InsensitiveStr::Ascii("des"),
        dictgen::InsensitiveStr::Ascii("igarcy"),
        dictgen::InsensitiveStr::Ascii("igrachy"),
        dictgen::InsensitiveStr::Ascii("l"),
        dictgen::InsensitiveStr::Ascii("mypic"),
        dictgen::InsensitiveStr::Ascii("mypics"),
        dictgen::InsensitiveStr::Ascii("ny"),
        dictgen::InsensitiveStr::Ascii("reans"),
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("ther"),
        dictgen::InsensitiveStr::Ascii("y"),
        dictgen::InsensitiveStr::Ascii("ymipcs"),
        dictgen::InsensitiveStr::Ascii("ympis"),
        dictgen::InsensitiveStr::Ascii("ypmic"),
        dictgen::InsensitiveStr::Ascii("ypmics"),
    ],
    values: &[
        &["obligatory"],
        &["obliterated"],
        &["oldest"],
        &["oligarchy"],
        &["oligarchy"],
        &["all", "ole", "old", "olly", "oil"],
        &["olympic"],
        &["olympics"],
        &["only"],
        &["orleans"],
        &["old"],
        &["other"],
        &["only"],
        &["olympics"],
        &["olympics"],
        &["olympic"],
        &["olympics"],
    ],
    range: 1..=9,
};

static WORD_OK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OK_CHILDREN),
    value: None,
};

pub static WORD_OK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("at"),
        dictgen::InsensitiveStr::Ascii("tober"),
    ],
    values: &[&["okay"], &["october"]],
    range: 2..=5,
};

static WORD_OJ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OJ_CHILDREN),
    value: None,
};

pub static WORD_OJ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("bect"),
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("ect"),
        dictgen::InsensitiveStr::Ascii("ection"),
        dictgen::InsensitiveStr::Ascii("ective"),
        dictgen::InsensitiveStr::Ascii("ects"),
        dictgen::InsensitiveStr::Ascii("ekts"),
    ],
    values: &[
        &["object"],
        &["one"],
        &["object"],
        &["objection"],
        &["objective"],
        &["objects"],
        &["objects"],
    ],
    range: 1..=6,
};

static WORD_OI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OI_CHILDREN),
    value: None,
};

pub static WORD_OI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("gin"),
        dictgen::InsensitiveStr::Ascii("ginal"),
        dictgen::InsensitiveStr::Ascii("ginally"),
        dictgen::InsensitiveStr::Ascii("ginals"),
        dictgen::InsensitiveStr::Ascii("ginating"),
        dictgen::InsensitiveStr::Ascii("gins"),
        dictgen::InsensitiveStr::Ascii("lgarchy"),
        dictgen::InsensitiveStr::Ascii("nts"),
        dictgen::InsensitiveStr::Ascii("s"),
    ],
    values: &[
        &["origin"],
        &["original"],
        &["originally"],
        &["originals"],
        &["originating"],
        &["origins"],
        &["oligarchy"],
        &["points", "pints"],
        &["is"],
    ],
    range: 1..=8,
};

static WORD_OH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OH_CHILDREN),
    value: None,
};

pub static WORD_OH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("er"),
        dictgen::InsensitiveStr::Ascii("erwise"),
        dictgen::InsensitiveStr::Ascii("ter"),
        dictgen::InsensitiveStr::Ascii("ters"),
        dictgen::InsensitiveStr::Ascii("terwise"),
    ],
    values: &[
        &["her", "other"],
        &["otherwise"],
        &["other"],
        &["others"],
        &["otherwise"],
    ],
    range: 2..=7,
};

static WORD_OG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OG_CHILDREN),
    value: None,
};

pub static WORD_OG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("er"),
        dictgen::InsensitiveStr::Ascii("erish"),
        dictgen::InsensitiveStr::Ascii("ers"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("liarchy"),
        dictgen::InsensitiveStr::Ascii("ranisation"),
        dictgen::InsensitiveStr::Ascii("rilla"),
    ],
    values: &[
        &["ogre"],
        &["ogreish"],
        &["ogres"],
        &["going", "ogling"],
        &["oligarchy"],
        &["organisation"],
        &["gorilla"],
    ],
    range: 2..=10,
};

static WORD_OF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_OF_CHILDREN),
    value: None,
};

static WORD_OF_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    Some(&WORD_OFC_NODE),
    None,
    None,
    Some(&WORD_OFF_NODE),
    None,
    None,
    Some(&WORD_OFI_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_OFO_NODE),
    None,
    None,
    Some(&WORD_OFR_NODE),
    Some(&WORD_OFS_NODE),
    Some(&WORD_OFT_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_OFT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OFT_CHILDREN),
    value: None,
};

pub static WORD_OFT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("enly"),
        dictgen::InsensitiveStr::Ascii("er"),
        dictgen::InsensitiveStr::Ascii("hen"),
    ],
    values: &[&["often"], &["after", "offer", "often"], &["often"]],
    range: 2..=4,
};

static WORD_OFS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OFS_CHILDREN),
    value: None,
};

pub static WORD_OFS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("etted"),
        dictgen::InsensitiveStr::Ascii("set"),
    ],
    values: &[&["offsetted"], &["offset"]],
    range: 3..=5,
};

static WORD_OFR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OFR_CHILDREN),
    value: None,
};

pub static WORD_OFR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("om")],
    values: &[&["from"]],
    range: 2..=2,
};

static WORD_OFO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OFO_CHILDREN),
    value: Some(&["of"]),
};

pub static WORD_OFO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("curse")],
    values: &[&["ofcourse"]],
    range: 5..=5,
};

static WORD_OFI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OFI_CHILDREN),
    value: None,
};

pub static WORD_OFI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cial"),
        dictgen::InsensitiveStr::Ascii("cially"),
        dictgen::InsensitiveStr::Ascii("cianado"),
        dictgen::InsensitiveStr::Ascii("cianados"),
        dictgen::InsensitiveStr::Ascii("cionado"),
        dictgen::InsensitiveStr::Ascii("cionados"),
        dictgen::InsensitiveStr::Ascii("sianado"),
        dictgen::InsensitiveStr::Ascii("sianados"),
        dictgen::InsensitiveStr::Ascii("sionado"),
        dictgen::InsensitiveStr::Ascii("sionados"),
    ],
    values: &[
        &["official"],
        &["officially"],
        &["aficionado"],
        &["aficionados"],
        &["aficionado"],
        &["aficionados"],
        &["aficionado"],
        &["aficionados"],
        &["aficionado"],
        &["aficionados"],
    ],
    range: 4..=8,
};

static WORD_OFF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_OFF_CHILDREN),
    value: None,
};

static WORD_OFF_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_OFFA_NODE),
    None,
    Some(&WORD_OFFC_NODE),
    None,
    Some(&WORD_OFFE_NODE),
    Some(&WORD_OFFF_NODE),
    None,
    None,
    Some(&WORD_OFFI_NODE),
    None,
    None,
    Some(&WORD_OFFL_NODE),
    None,
    None,
    None,
    Some(&WORD_OFFP_NODE),
    None,
    Some(&WORD_OFFR_NODE),
    Some(&WORD_OFFS_NODE),
    Some(&WORD_OFFT_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_OFFT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OFFT_CHILDREN),
    value: None,
};

pub static WORD_OFFT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("en")],
    values: &[&["often"]],
    range: 2..=2,
};

static WORD_OFFS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OFFS_CHILDREN),
    value: None,
};

pub static WORD_OFFS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ence"),
        dictgen::InsensitiveStr::Ascii("ense"),
        dictgen::InsensitiveStr::Ascii("enses"),
        dictgen::InsensitiveStr::Ascii("er"),
        dictgen::InsensitiveStr::Ascii("est"),
        dictgen::InsensitiveStr::Ascii("eted"),
        dictgen::InsensitiveStr::Ascii("eting"),
        dictgen::InsensitiveStr::Ascii("etp"),
        dictgen::InsensitiveStr::Ascii("ett"),
        dictgen::InsensitiveStr::Ascii("ited"),
        dictgen::InsensitiveStr::Ascii("pirng"),
        dictgen::InsensitiveStr::Ascii("rping"),
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("tets"),
    ],
    values: &[
        &["offence"],
        &["offense"],
        &["offenses"],
        &["offset"],
        &["offset", "offsets"],
        &["offsetted"],
        &["offsetting"],
        &["offset"],
        &["offset"],
        &["offside"],
        &["offspring"],
        &["offspring"],
        &["offset"],
        &["offsets"],
    ],
    range: 1..=5,
};

static WORD_OFFR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OFFR_CHILDREN),
    value: None,
};

pub static WORD_OFFR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ed")],
    values: &[&["offered"]],
    range: 2..=2,
};

static WORD_OFFP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OFFP_CHILDREN),
    value: None,
};

pub static WORD_OFFP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("sring")],
    values: &[&["offspring"]],
    range: 5..=5,
};

static WORD_OFFL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OFFL_CHILDREN),
    value: None,
};

pub static WORD_OFFL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aod"),
        dictgen::InsensitiveStr::Ascii("aoded"),
        dictgen::InsensitiveStr::Ascii("aoding"),
        dictgen::InsensitiveStr::Ascii("oded"),
    ],
    values: &[
        &["offload"],
        &["offloaded"],
        &["offloading"],
        &["offloaded"],
    ],
    range: 3..=6,
};

static WORD_OFFI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OFFI_CHILDREN),
    value: None,
};

pub static WORD_OFFI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("c"),
        dictgen::InsensitiveStr::Ascii("cailly"),
        dictgen::InsensitiveStr::Ascii("cal"),
        dictgen::InsensitiveStr::Ascii("cally"),
        dictgen::InsensitiveStr::Ascii("cals"),
        dictgen::InsensitiveStr::Ascii("caly"),
        dictgen::InsensitiveStr::Ascii("ceal"),
        dictgen::InsensitiveStr::Ascii("ceally"),
        dictgen::InsensitiveStr::Ascii("ceals"),
        dictgen::InsensitiveStr::Ascii("cealy"),
        dictgen::InsensitiveStr::Ascii("ciallly"),
        dictgen::InsensitiveStr::Ascii("cialy"),
        dictgen::InsensitiveStr::Ascii("cianado"),
        dictgen::InsensitiveStr::Ascii("cianados"),
        dictgen::InsensitiveStr::Ascii("cionado"),
        dictgen::InsensitiveStr::Ascii("cionados"),
        dictgen::InsensitiveStr::Ascii("sde"),
        dictgen::InsensitiveStr::Ascii("sianado"),
        dictgen::InsensitiveStr::Ascii("sianados"),
        dictgen::InsensitiveStr::Ascii("sionado"),
        dictgen::InsensitiveStr::Ascii("sionados"),
    ],
    values: &[
        &["office"],
        &["officially"],
        &["official"],
        &["officially"],
        &["officials"],
        &["officially"],
        &["official"],
        &["officially"],
        &["officials"],
        &["officially"],
        &["officially"],
        &["officially"],
        &["aficionado"],
        &["aficionados"],
        &["aficionado"],
        &["aficionados"],
        &["offside"],
        &["aficionado"],
        &["aficionados"],
        &["aficionado"],
        &["aficionados"],
    ],
    range: 1..=8,
};

static WORD_OFFF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OFFF_CHILDREN),
    value: None,
};

pub static WORD_OFFF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ence"),
        dictgen::InsensitiveStr::Ascii("ences"),
        dictgen::InsensitiveStr::Ascii("ense"),
        dictgen::InsensitiveStr::Ascii("enses"),
        dictgen::InsensitiveStr::Ascii("set"),
        dictgen::InsensitiveStr::Ascii("sets"),
    ],
    values: &[
        &["offence"],
        &["offences"],
        &["offense"],
        &["offenses"],
        &["offset"],
        &["offsets"],
    ],
    range: 3..=5,
};

static WORD_OFFE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OFFE_CHILDREN),
    value: None,
};

pub static WORD_OFFE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("n"),
        dictgen::InsensitiveStr::Ascii("ner"),
        dictgen::InsensitiveStr::Ascii("nest"),
        dictgen::InsensitiveStr::Ascii("ns"),
        dictgen::InsensitiveStr::Ascii("nsivelly"),
        dictgen::InsensitiveStr::Ascii("nsivley"),
        dictgen::InsensitiveStr::Ascii("nsivly"),
        dictgen::InsensitiveStr::Ascii("rd"),
        dictgen::InsensitiveStr::Ascii("reings"),
        dictgen::InsensitiveStr::Ascii("snively"),
        dictgen::InsensitiveStr::Ascii("st"),
        dictgen::InsensitiveStr::Ascii("sts"),
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("ts"),
    ],
    values: &[
        &["often"],
        &["oftener"],
        &["oftenest"],
        &["offend", "offends", "offense", "offers"],
        &["offensively"],
        &["offensively"],
        &["offensively"],
        &["offered"],
        &["offerings"],
        &["offensively"],
        &["offset"],
        &["offsets"],
        &["offset", "offer"],
        &["offsets", "offers"],
    ],
    range: 1..=8,
};

static WORD_OFFC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OFFC_CHILDREN),
    value: None,
};

pub static WORD_OFFC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ers"),
        dictgen::InsensitiveStr::Ascii("ial"),
        dictgen::InsensitiveStr::Ascii("ially"),
        dictgen::InsensitiveStr::Ascii("ials"),
    ],
    values: &[
        &["officers"],
        &["official"],
        &["officially"],
        &["officials"],
    ],
    range: 3..=5,
};

static WORD_OFFA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OFFA_CHILDREN),
    value: None,
};

pub static WORD_OFFA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("et")],
    values: &[&["offset"]],
    range: 2..=2,
};

static WORD_OFC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OFC_CHILDREN),
    value: None,
};

pub static WORD_OFC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("oruse"),
        dictgen::InsensitiveStr::Ascii("oure"),
        dictgen::InsensitiveStr::Ascii("oures"),
        dictgen::InsensitiveStr::Ascii("ousre"),
        dictgen::InsensitiveStr::Ascii("rouse"),
    ],
    values: &[
        &["ofcourse"],
        &["ofcourse"],
        &["ofcourse"],
        &["ofcourse"],
        &["ofcourse"],
    ],
    range: 4..=5,
};

static WORD_OE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OE_CHILDREN),
    value: None,
};

pub static WORD_OE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("n"),
        dictgen::InsensitiveStr::Ascii("pnapi"),
        dictgen::InsensitiveStr::Ascii("pration"),
        dictgen::InsensitiveStr::Ascii("prations"),
        dictgen::InsensitiveStr::Ascii("rflow"),
    ],
    values: &[
        &["one"],
        &["openapi"],
        &["operation"],
        &["operations"],
        &["overflow"],
    ],
    range: 1..=8,
};

static WORD_OD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OD_CHILDREN),
    value: None,
};

pub static WORD_OD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("asee"),
        dictgen::InsensitiveStr::Ascii("asees"),
        dictgen::InsensitiveStr::Ascii("er"),
        dictgen::InsensitiveStr::Ascii("ly"),
        dictgen::InsensitiveStr::Ascii("y"),
    ],
    values: &[
        &["odyssey"],
        &["odysseys"],
        &["order", "odor", "older"],
        &["oddly"],
        &["body"],
    ],
    range: 1..=5,
};

static WORD_OC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_OC_CHILDREN),
    value: None,
};

static WORD_OC_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_OCA_NODE),
    None,
    Some(&WORD_OCC_NODE),
    None,
    Some(&WORD_OCE_NODE),
    None,
    None,
    None,
    Some(&WORD_OCI_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_OCN_NODE),
    Some(&WORD_OCO_NODE),
    None,
    None,
    Some(&WORD_OCR_NODE),
    None,
    Some(&WORD_OCT_NODE),
    Some(&WORD_OCU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_OCU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OCU_CHILDREN),
    value: None,
};

pub static WORD_OCU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ntries"),
        dictgen::InsensitiveStr::Ascii("ntry"),
        dictgen::InsensitiveStr::Ascii("pied"),
        dictgen::InsensitiveStr::Ascii("pier"),
        dictgen::InsensitiveStr::Ascii("piers"),
        dictgen::InsensitiveStr::Ascii("pies"),
        dictgen::InsensitiveStr::Ascii("py"),
        dictgen::InsensitiveStr::Ascii("pying"),
        dictgen::InsensitiveStr::Ascii("r"),
        dictgen::InsensitiveStr::Ascii("rr"),
        dictgen::InsensitiveStr::Ascii("rrance"),
        dictgen::InsensitiveStr::Ascii("rred"),
        dictgen::InsensitiveStr::Ascii("rrence"),
        dictgen::InsensitiveStr::Ascii("rrences"),
        dictgen::InsensitiveStr::Ascii("rring"),
        dictgen::InsensitiveStr::Ascii("rrred"),
        dictgen::InsensitiveStr::Ascii("rrs"),
    ],
    values: &[
        &["countries"],
        &["country"],
        &["occupied"],
        &["occupier"],
        &["occupiers"],
        &["occupies"],
        &["occupy"],
        &["occupying"],
        &["occur"],
        &["occur"],
        &["occurrence"],
        &["occurred"],
        &["occurrence"],
        &["occurrences"],
        &["occurring"],
        &["occurred"],
        &["occurs"],
    ],
    range: 1..=7,
};

static WORD_OCT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OCT_CHILDREN),
    value: None,
};

pub static WORD_OCT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ect"),
        dictgen::InsensitiveStr::Ascii("ects"),
        dictgen::InsensitiveStr::Ascii("ive"),
        dictgen::InsensitiveStr::Ascii("ives"),
        dictgen::InsensitiveStr::Ascii("obear"),
        dictgen::InsensitiveStr::Ascii("obor"),
        dictgen::InsensitiveStr::Ascii("ohedra"),
        dictgen::InsensitiveStr::Ascii("ohedral"),
        dictgen::InsensitiveStr::Ascii("ohedron"),
        dictgen::InsensitiveStr::Ascii("opuns"),
    ],
    values: &[
        &["octet"],
        &["octets"],
        &["active", "octave"],
        &["actives", "octaves"],
        &["october"],
        &["october"],
        &["octahedra"],
        &["octahedral"],
        &["octahedron"],
        &["octopus"],
    ],
    range: 3..=7,
};

static WORD_OCR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OCR_CHILDREN),
    value: None,
};

pub static WORD_OCR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("aina")],
    values: &[&["ocarina"]],
    range: 4..=4,
};

static WORD_OCO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OCO_CHILDREN),
    value: None,
};

pub static WORD_OCO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("rrence"),
        dictgen::InsensitiveStr::Ascii("rrences"),
        dictgen::InsensitiveStr::Ascii("tber"),
        dictgen::InsensitiveStr::Ascii("tpus"),
    ],
    values: &[
        &["occurrence"],
        &["occurrences"],
        &["october"],
        &["octopus"],
    ],
    range: 4..=7,
};

static WORD_OCN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OCN_CHILDREN),
    value: None,
};

pub static WORD_OCN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("text")],
    values: &[&["context"]],
    range: 4..=4,
};

static WORD_OCI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OCI_CHILDREN),
    value: None,
};

pub static WORD_OCI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("late"),
        dictgen::InsensitiveStr::Ascii("lated"),
        dictgen::InsensitiveStr::Ascii("later"),
        dictgen::InsensitiveStr::Ascii("laters"),
        dictgen::InsensitiveStr::Ascii("lates"),
        dictgen::InsensitiveStr::Ascii("lating"),
        dictgen::InsensitiveStr::Ascii("lator"),
        dictgen::InsensitiveStr::Ascii("lators"),
    ],
    values: &[
        &["oscillate"],
        &["oscillated"],
        &["oscillator"],
        &["oscillators"],
        &["oscillates"],
        &["oscillating"],
        &["oscillator"],
        &["oscillators"],
    ],
    range: 4..=6,
};

static WORD_OCE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OCE_CHILDREN),
    value: Some(&["once", "one", "ore"]),
};

pub static WORD_OCE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[],
    values: &[],
    range: 0..=0,
};

static WORD_OCC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_OCC_CHILDREN),
    value: None,
};

static WORD_OCC_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_OCCA_NODE),
    None,
    Some(&WORD_OCCC_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_OCCO_NODE),
    None,
    None,
    Some(&WORD_OCCR_NODE),
    Some(&WORD_OCCS_NODE),
    None,
    Some(&WORD_OCCU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_OCCU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OCCU_CHILDREN),
    value: None,
};

pub static WORD_OCCU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cence"),
        dictgen::InsensitiveStr::Ascii("cences"),
        dictgen::InsensitiveStr::Ascii("ers"),
        dictgen::InsensitiveStr::Ascii("lation"),
        dictgen::InsensitiveStr::Ascii("lusion"),
        dictgen::InsensitiveStr::Ascii("paiton"),
        dictgen::InsensitiveStr::Ascii("pance"),
        dictgen::InsensitiveStr::Ascii("pato"),
        dictgen::InsensitiveStr::Ascii("ped"),
        dictgen::InsensitiveStr::Ascii("pided"),
        dictgen::InsensitiveStr::Ascii("racy"),
        dictgen::InsensitiveStr::Ascii("rance"),
        dictgen::InsensitiveStr::Ascii("rances"),
        dictgen::InsensitiveStr::Ascii("rately"),
        dictgen::InsensitiveStr::Ascii("rd"),
        dictgen::InsensitiveStr::Ascii("rded"),
        dictgen::InsensitiveStr::Ascii("re"),
        dictgen::InsensitiveStr::Ascii("red"),
        dictgen::InsensitiveStr::Ascii("rence"),
        dictgen::InsensitiveStr::Ascii("rences"),
        dictgen::InsensitiveStr::Ascii("res"),
        dictgen::InsensitiveStr::Ascii("ring"),
        dictgen::InsensitiveStr::Ascii("rr"),
        dictgen::InsensitiveStr::Ascii("rrance"),
        dictgen::InsensitiveStr::Ascii("rrances"),
        dictgen::InsensitiveStr::Ascii("rrencies"),
        dictgen::InsensitiveStr::Ascii("rrencs"),
        dictgen::InsensitiveStr::Ascii("rrs"),
    ],
    values: &[
        &["occurrence"],
        &["occurrences"],
        &["occurs"],
        &["occupation"],
        &["occlusion"],
        &["occupation"],
        &["occupancy"],
        &["occupation"],
        &["occupied"],
        &["occupied"],
        &["accuracy"],
        &["occurrence"],
        &["occurrences"],
        &["accurately"],
        &["occurred", "occur"],
        &["occurred"],
        &["occur", "occurred"],
        &["occurred"],
        &["occurrence"],
        &["occurrences"],
        &["occurs"],
        &["occurring"],
        &["occur"],
        &["occurrence"],
        &["occurrences"],
        &["occurrences"],
        &["occurrences"],
        &["occurs"],
    ],
    range: 2..=8,
};

static WORD_OCCS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OCCS_CHILDREN),
    value: None,
};

pub static WORD_OCCS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ionally")],
    values: &[&["occasionally"]],
    range: 7..=7,
};

static WORD_OCCR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OCCR_CHILDREN),
    value: None,
};

pub static WORD_OCCR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("rance"),
        dictgen::InsensitiveStr::Ascii("rances"),
        dictgen::InsensitiveStr::Ascii("red"),
        dictgen::InsensitiveStr::Ascii("ring"),
    ],
    values: &[
        &["occurrence"],
        &["occurrences"],
        &["occurred"],
        &["occurring"],
    ],
    range: 3..=6,
};

static WORD_OCCO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OCCO_CHILDREN),
    value: None,
};

pub static WORD_OCCO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ur"),
        dictgen::InsensitiveStr::Ascii("ured"),
        dictgen::InsensitiveStr::Ascii("uring"),
        dictgen::InsensitiveStr::Ascii("urring"),
        dictgen::InsensitiveStr::Ascii("urs"),
    ],
    values: &[
        &["occur"],
        &["occurred"],
        &["occurring"],
        &["occurring"],
        &["occurs"],
    ],
    range: 2..=6,
};

static WORD_OCCC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OCCC_CHILDREN),
    value: None,
};

pub static WORD_OCCC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ur"),
        dictgen::InsensitiveStr::Ascii("ured"),
        dictgen::InsensitiveStr::Ascii("urs"),
    ],
    values: &[&["occur"], &["occurred"], &["occurs"]],
    range: 2..=4,
};

static WORD_OCCA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OCCA_CHILDREN),
    value: None,
};

pub static WORD_OCCA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("isionally"),
        dictgen::InsensitiveStr::Ascii("ison"),
        dictgen::InsensitiveStr::Ascii("isonal"),
        dictgen::InsensitiveStr::Ascii("isonally"),
        dictgen::InsensitiveStr::Ascii("isons"),
        dictgen::InsensitiveStr::Ascii("sinal"),
        dictgen::InsensitiveStr::Ascii("sinally"),
        dictgen::InsensitiveStr::Ascii("sioanlly"),
        dictgen::InsensitiveStr::Ascii("sionals"),
        dictgen::InsensitiveStr::Ascii("sionaly"),
        dictgen::InsensitiveStr::Ascii("sionly"),
        dictgen::InsensitiveStr::Ascii("sionnal"),
        dictgen::InsensitiveStr::Ascii("ssion"),
        dictgen::InsensitiveStr::Ascii("ssional"),
        dictgen::InsensitiveStr::Ascii("ssionally"),
        dictgen::InsensitiveStr::Ascii("ssionaly"),
        dictgen::InsensitiveStr::Ascii("ssioned"),
        dictgen::InsensitiveStr::Ascii("ssions"),
        dictgen::InsensitiveStr::Ascii("tion"),
        dictgen::InsensitiveStr::Ascii("tional"),
        dictgen::InsensitiveStr::Ascii("tionally"),
        dictgen::InsensitiveStr::Ascii("tionly"),
        dictgen::InsensitiveStr::Ascii("tions"),
    ],
    values: &[
        &["occasionally"],
        &["occasion"],
        &["occasional"],
        &["occasionally"],
        &["occasions"],
        &["occasional"],
        &["occasionally"],
        &["occasionally"],
        &["occasions"],
        &["occasionally"],
        &["occasional"],
        &["occasional"],
        &["occasion"],
        &["occasional"],
        &["occasionally"],
        &["occasionally"],
        &["occasioned"],
        &["occasions"],
        &["occasion"],
        &["occasional"],
        &["occasionally"],
        &["occasionally"],
        &["occasions"],
    ],
    range: 4..=9,
};

static WORD_OCA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OCA_CHILDREN),
    value: None,
};

pub static WORD_OCA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("rnia"),
        dictgen::InsensitiveStr::Ascii("sion"),
        dictgen::InsensitiveStr::Ascii("sional"),
        dictgen::InsensitiveStr::Ascii("sionally"),
        dictgen::InsensitiveStr::Ascii("sionaly"),
        dictgen::InsensitiveStr::Ascii("sioned"),
        dictgen::InsensitiveStr::Ascii("sions"),
        dictgen::InsensitiveStr::Ascii("ssion"),
        dictgen::InsensitiveStr::Ascii("ssional"),
        dictgen::InsensitiveStr::Ascii("ssionally"),
        dictgen::InsensitiveStr::Ascii("ssionaly"),
        dictgen::InsensitiveStr::Ascii("ssioned"),
        dictgen::InsensitiveStr::Ascii("ssions"),
    ],
    values: &[
        &["ocarina"],
        &["occasion"],
        &["occasional"],
        &["occasionally"],
        &["occasionally"],
        &["occasioned"],
        &["occasions"],
        &["occasion"],
        &["occasional"],
        &["occasionally"],
        &["occasionally"],
        &["occasioned"],
        &["occasions"],
    ],
    range: 4..=9,
};

static WORD_OB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_OB_CHILDREN),
    value: None,
};

static WORD_OB_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_OBA_NODE),
    None,
    None,
    Some(&WORD_OBD_NODE),
    Some(&WORD_OBE_NODE),
    None,
    Some(&WORD_OBG_NODE),
    Some(&WORD_OBH_NODE),
    Some(&WORD_OBI_NODE),
    Some(&WORD_OBJ_NODE),
    None,
    Some(&WORD_OBL_NODE),
    None,
    Some(&WORD_OBN_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_OBS_NODE),
    Some(&WORD_OBT_NODE),
    Some(&WORD_OBU_NODE),
    Some(&WORD_OBV_NODE),
    None,
    None,
    Some(&WORD_OBY_NODE),
    None,
];

static WORD_OBY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OBY_CHILDREN),
    value: None,
};

pub static WORD_OBY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ect"),
        dictgen::InsensitiveStr::Ascii("ekt"),
    ],
    values: &[&["object"], &["object"]],
    range: 3..=3,
};

static WORD_OBV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OBV_CHILDREN),
    value: None,
};

pub static WORD_OBV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ersation"),
        dictgen::InsensitiveStr::Ascii("ersations"),
        dictgen::InsensitiveStr::Ascii("ilion"),
        dictgen::InsensitiveStr::Ascii("iosuly"),
        dictgen::InsensitiveStr::Ascii("ioulsy"),
        dictgen::InsensitiveStr::Ascii("isious"),
        dictgen::InsensitiveStr::Ascii("isouly"),
        dictgen::InsensitiveStr::Ascii("isous"),
        dictgen::InsensitiveStr::Ascii("isously"),
        dictgen::InsensitiveStr::Ascii("oius"),
        dictgen::InsensitiveStr::Ascii("oiusly"),
    ],
    values: &[
        &["observation"],
        &["observations"],
        &["oblivion"],
        &["obviously"],
        &["obviously"],
        &["obvious"],
        &["obviously"],
        &["obvious"],
        &["obviously"],
        &["obvious"],
        &["obviously"],
    ],
    range: 4..=9,
};

static WORD_OBU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OBU_CHILDREN),
    value: None,
};

pub static WORD_OBU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("sing")],
    values: &[&["abusing"]],
    range: 4..=4,
};

static WORD_OBT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OBT_CHILDREN),
    value: None,
};

pub static WORD_OBT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aien"),
        dictgen::InsensitiveStr::Ascii("aiend"),
        dictgen::InsensitiveStr::Ascii("aiens"),
        dictgen::InsensitiveStr::Ascii("ainabe"),
        dictgen::InsensitiveStr::Ascii("ainabie"),
        dictgen::InsensitiveStr::Ascii("aine"),
        dictgen::InsensitiveStr::Ascii("aineble"),
        dictgen::InsensitiveStr::Ascii("aines"),
        dictgen::InsensitiveStr::Ascii("ainible"),
        dictgen::InsensitiveStr::Ascii("ainig"),
        dictgen::InsensitiveStr::Ascii("aion"),
        dictgen::InsensitiveStr::Ascii("aioned"),
        dictgen::InsensitiveStr::Ascii("aions"),
        dictgen::InsensitiveStr::Ascii("ianable"),
        dictgen::InsensitiveStr::Ascii("rain"),
        dictgen::InsensitiveStr::Ascii("rained"),
        dictgen::InsensitiveStr::Ascii("rains"),
    ],
    values: &[
        &["obtain", "obtained"],
        &["obtained"],
        &["obtains"],
        &["obtainable"],
        &["obtainable"],
        &["obtain", "obtained", "obtains"],
        &["obtainable"],
        &["obtains"],
        &["obtainable"],
        &["obtaining"],
        &["obtain"],
        &["obtained"],
        &["obtains"],
        &["obtainable"],
        &["obtain"],
        &["obtained"],
        &["obtains"],
    ],
    range: 4..=7,
};

static WORD_OBS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OBS_CHILDREN),
    value: None,
};

pub static WORD_OBS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cruity"),
        dictgen::InsensitiveStr::Ascii("cuirty"),
        dictgen::InsensitiveStr::Ascii("cur"),
        dictgen::InsensitiveStr::Ascii("elete"),
        dictgen::InsensitiveStr::Ascii("eravtion"),
        dictgen::InsensitiveStr::Ascii("eravtions"),
        dictgen::InsensitiveStr::Ascii("erv"),
        dictgen::InsensitiveStr::Ascii("ervabil"),
        dictgen::InsensitiveStr::Ascii("ervacion"),
        dictgen::InsensitiveStr::Ascii("ervaiton"),
        dictgen::InsensitiveStr::Ascii("ervare"),
        dictgen::InsensitiveStr::Ascii("ervarse"),
        dictgen::InsensitiveStr::Ascii("ervasion"),
        dictgen::InsensitiveStr::Ascii("ervating"),
        dictgen::InsensitiveStr::Ascii("ervaton"),
        dictgen::InsensitiveStr::Ascii("erveras"),
        dictgen::InsensitiveStr::Ascii("erverats"),
        dictgen::InsensitiveStr::Ascii("erverd"),
        dictgen::InsensitiveStr::Ascii("ervered"),
        dictgen::InsensitiveStr::Ascii("erveres"),
        dictgen::InsensitiveStr::Ascii("ervible"),
        dictgen::InsensitiveStr::Ascii("essie"),
        dictgen::InsensitiveStr::Ascii("essin"),
        dictgen::InsensitiveStr::Ascii("essivley"),
        dictgen::InsensitiveStr::Ascii("evrer"),
        dictgen::InsensitiveStr::Ascii("evrers"),
        dictgen::InsensitiveStr::Ascii("idain"),
        dictgen::InsensitiveStr::Ascii("olate"),
        dictgen::InsensitiveStr::Ascii("olesence"),
        dictgen::InsensitiveStr::Ascii("olite"),
        dictgen::InsensitiveStr::Ascii("olited"),
        dictgen::InsensitiveStr::Ascii("olote"),
        dictgen::InsensitiveStr::Ascii("olte"),
        dictgen::InsensitiveStr::Ascii("olted"),
        dictgen::InsensitiveStr::Ascii("sesion"),
        dictgen::InsensitiveStr::Ascii("sesive"),
        dictgen::InsensitiveStr::Ascii("sessed"),
        dictgen::InsensitiveStr::Ascii("tacal"),
        dictgen::InsensitiveStr::Ascii("tancles"),
        dictgen::InsensitiveStr::Ascii("truccion"),
        dictgen::InsensitiveStr::Ascii("truced"),
        dictgen::InsensitiveStr::Ascii("trucion"),
        dictgen::InsensitiveStr::Ascii("tructin"),
        dictgen::InsensitiveStr::Ascii("truktion"),
        dictgen::InsensitiveStr::Ascii("turction"),
        dictgen::InsensitiveStr::Ascii("ucrity"),
        dictgen::InsensitiveStr::Ascii("ure"),
    ],
    values: &[
        &["obscurity"],
        &["obscurity"],
        &["obscure"],
        &["obsolete"],
        &["observation"],
        &["observations"],
        &["observe"],
        &["observable"],
        &["observation"],
        &["observant"],
        &["observer"],
        &["observers"],
        &["observations"],
        &["observation"],
        &["observation"],
        &["observers"],
        &["observers"],
        &["observed"],
        &["observed"],
        &["observers"],
        &["observable"],
        &["obsessive"],
        &["obsession"],
        &["obsessive"],
        &["observer"],
        &["observers"],
        &["obsidian"],
        &["obsolete"],
        &["obsolescence"],
        &["obsolete"],
        &["obsoleted"],
        &["obsolete"],
        &["obsolete"],
        &["obsoleted"],
        &["obsession"],
        &["obsessive"],
        &["obsessed"],
        &["obstacle"],
        &["obstacles"],
        &["obstruction"],
        &["obstructed"],
        &["obstruction"],
        &["obstruction"],
        &["obstruction"],
        &["obstruction"],
        &["obscurity"],
        &["obscure"],
    ],
    range: 3..=9,
};

static WORD_OBN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OBN_CHILDREN),
    value: None,
};

pub static WORD_OBN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ject")],
    values: &[&["object"]],
    range: 4..=4,
};

static WORD_OBL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OBL_CHILDREN),
    value: None,
};

pub static WORD_OBL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eek"),
        dictgen::InsensitiveStr::Ascii("eekly"),
        dictgen::InsensitiveStr::Ascii("iberated"),
        dictgen::InsensitiveStr::Ascii("iderated"),
        dictgen::InsensitiveStr::Ascii("igerated"),
        dictgen::InsensitiveStr::Ascii("igitary"),
        dictgen::InsensitiveStr::Ascii("igitory"),
        dictgen::InsensitiveStr::Ascii("isk"),
        dictgen::InsensitiveStr::Ascii("isks"),
        dictgen::InsensitiveStr::Ascii("itarated"),
        dictgen::InsensitiveStr::Ascii("iteraded"),
        dictgen::InsensitiveStr::Ascii("iterared"),
        dictgen::InsensitiveStr::Ascii("itirated"),
        dictgen::InsensitiveStr::Ascii("itorated"),
        dictgen::InsensitiveStr::Ascii("itque"),
        dictgen::InsensitiveStr::Ascii("iverated"),
    ],
    values: &[
        &["oblique"],
        &["obliquely"],
        &["obliterated"],
        &["obliterated"],
        &["obliterated"],
        &["obligatory"],
        &["obligatory"],
        &["obelisk"],
        &["obelisks"],
        &["obliterated"],
        &["obliterated"],
        &["obliterated"],
        &["obliterated"],
        &["obliterated"],
        &["oblique"],
        &["obliterated"],
    ],
    range: 3..=8,
};

static WORD_OBJ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OBJ_CHILDREN),
    value: None,
};

pub static WORD_OBJ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ec"),
        dictgen::InsensitiveStr::Ascii("ecitves"),
        dictgen::InsensitiveStr::Ascii("ecs"),
        dictgen::InsensitiveStr::Ascii("ectificaiton"),
        dictgen::InsensitiveStr::Ascii("ectificaton"),
        dictgen::InsensitiveStr::Ascii("ectificiation"),
        dictgen::InsensitiveStr::Ascii("ectivas"),
        dictgen::InsensitiveStr::Ascii("ectivelly"),
        dictgen::InsensitiveStr::Ascii("ectivety"),
        dictgen::InsensitiveStr::Ascii("ectivication"),
        dictgen::InsensitiveStr::Ascii("ectivify"),
        dictgen::InsensitiveStr::Ascii("ectivily"),
        dictgen::InsensitiveStr::Ascii("ectiviser"),
        dictgen::InsensitiveStr::Ascii("ectivitiy"),
        dictgen::InsensitiveStr::Ascii("ectivley"),
        dictgen::InsensitiveStr::Ascii("ectivly"),
        dictgen::InsensitiveStr::Ascii("ectivs"),
        dictgen::InsensitiveStr::Ascii("ectivst"),
        dictgen::InsensitiveStr::Ascii("ectivty"),
        dictgen::InsensitiveStr::Ascii("ectivy"),
        dictgen::InsensitiveStr::Ascii("ectss"),
        dictgen::InsensitiveStr::Ascii("ejct"),
        dictgen::InsensitiveStr::Ascii("ekt"),
        dictgen::InsensitiveStr::Ascii("ektives"),
        dictgen::InsensitiveStr::Ascii("et"),
        dictgen::InsensitiveStr::Ascii("etc"),
        dictgen::InsensitiveStr::Ascii("etcs"),
        dictgen::InsensitiveStr::Ascii("ets"),
        dictgen::InsensitiveStr::Ascii("tain"),
        dictgen::InsensitiveStr::Ascii("tained"),
        dictgen::InsensitiveStr::Ascii("tains"),
        dictgen::InsensitiveStr::Ascii("ump"),
    ],
    values: &[
        &["object"],
        &["objectives"],
        &["objects"],
        &["objectification"],
        &["objectification"],
        &["objectification"],
        &["objectives"],
        &["objectively"],
        &["objectivity"],
        &["objectification"],
        &["objectivity"],
        &["objectivity"],
        &["objectives"],
        &["objectivity"],
        &["objectively"],
        &["objectively"],
        &["objectives"],
        &["objectives"],
        &["objectivity"],
        &["objectivity"],
        &["objects"],
        &["object"],
        &["object"],
        &["objectives"],
        &["object"],
        &["object"],
        &["objects"],
        &["objects"],
        &["obtain"],
        &["obtained"],
        &["obtains"],
        &["objdump"],
    ],
    range: 2..=13,
};

static WORD_OBI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OBI_CHILDREN),
    value: None,
};

pub static WORD_OBI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("edence"),
        dictgen::InsensitiveStr::Ascii("lgatory"),
        dictgen::InsensitiveStr::Ascii("lterated"),
        dictgen::InsensitiveStr::Ascii("lvion"),
        dictgen::InsensitiveStr::Ascii("ous"),
        dictgen::InsensitiveStr::Ascii("ously"),
        dictgen::InsensitiveStr::Ascii("sdian"),
        dictgen::InsensitiveStr::Ascii("vous"),
        dictgen::InsensitiveStr::Ascii("vously"),
    ],
    values: &[
        &["obedience"],
        &["obligatory"],
        &["obliterated"],
        &["oblivion"],
        &["obvious"],
        &["obviously"],
        &["obsidian"],
        &["obvious"],
        &["obviously"],
    ],
    range: 3..=8,
};

static WORD_OBH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OBH_CHILDREN),
    value: None,
};

pub static WORD_OBH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ect"),
        dictgen::InsensitiveStr::Ascii("ectification"),
        dictgen::InsensitiveStr::Ascii("ectifies"),
        dictgen::InsensitiveStr::Ascii("ectify"),
        dictgen::InsensitiveStr::Ascii("ectifying"),
        dictgen::InsensitiveStr::Ascii("ecting"),
        dictgen::InsensitiveStr::Ascii("ection"),
        dictgen::InsensitiveStr::Ascii("ects"),
    ],
    values: &[
        &["object"],
        &["objectification"],
        &["objectifies"],
        &["objectify"],
        &["objectifying"],
        &["objecting"],
        &["objection"],
        &["objects"],
    ],
    range: 3..=12,
};

static WORD_OBG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OBG_CHILDREN),
    value: None,
};

pub static WORD_OBG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ect"),
        dictgen::InsensitiveStr::Ascii("ects"),
    ],
    values: &[&["object"], &["objects"]],
    range: 3..=4,
};

static WORD_OBE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OBE_CHILDREN),
    value: None,
};

pub static WORD_OBE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ct"),
        dictgen::InsensitiveStr::Ascii("diance"),
        dictgen::InsensitiveStr::Ascii("diant"),
        dictgen::InsensitiveStr::Ascii("idence"),
        dictgen::InsensitiveStr::Ascii("jct"),
        dictgen::InsensitiveStr::Ascii("jcted"),
        dictgen::InsensitiveStr::Ascii("jction"),
        dictgen::InsensitiveStr::Ascii("jctions"),
        dictgen::InsensitiveStr::Ascii("jctive"),
        dictgen::InsensitiveStr::Ascii("jctively"),
        dictgen::InsensitiveStr::Ascii("jctives"),
        dictgen::InsensitiveStr::Ascii("jcts"),
        dictgen::InsensitiveStr::Ascii("ject"),
        dictgen::InsensitiveStr::Ascii("jection"),
        dictgen::InsensitiveStr::Ascii("jects"),
        dictgen::InsensitiveStr::Ascii("rflow"),
        dictgen::InsensitiveStr::Ascii("rflowed"),
        dictgen::InsensitiveStr::Ascii("rflowing"),
        dictgen::InsensitiveStr::Ascii("rflows"),
        dictgen::InsensitiveStr::Ascii("rsvant"),
        dictgen::InsensitiveStr::Ascii("rsvation"),
        dictgen::InsensitiveStr::Ascii("rsvations"),
        dictgen::InsensitiveStr::Ascii("rsvers"),
        dictgen::InsensitiveStr::Ascii("rv"),
        dictgen::InsensitiveStr::Ascii("rvant"),
        dictgen::InsensitiveStr::Ascii("rvation"),
        dictgen::InsensitiveStr::Ascii("rvations"),
        dictgen::InsensitiveStr::Ascii("rve"),
        dictgen::InsensitiveStr::Ascii("rved"),
        dictgen::InsensitiveStr::Ascii("rver"),
        dictgen::InsensitiveStr::Ascii("rvers"),
        dictgen::InsensitiveStr::Ascii("rves"),
        dictgen::InsensitiveStr::Ascii("rving"),
        dictgen::InsensitiveStr::Ascii("rvs"),
        dictgen::InsensitiveStr::Ascii("servation"),
        dictgen::InsensitiveStr::Ascii("servations"),
        dictgen::InsensitiveStr::Ascii("serve"),
        dictgen::InsensitiveStr::Ascii("served"),
        dictgen::InsensitiveStr::Ascii("server"),
        dictgen::InsensitiveStr::Ascii("servers"),
        dictgen::InsensitiveStr::Ascii("serves"),
        dictgen::InsensitiveStr::Ascii("serving"),
        dictgen::InsensitiveStr::Ascii("ssion"),
        dictgen::InsensitiveStr::Ascii("ssions"),
        dictgen::InsensitiveStr::Ascii("sssion"),
    ],
    values: &[
        &["object"],
        &["obedience"],
        &["obedient"],
        &["obedience"],
        &["object"],
        &["objected"],
        &["objection"],
        &["objections"],
        &["objective"],
        &["objectively"],
        &["objectives"],
        &["objects"],
        &["object"],
        &["objection"],
        &["objects"],
        &["overflow"],
        &["overflowed"],
        &["overflowing"],
        &["overflows"],
        &["observant"],
        &["observation"],
        &["observations"],
        &["observers"],
        &["observe"],
        &["observant"],
        &["observation"],
        &["observations"],
        &["observe"],
        &["observed"],
        &["observer"],
        &["observers"],
        &["observes"],
        &["observing"],
        &["observes"],
        &["observation"],
        &["observations"],
        &["observe"],
        &["observed"],
        &["observer"],
        &["observers"],
        &["observes"],
        &["observing"],
        &["obsession"],
        &["obsessions"],
        &["obsession"],
    ],
    range: 2..=10,
};

static WORD_OBD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OBD_CHILDREN),
    value: None,
};

pub static WORD_OBD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("isian")],
    values: &[&["obsidian"]],
    range: 5..=5,
};

static WORD_OBA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OBA_CHILDREN),
    value: None,
};

pub static WORD_OBA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("mination"),
        dictgen::InsensitiveStr::Ascii("tinable"),
        dictgen::InsensitiveStr::Ascii("tion"),
        dictgen::InsensitiveStr::Ascii("tions"),
        dictgen::InsensitiveStr::Ascii("y"),
        dictgen::InsensitiveStr::Ascii("yed"),
        dictgen::InsensitiveStr::Ascii("ying"),
        dictgen::InsensitiveStr::Ascii("ys"),
    ],
    values: &[
        &["abomination"],
        &["obtainable"],
        &["ovation"],
        &["ovations"],
        &["obey"],
        &["obeyed"],
        &["obeying"],
        &["obeys"],
    ],
    range: 1..=8,
};

static WORD_OA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_OA_CHILDREN),
    value: None,
};

pub static WORD_OA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ker"),
        dictgen::InsensitiveStr::Ascii("kereous"),
        dictgen::InsensitiveStr::Ascii("kereously"),
        dictgen::InsensitiveStr::Ascii("kerous"),
        dictgen::InsensitiveStr::Ascii("kerously"),
        dictgen::InsensitiveStr::Ascii("kery"),
        dictgen::InsensitiveStr::Ascii("ram"),
        dictgen::InsensitiveStr::Ascii("rcles"),
        dictgen::InsensitiveStr::Ascii("ut"),
    ],
    values: &[
        &[
            "baker", "faker", "laker", "maker", "oaken", "oakier", "ocher", "taker",
        ],
        &["ocherous"],
        &["ocherously"],
        &["ocherous"],
        &["ocherously"],
        &["ochery"],
        &["param"],
        &["oracles"],
        &["oauth"],
    ],
    range: 2..=9,
};

static WORD_N_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_N_CHILDREN),
    value: None,
};

static WORD_N_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_NA_NODE),
    None,
    Some(&WORD_NC_NODE),
    Some(&WORD_ND_NODE),
    Some(&WORD_NE_NODE),
    None,
    None,
    None,
    Some(&WORD_NI_NODE),
    None,
    Some(&WORD_NK_NODE),
    None,
    Some(&WORD_NM_NODE),
    Some(&WORD_NN_NODE),
    Some(&WORD_NO_NODE),
    None,
    None,
    Some(&WORD_NR_NODE),
    Some(&WORD_NS_NODE),
    Some(&WORD_NT_NODE),
    Some(&WORD_NU_NODE),
    None,
    Some(&WORD_NW_NODE),
    None,
    Some(&WORD_NY_NODE),
    None,
];

static WORD_NY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NY_CHILDREN),
    value: None,
};

pub static WORD_NY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("mber")],
    values: &[&["number"]],
    range: 4..=4,
};

static WORD_NW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NW_CHILDREN),
    value: None,
};

pub static WORD_NW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("o"),
    ],
    values: &[&["new"], &["now"]],
    range: 1..=1,
};

static WORD_NU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_NU_CHILDREN),
    value: None,
};

static WORD_NU_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_NUA_NODE),
    Some(&WORD_NUB_NODE),
    Some(&WORD_NUC_NODE),
    None,
    Some(&WORD_NUE_NODE),
    None,
    None,
    None,
    Some(&WORD_NUI_NODE),
    None,
    None,
    Some(&WORD_NUL_NODE),
    Some(&WORD_NUM_NODE),
    Some(&WORD_NUN_NODE),
    None,
    None,
    None,
    Some(&WORD_NUR_NODE),
    Some(&WORD_NUS_NODE),
    Some(&WORD_NUT_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_NUT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NUT_CHILDREN),
    value: None,
};

pub static WORD_NUT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("irent"),
        dictgen::InsensitiveStr::Ascii("irents"),
        dictgen::InsensitiveStr::Ascii("ral"),
        dictgen::InsensitiveStr::Ascii("rally"),
        dictgen::InsensitiveStr::Ascii("raly"),
        dictgen::InsensitiveStr::Ascii("reints"),
        dictgen::InsensitiveStr::Ascii("ricional"),
        dictgen::InsensitiveStr::Ascii("ricious"),
        dictgen::InsensitiveStr::Ascii("riens"),
        dictgen::InsensitiveStr::Ascii("rientes"),
        dictgen::InsensitiveStr::Ascii("rieous"),
        dictgen::InsensitiveStr::Ascii("riet"),
        dictgen::InsensitiveStr::Ascii("ritent"),
        dictgen::InsensitiveStr::Ascii("ritents"),
        dictgen::InsensitiveStr::Ascii("ritian"),
        dictgen::InsensitiveStr::Ascii("ritinal"),
        dictgen::InsensitiveStr::Ascii("ritionnal"),
        dictgen::InsensitiveStr::Ascii("ritios"),
        dictgen::InsensitiveStr::Ascii("ritiuos"),
        dictgen::InsensitiveStr::Ascii("ritivos"),
        dictgen::InsensitiveStr::Ascii("rituous"),
        dictgen::InsensitiveStr::Ascii("rutional"),
        dictgen::InsensitiveStr::Ascii("rutious"),
        dictgen::InsensitiveStr::Ascii("uring"),
    ],
    values: &[
        &["nutrient"],
        &["nutrients"],
        &["neutral"],
        &["neutrally"],
        &["neutrally"],
        &["nutrients"],
        &["nutritional"],
        &["nutritious"],
        &["nutrients"],
        &["nutrients"],
        &["nutritious"],
        &["nutrient"],
        &["nutrient"],
        &["nutrients"],
        &["nutritional"],
        &["nutritional"],
        &["nutritional"],
        &["nutritious"],
        &["nutritious"],
        &["nutritious"],
        &["nutritious"],
        &["nutritional"],
        &["nutritious"],
        &["nurturing"],
    ],
    range: 3..=9,
};

static WORD_NUS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NUS_CHILDREN),
    value: None,
};

pub static WORD_NUS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aince"),
        dictgen::InsensitiveStr::Ascii("ance"),
        dictgen::InsensitiveStr::Ascii("iance"),
    ],
    values: &[&["nuisance"], &["nuisance"], &["nuisance"]],
    range: 4..=5,
};

static WORD_NUR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NUR_CHILDREN),
    value: None,
};

pub static WORD_NUR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("emburg"),
        dictgen::InsensitiveStr::Ascii("ish"),
        dictgen::InsensitiveStr::Ascii("ished"),
        dictgen::InsensitiveStr::Ascii("isher"),
        dictgen::InsensitiveStr::Ascii("ishes"),
        dictgen::InsensitiveStr::Ascii("ishing"),
        dictgen::InsensitiveStr::Ascii("ishment"),
        dictgen::InsensitiveStr::Ascii("tient"),
        dictgen::InsensitiveStr::Ascii("tients"),
        dictgen::InsensitiveStr::Ascii("titional"),
    ],
    values: &[
        &["nuremberg"],
        &["nourish"],
        &["nourished"],
        &["nourisher"],
        &["nourishes"],
        &["nourishing"],
        &["nourishment"],
        &["nutrient"],
        &["nutrients"],
        &["nutritional"],
    ],
    range: 3..=8,
};

static WORD_NUN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NUN_CHILDREN),
    value: None,
};

pub static WORD_NUN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ber"),
        dictgen::InsensitiveStr::Ascii("bers"),
    ],
    values: &[&["number"], &["numbers"]],
    range: 3..=4,
};

static WORD_NUM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NUM_CHILDREN),
    value: None,
};

pub static WORD_NUM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("bber"),
        dictgen::InsensitiveStr::Ascii("bbered"),
        dictgen::InsensitiveStr::Ascii("bbering"),
        dictgen::InsensitiveStr::Ascii("bbers"),
        dictgen::InsensitiveStr::Ascii("be"),
        dictgen::InsensitiveStr::Ascii("beral"),
        dictgen::InsensitiveStr::Ascii("berals"),
        dictgen::InsensitiveStr::Ascii("beric"),
        dictgen::InsensitiveStr::Ascii("berous"),
        dictgen::InsensitiveStr::Ascii("berr"),
        dictgen::InsensitiveStr::Ascii("berred"),
        dictgen::InsensitiveStr::Ascii("berring"),
        dictgen::InsensitiveStr::Ascii("berrs"),
        dictgen::InsensitiveStr::Ascii("berss"),
        dictgen::InsensitiveStr::Ascii("bert"),
        dictgen::InsensitiveStr::Ascii("bet"),
        dictgen::InsensitiveStr::Ascii("bets"),
        dictgen::InsensitiveStr::Ascii("bres"),
        dictgen::InsensitiveStr::Ascii("earate"),
        dictgen::InsensitiveStr::Ascii("earation"),
        dictgen::InsensitiveStr::Ascii("eber"),
        dictgen::InsensitiveStr::Ascii("ebering"),
        dictgen::InsensitiveStr::Ascii("ebers"),
        dictgen::InsensitiveStr::Ascii("ebr"),
        dictgen::InsensitiveStr::Ascii("ebrs"),
        dictgen::InsensitiveStr::Ascii("er"),
        dictgen::InsensitiveStr::Ascii("eraotr"),
        dictgen::InsensitiveStr::Ascii("erbering"),
        dictgen::InsensitiveStr::Ascii("ercial"),
        dictgen::InsensitiveStr::Ascii("ercially"),
        dictgen::InsensitiveStr::Ascii("erial"),
        dictgen::InsensitiveStr::Ascii("ericable"),
        dictgen::InsensitiveStr::Ascii("ering"),
        dictgen::InsensitiveStr::Ascii("erious"),
        dictgen::InsensitiveStr::Ascii("ers"),
        dictgen::InsensitiveStr::Ascii("mber"),
        dictgen::InsensitiveStr::Ascii("mbers"),
        dictgen::InsensitiveStr::Ascii("meric"),
        dictgen::InsensitiveStr::Ascii("nber"),
        dictgen::InsensitiveStr::Ascii("nbered"),
        dictgen::InsensitiveStr::Ascii("nbering"),
        dictgen::InsensitiveStr::Ascii("nbers"),
        dictgen::InsensitiveStr::Ascii("ner"),
        dictgen::InsensitiveStr::Ascii("ners"),
        dictgen::InsensitiveStr::Ascii("ver"),
        dictgen::InsensitiveStr::Ascii("vers"),
    ],
    values: &[
        &["number"],
        &["numbered"],
        &["numbering"],
        &["numbers"],
        &["number", "numb"],
        &["numeral"],
        &["numerals"],
        &["numeric"],
        &["numerous"],
        &["number"],
        &["numbered"],
        &["numbering"],
        &["numbers"],
        &["numbers"],
        &["number"],
        &["number"],
        &["numbers"],
        &["numbers"],
        &["numerate"],
        &["numeration"],
        &["number"],
        &["numbering"],
        &["numbers"],
        &["number"],
        &["numbers"],
        &["number"],
        &["numerator"],
        &["numbering"],
        &["numerical"],
        &["numerically"],
        &["numeral", "numerical"],
        &["numerical"],
        &["numbering"],
        &["numerous"],
        &["numbers"],
        &["number"],
        &["numbers"],
        &["numeric"],
        &["number"],
        &["numbered"],
        &["numbering"],
        &["numbers"],
        &["number"],
        &["numbers"],
        &["number"],
        &["numbers"],
    ],
    range: 2..=8,
};

static WORD_NUL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NUL_CHILDREN),
    value: None,
};

pub static WORD_NUL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("able"),
        dictgen::InsensitiveStr::Ascii("cear"),
        dictgen::InsensitiveStr::Ascii("k"),
        dictgen::InsensitiveStr::Ascii("labour"),
        dictgen::InsensitiveStr::Ascii("lalble"),
        dictgen::InsensitiveStr::Ascii("lfiy"),
        dictgen::InsensitiveStr::Ascii("lifiy"),
        dictgen::InsensitiveStr::Ascii("ll"),
    ],
    values: &[
        &["nullable"],
        &["nuclear"],
        &["null"],
        &["nullarbor"],
        &["nullable"],
        &["nullify"],
        &["nullify"],
        &["null"],
    ],
    range: 1..=6,
};

static WORD_NUI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NUI_CHILDREN),
    value: None,
};

pub static WORD_NUI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("sans"),
        dictgen::InsensitiveStr::Ascii("sanse"),
        dictgen::InsensitiveStr::Ascii("sanses"),
        dictgen::InsensitiveStr::Ascii("ssance"),
    ],
    values: &[
        &["nuisance"],
        &["nuisance"],
        &["nuisance", "nuisances"],
        &["nuisance"],
    ],
    range: 4..=6,
};

static WORD_NUE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NUE_CHILDREN),
    value: None,
};

pub static WORD_NUE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("rological"),
        dictgen::InsensitiveStr::Ascii("rons"),
        dictgen::InsensitiveStr::Ascii("roscience"),
        dictgen::InsensitiveStr::Ascii("tered"),
        dictgen::InsensitiveStr::Ascii("tral"),
        dictgen::InsensitiveStr::Ascii("trality"),
        dictgen::InsensitiveStr::Ascii("tron"),
    ],
    values: &[
        &["neurological"],
        &["neurons"],
        &["neuroscience"],
        &["neutered"],
        &["neutral"],
        &["neutrality"],
        &["neutron"],
    ],
    range: 4..=9,
};

static WORD_NUC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NUC_CHILDREN),
    value: None,
};

pub static WORD_NUC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("elar"),
        dictgen::InsensitiveStr::Ascii("elus"),
        dictgen::InsensitiveStr::Ascii("lean"),
        dictgen::InsensitiveStr::Ascii("leous"),
        dictgen::InsensitiveStr::Ascii("lues"),
        dictgen::InsensitiveStr::Ascii("ular"),
        dictgen::InsensitiveStr::Ascii("ulear"),
    ],
    values: &[
        &["nuclear"],
        &["nucleus"],
        &["unclean"],
        &["nucleus", "nucleolus"],
        &["nucleus"],
        &["nuclear"],
        &["nuclear"],
    ],
    range: 4..=5,
};

static WORD_NUB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NUB_CHILDREN),
    value: None,
};

pub static WORD_NUB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("er"),
        dictgen::InsensitiveStr::Ascii("ering"),
        dictgen::InsensitiveStr::Ascii("mer"),
        dictgen::InsensitiveStr::Ascii("mers"),
    ],
    values: &[&["number"], &["numbering"], &["number"], &["numbers"]],
    range: 2..=5,
};

static WORD_NUA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NUA_CHILDREN),
    value: None,
};

pub static WORD_NUA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ghty"),
        dictgen::InsensitiveStr::Ascii("tilus"),
    ],
    values: &[&["naughty"], &["nautilus"]],
    range: 4..=5,
};

static WORD_NT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NT_CHILDREN),
    value: None,
};

pub static WORD_NT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ification"),
        dictgen::InsensitiveStr::Ascii("o"),
    ],
    values: &[&["notification"], &["not"]],
    range: 1..=9,
};

static WORD_NS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NS_CHILDREN),
    value: None,
};

pub static WORD_NS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("tall"),
        dictgen::InsensitiveStr::Ascii("tallation"),
        dictgen::InsensitiveStr::Ascii("talled"),
        dictgen::InsensitiveStr::Ascii("talling"),
        dictgen::InsensitiveStr::Ascii("talls"),
    ],
    values: &[
        &["install"],
        &["installation"],
        &["installed"],
        &["installing"],
        &["installs"],
    ],
    range: 4..=9,
};

static WORD_NR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NR_CHILDREN),
    value: None,
};

pub static WORD_NR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ivana"),
        dictgen::InsensitiveStr::Ascii("omandy"),
        dictgen::InsensitiveStr::Ascii("twork"),
    ],
    values: &[&["nirvana"], &["normandy"], &["network"]],
    range: 5..=6,
};

static WORD_NO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_NO_CHILDREN),
    value: None,
};

static WORD_NO_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    Some(&WORD_NOC_NODE),
    Some(&WORD_NOD_NODE),
    Some(&WORD_NOE_NODE),
    Some(&WORD_NOF_NODE),
    None,
    Some(&WORD_NOH_NODE),
    Some(&WORD_NOI_NODE),
    Some(&WORD_NOJ_NODE),
    None,
    None,
    Some(&WORD_NOM_NODE),
    Some(&WORD_NON_NODE),
    Some(&WORD_NOO_NODE),
    None,
    None,
    Some(&WORD_NOR_NODE),
    Some(&WORD_NOS_NODE),
    Some(&WORD_NOT_NODE),
    None,
    Some(&WORD_NOV_NODE),
    Some(&WORD_NOW_NODE),
    None,
    None,
    None,
];

static WORD_NOW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NOW_CHILDREN),
    value: None,
};

pub static WORD_NOW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("adys"),
        dictgen::InsensitiveStr::Ascii("days"),
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("n"),
        dictgen::InsensitiveStr::Ascii("ns"),
    ],
    values: &[
        &["nowadays"],
        &["nowadays"],
        &["now"],
        &["known", "noun"],
        &["knowns", "nouns"],
    ],
    range: 1..=4,
};

static WORD_NOV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NOV_CHILDREN),
    value: None,
};

pub static WORD_NOV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eau"),
        dictgen::InsensitiveStr::Ascii("embeard"),
        dictgen::InsensitiveStr::Ascii("emeber"),
        dictgen::InsensitiveStr::Ascii("emer"),
        dictgen::InsensitiveStr::Ascii("ermber"),
        dictgen::InsensitiveStr::Ascii("isheate"),
        dictgen::InsensitiveStr::Ascii("isheates"),
        dictgen::InsensitiveStr::Ascii("isheut"),
        dictgen::InsensitiveStr::Ascii("isheuts"),
        dictgen::InsensitiveStr::Ascii("meber"),
    ],
    values: &[
        &["nouveau"],
        &["november"],
        &["november"],
        &["november"],
        &["november"],
        &["novitiate"],
        &["novitiates"],
        &["novitiate"],
        &["novitiates"],
        &["november"],
    ],
    range: 3..=8,
};

static WORD_NOT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_NOT_CHILDREN),
    value: None,
};

static WORD_NOT_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_NOTA_NODE),
    None,
    Some(&WORD_NOTC_NODE),
    None,
    Some(&WORD_NOTE_NODE),
    Some(&WORD_NOTF_NODE),
    None,
    Some(&WORD_NOTH_NODE),
    Some(&WORD_NOTI_NODE),
    None,
    None,
    None,
    Some(&WORD_NOTM_NODE),
    Some(&WORD_NOTN_NODE),
    Some(&WORD_NOTO_NODE),
    None,
    None,
    None,
    Some(&WORD_NOTS_NODE),
    Some(&WORD_NOTT_NODE),
    None,
    None,
    Some(&WORD_NOTW_NODE),
    None,
    None,
    None,
];

static WORD_NOTW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NOTW_CHILDREN),
    value: None,
};

pub static WORD_NOTW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("hithstanding")],
    values: &[&["notwithstanding"]],
    range: 12..=12,
};

static WORD_NOTT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NOTT_CHILDREN),
    value: Some(&["not"]),
};

pub static WORD_NOTT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aion"),
        dictgen::InsensitiveStr::Ascii("aions"),
    ],
    values: &[&["notation"], &["notations"]],
    range: 4..=5,
};

static WORD_NOTS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NOTS_CHILDREN),
    value: None,
};

pub static WORD_NOTS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("e")],
    values: &[&["notes", "note"]],
    range: 1..=1,
};

static WORD_NOTO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NOTO_CHILDREN),
    value: None,
};

pub static WORD_NOTO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("d"),
        dictgen::InsensitiveStr::Ascii("focation"),
        dictgen::InsensitiveStr::Ascii("focations"),
        dictgen::InsensitiveStr::Ascii("reous"),
        dictgen::InsensitiveStr::Ascii("reously"),
        dictgen::InsensitiveStr::Ascii("rios"),
        dictgen::InsensitiveStr::Ascii("riosly"),
        dictgen::InsensitiveStr::Ascii("rity"),
        dictgen::InsensitiveStr::Ascii("riuosly"),
        dictgen::InsensitiveStr::Ascii("roius"),
    ],
    values: &[
        &["noted"],
        &["notification"],
        &["notifications"],
        &["notorious"],
        &["notoriously"],
        &["notorious"],
        &["notoriously"],
        &["notoriety"],
        &["notoriously"],
        &["notorious"],
    ],
    range: 1..=9,
};

static WORD_NOTN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NOTN_CHILDREN),
    value: None,
};

pub static WORD_NOTN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ing")],
    values: &[&["nothing"]],
    range: 3..=3,
};

static WORD_NOTM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NOTM_CHILDREN),
    value: None,
};

pub static WORD_NOTM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("alize"),
        dictgen::InsensitiveStr::Ascii("alized"),
        dictgen::InsensitiveStr::Ascii("utch"),
    ],
    values: &[&["normalize"], &["normalized"], &["notmuch"]],
    range: 4..=6,
};

static WORD_NOTI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NOTI_CHILDREN),
    value: None,
};

pub static WORD_NOTI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cabe"),
        dictgen::InsensitiveStr::Ascii("cabely"),
        dictgen::InsensitiveStr::Ascii("cable"),
        dictgen::InsensitiveStr::Ascii("cabley"),
        dictgen::InsensitiveStr::Ascii("cably"),
        dictgen::InsensitiveStr::Ascii("calbe"),
        dictgen::InsensitiveStr::Ascii("cation"),
        dictgen::InsensitiveStr::Ascii("cations"),
        dictgen::InsensitiveStr::Ascii("ceablely"),
        dictgen::InsensitiveStr::Ascii("ceabley"),
        dictgen::InsensitiveStr::Ascii("ceing"),
        dictgen::InsensitiveStr::Ascii("ciable"),
        dictgen::InsensitiveStr::Ascii("ciably"),
        dictgen::InsensitiveStr::Ascii("cible"),
        dictgen::InsensitiveStr::Ascii("cication"),
        dictgen::InsensitiveStr::Ascii("cications"),
        dictgen::InsensitiveStr::Ascii("dy"),
        dictgen::InsensitiveStr::Ascii("facation"),
        dictgen::InsensitiveStr::Ascii("facations"),
        dictgen::InsensitiveStr::Ascii("faction"),
        dictgen::InsensitiveStr::Ascii("factions"),
        dictgen::InsensitiveStr::Ascii("fcation"),
        dictgen::InsensitiveStr::Ascii("fcations"),
        dictgen::InsensitiveStr::Ascii("fed"),
        dictgen::InsensitiveStr::Ascii("fer"),
        dictgen::InsensitiveStr::Ascii("fes"),
        dictgen::InsensitiveStr::Ascii("fiaction"),
        dictgen::InsensitiveStr::Ascii("fiactions"),
        dictgen::InsensitiveStr::Ascii("fiation"),
        dictgen::InsensitiveStr::Ascii("fiations"),
        dictgen::InsensitiveStr::Ascii("ficacion"),
        dictgen::InsensitiveStr::Ascii("ficaction"),
        dictgen::InsensitiveStr::Ascii("ficactions"),
        dictgen::InsensitiveStr::Ascii("ficaion"),
        dictgen::InsensitiveStr::Ascii("ficaions"),
        dictgen::InsensitiveStr::Ascii("ficaiton"),
        dictgen::InsensitiveStr::Ascii("ficaitons"),
        dictgen::InsensitiveStr::Ascii("ficarion"),
        dictgen::InsensitiveStr::Ascii("ficarions"),
        dictgen::InsensitiveStr::Ascii("ficastion"),
        dictgen::InsensitiveStr::Ascii("ficastions"),
        dictgen::InsensitiveStr::Ascii("ficatios"),
        dictgen::InsensitiveStr::Ascii("ficaton"),
        dictgen::InsensitiveStr::Ascii("ficatons"),
        dictgen::InsensitiveStr::Ascii("ficiation"),
        dictgen::InsensitiveStr::Ascii("ficiations"),
        dictgen::InsensitiveStr::Ascii("ficications"),
        dictgen::InsensitiveStr::Ascii("fictation"),
        dictgen::InsensitiveStr::Ascii("fictations"),
        dictgen::InsensitiveStr::Ascii("fiction"),
        dictgen::InsensitiveStr::Ascii("fictions"),
        dictgen::InsensitiveStr::Ascii("fifation"),
        dictgen::InsensitiveStr::Ascii("fifations"),
        dictgen::InsensitiveStr::Ascii("fiy"),
        dictgen::InsensitiveStr::Ascii("fiying"),
        dictgen::InsensitiveStr::Ascii("fycation"),
        dictgen::InsensitiveStr::Ascii("gication"),
        dictgen::InsensitiveStr::Ascii("gications"),
        dictgen::InsensitiveStr::Ascii("rications"),
        dictgen::InsensitiveStr::Ascii("ty"),
    ],
    values: &[
        &["noticeable"],
        &["noticeably"],
        &["noticeable"],
        &["noticeably"],
        &["noticeably"],
        &["noticeable"],
        &["notification"],
        &["notifications"],
        &["noticeably"],
        &["noticeably"],
        &["noticing"],
        &["noticeable"],
        &["noticeably"],
        &["noticeable"],
        &["notification"],
        &["notifications"],
        &["notify"],
        &["notification"],
        &["notifications"],
        &["notification"],
        &["notifications"],
        &["notification"],
        &["notifications"],
        &["notified"],
        &["notifier"],
        &["notifies"],
        &["notification"],
        &["notifications"],
        &["notification"],
        &["notifications"],
        &["notification"],
        &["notification"],
        &["notifications"],
        &["notification"],
        &["notifications"],
        &["notification"],
        &["notifications"],
        &["notification"],
        &["notifications"],
        &["notification"],
        &["notifications"],
        &["notification", "notifications"],
        &["notification"],
        &["notifications"],
        &["notification"],
        &["notifications"],
        &["notifications"],
        &["notification"],
        &["notifications"],
        &["notification"],
        &["notifications"],
        &["notification"],
        &["notifications"],
        &["notify"],
        &["notifying"],
        &["notification"],
        &["notification"],
        &["notifications"],
        &["notifications"],
        &["notify"],
    ],
    range: 2..=11,
};

static WORD_NOTH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NOTH_CHILDREN),
    value: Some(&["north"]),
};

pub static WORD_NOTH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("ern"),
        dictgen::InsensitiveStr::Ascii("ign"),
        dictgen::InsensitiveStr::Ascii("igng"),
        dictgen::InsensitiveStr::Ascii("ihg"),
        dictgen::InsensitiveStr::Ascii("in"),
        dictgen::InsensitiveStr::Ascii("ind"),
        dictgen::InsensitiveStr::Ascii("ingess"),
        dictgen::InsensitiveStr::Ascii("ingsness"),
        dictgen::InsensitiveStr::Ascii("ink"),
    ],
    values: &[
        &["north", "note"],
        &["northern"],
        &["nothing"],
        &["nothing"],
        &["nothing"],
        &["nothing"],
        &["nothing"],
        &["nothingness"],
        &["nothingness"],
        &["nothing"],
    ],
    range: 1..=8,
};

static WORD_NOTF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NOTF_CHILDREN),
    value: None,
};

pub static WORD_NOTF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ication"),
        dictgen::InsensitiveStr::Ascii("ications"),
        dictgen::InsensitiveStr::Ascii("y"),
    ],
    values: &[&["notification"], &["notifications"], &["notify"]],
    range: 1..=8,
};

static WORD_NOTE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NOTE_CHILDREN),
    value: None,
};

pub static WORD_NOTE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("able"),
        dictgen::InsensitiveStr::Ascii("ably"),
        dictgen::InsensitiveStr::Ascii("bok"),
        dictgen::InsensitiveStr::Ascii("boook"),
        dictgen::InsensitiveStr::Ascii("boooks"),
        dictgen::InsensitiveStr::Ascii("riety"),
        dictgen::InsensitiveStr::Ascii("worhty"),
        dictgen::InsensitiveStr::Ascii("worthly"),
        dictgen::InsensitiveStr::Ascii("worty"),
    ],
    values: &[
        &["notable"],
        &["notably"],
        &["notebook"],
        &["notebook"],
        &["notebooks"],
        &["notoriety"],
        &["noteworthy"],
        &["noteworthy"],
        &["noteworthy"],
    ],
    range: 3..=7,
};

static WORD_NOTC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NOTC_CHILDREN),
    value: None,
};

pub static WORD_NOTC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("iable")],
    values: &[&["noticeable"]],
    range: 5..=5,
};

static WORD_NOTA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NOTA_CHILDREN),
    value: None,
};

pub static WORD_NOTA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("bley"),
        dictgen::InsensitiveStr::Ascii("blly"),
        dictgen::InsensitiveStr::Ascii("cible"),
        dictgen::InsensitiveStr::Ascii("ion"),
        dictgen::InsensitiveStr::Ascii("ly"),
        dictgen::InsensitiveStr::Ascii("rio"),
        dictgen::InsensitiveStr::Ascii("sion"),
        dictgen::InsensitiveStr::Ascii("tin"),
    ],
    values: &[
        &["notably"],
        &["notably"],
        &["noticeable"],
        &["notation"],
        &["notably"],
        &["ontario"],
        &["notation"],
        &["notation"],
    ],
    range: 2..=5,
};

static WORD_NOS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NOS_CHILDREN),
    value: None,
};

pub static WORD_NOS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("taglia"),
        dictgen::InsensitiveStr::Ascii("taglic"),
        dictgen::InsensitiveStr::Ascii("talga"),
        dictgen::InsensitiveStr::Ascii("talgica"),
        dictgen::InsensitiveStr::Ascii("talgija"),
        dictgen::InsensitiveStr::Ascii("talgisch"),
        dictgen::InsensitiveStr::Ascii("taliga"),
        dictgen::InsensitiveStr::Ascii("taligc"),
        dictgen::InsensitiveStr::Ascii("tirls"),
        dictgen::InsensitiveStr::Ascii("tlagia"),
        dictgen::InsensitiveStr::Ascii("tlagic"),
        dictgen::InsensitiveStr::Ascii("tolgia"),
        dictgen::InsensitiveStr::Ascii("tolgic"),
        dictgen::InsensitiveStr::Ascii("tolgically"),
        dictgen::InsensitiveStr::Ascii("tolgicly"),
        dictgen::InsensitiveStr::Ascii("triles"),
        dictgen::InsensitiveStr::Ascii("trills"),
        dictgen::InsensitiveStr::Ascii("tris"),
    ],
    values: &[
        &["nostalgia"],
        &["nostalgic"],
        &["nostalgia"],
        &["nostalgia"],
        &["nostalgia"],
        &["nostalgic"],
        &["nostalgia"],
        &["nostalgic"],
        &["nostrils"],
        &["nostalgia"],
        &["nostalgic"],
        &["nostalgia"],
        &["nostalgic"],
        &["nostalgically"],
        &["nostalgically"],
        &["nostrils"],
        &["nostrils"],
        &["nostrils"],
    ],
    range: 4..=10,
};

static WORD_NOR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NOR_CHILDREN),
    value: None,
};

pub static WORD_NOR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("al"),
        dictgen::InsensitiveStr::Ascii("alize"),
        dictgen::InsensitiveStr::Ascii("alized"),
        dictgen::InsensitiveStr::Ascii("amal"),
        dictgen::InsensitiveStr::Ascii("amalise"),
        dictgen::InsensitiveStr::Ascii("amalised"),
        dictgen::InsensitiveStr::Ascii("amalises"),
        dictgen::InsensitiveStr::Ascii("amalising"),
        dictgen::InsensitiveStr::Ascii("amalize"),
        dictgen::InsensitiveStr::Ascii("amalized"),
        dictgen::InsensitiveStr::Ascii("amalizes"),
        dictgen::InsensitiveStr::Ascii("amalizing"),
        dictgen::InsensitiveStr::Ascii("amals"),
        dictgen::InsensitiveStr::Ascii("aml"),
        dictgen::InsensitiveStr::Ascii("amlly"),
        dictgen::InsensitiveStr::Ascii("amls"),
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("hern"),
        dictgen::InsensitiveStr::Ascii("hteast"),
        dictgen::InsensitiveStr::Ascii("htern"),
        dictgen::InsensitiveStr::Ascii("htwest"),
        dictgen::InsensitiveStr::Ascii("htwestern"),
        dictgen::InsensitiveStr::Ascii("ifications"),
        dictgen::InsensitiveStr::Ascii("mailzation"),
        dictgen::InsensitiveStr::Ascii("maized"),
        dictgen::InsensitiveStr::Ascii("male"),
        dictgen::InsensitiveStr::Ascii("males"),
        dictgen::InsensitiveStr::Ascii("malis"),
        dictgen::InsensitiveStr::Ascii("malizd"),
        dictgen::InsensitiveStr::Ascii("mall"),
        dictgen::InsensitiveStr::Ascii("mallized"),
        dictgen::InsensitiveStr::Ascii("malls"),
        dictgen::InsensitiveStr::Ascii("malos"),
        dictgen::InsensitiveStr::Ascii("maly"),
        dictgen::InsensitiveStr::Ascii("malyl"),
        dictgen::InsensitiveStr::Ascii("malyly"),
        dictgen::InsensitiveStr::Ascii("malysed"),
        dictgen::InsensitiveStr::Ascii("malyy"),
        dictgen::InsensitiveStr::Ascii("malyzation"),
        dictgen::InsensitiveStr::Ascii("malyze"),
        dictgen::InsensitiveStr::Ascii("malyzed"),
        dictgen::InsensitiveStr::Ascii("manday"),
        dictgen::InsensitiveStr::Ascii("many"),
        dictgen::InsensitiveStr::Ascii("mlly"),
        dictgen::InsensitiveStr::Ascii("mnal"),
        dictgen::InsensitiveStr::Ascii("mol"),
        dictgen::InsensitiveStr::Ascii("molise"),
        dictgen::InsensitiveStr::Ascii("molize"),
        dictgen::InsensitiveStr::Ascii("theat"),
        dictgen::InsensitiveStr::Ascii("then"),
        dictgen::InsensitiveStr::Ascii("thereastern"),
        dictgen::InsensitiveStr::Ascii("theren"),
        dictgen::InsensitiveStr::Ascii("therend"),
        dictgen::InsensitiveStr::Ascii("thren"),
        dictgen::InsensitiveStr::Ascii("thwesten"),
        dictgen::InsensitiveStr::Ascii("thwestener"),
        dictgen::InsensitiveStr::Ascii("thwet"),
        dictgen::InsensitiveStr::Ascii("tification"),
        dictgen::InsensitiveStr::Ascii("tifications"),
        dictgen::InsensitiveStr::Ascii("tmally"),
        dictgen::InsensitiveStr::Ascii("wegain"),
        dictgen::InsensitiveStr::Ascii("wegin"),
        dictgen::InsensitiveStr::Ascii("wiegan"),
    ],
    values: &[
        &["normal", "moral"],
        &["normalize"],
        &["normalized"],
        &["normal"],
        &["normalise"],
        &["normalised"],
        &["normalises"],
        &["normalising"],
        &["normalize"],
        &["normalized"],
        &["normalizes"],
        &["normalizing"],
        &["normals"],
        &["normal"],
        &["normally"],
        &["normals"],
        &["nor", "more", "node", "note"],
        &["northern"],
        &["northeast"],
        &["northern"],
        &["northwest"],
        &["northwestern"],
        &["notifications"],
        &["normalization"],
        &["normalized"],
        &["normal"],
        &["normals"],
        &["normals"],
        &["normalized"],
        &["normal", "normally"],
        &["normalized"],
        &["normals"],
        &["normals"],
        &["normally"],
        &["normally"],
        &["normally"],
        &["normalised"],
        &["normally"],
        &["normalization"],
        &["normalize"],
        &["normalized"],
        &["normandy"],
        &["normandy"],
        &["normally"],
        &["normal"],
        &["normal"],
        &["normalise"],
        &["normalize"],
        &["northeast"],
        &["northern"],
        &["northeastern"],
        &["northern"],
        &["northern"],
        &["northern"],
        &["northwestern"],
        &["northwestern"],
        &["northwest"],
        &["notification"],
        &["notifications"],
        &["normally"],
        &["norwegian"],
        &["norwegian"],
        &["norwegian"],
    ],
    range: 1..=11,
};

static WORD_NOO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NOO_CHILDREN),
    value: Some(&["no"]),
};

pub static WORD_NOO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[],
    values: &[],
    range: 0..=0,
};

static WORD_NON_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NON_CHILDREN),
    value: None,
};

pub static WORD_NON_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("combatents"),
        dictgen::InsensitiveStr::Ascii("esense"),
        dictgen::InsensitiveStr::Ascii("esensical"),
        dictgen::InsensitiveStr::Ascii("existance"),
        dictgen::InsensitiveStr::Ascii("existant"),
        dictgen::InsensitiveStr::Ascii("inital"),
        dictgen::InsensitiveStr::Ascii("initalized"),
        dictgen::InsensitiveStr::Ascii("negarive"),
        dictgen::InsensitiveStr::Ascii("sence"),
        dictgen::InsensitiveStr::Ascii("sencial"),
        dictgen::InsensitiveStr::Ascii("sencical"),
        dictgen::InsensitiveStr::Ascii("sene"),
        dictgen::InsensitiveStr::Ascii("sens"),
        dictgen::InsensitiveStr::Ascii("senscial"),
        dictgen::InsensitiveStr::Ascii("sensicle"),
        dictgen::InsensitiveStr::Ascii("sesne"),
        dictgen::InsensitiveStr::Ascii("significant"),
        dictgen::InsensitiveStr::Ascii("te"),
        dictgen::InsensitiveStr::Ascii("theless"),
    ],
    values: &[
        &["noncombatants"],
        &["nonsense"],
        &["nonsensical"],
        &["nonexistence"],
        &["nonexistent"],
        &["noninitial"],
        &["noninitialized"],
        &["nonnegative"],
        &["nonsense"],
        &["nonsensical"],
        &["nonsensical"],
        &["nonsense"],
        &["nonsense"],
        &["nonsensical"],
        &["nonsensical"],
        &["nonsense"],
        &["insignificant"],
        &["note"],
        &["nonetheless"],
    ],
    range: 2..=11,
};

static WORD_NOM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NOM_CHILDREN),
    value: None,
};

pub static WORD_NOM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ber"),
        dictgen::InsensitiveStr::Ascii("bered"),
        dictgen::InsensitiveStr::Ascii("bering"),
        dictgen::InsensitiveStr::Ascii("bers"),
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("imal"),
        dictgen::InsensitiveStr::Ascii("inacion"),
        dictgen::InsensitiveStr::Ascii("inae"),
        dictgen::InsensitiveStr::Ascii("inatie"),
        dictgen::InsensitiveStr::Ascii("inatin"),
        dictgen::InsensitiveStr::Ascii("inatino"),
        dictgen::InsensitiveStr::Ascii("inativo"),
        dictgen::InsensitiveStr::Ascii("inato"),
        dictgen::InsensitiveStr::Ascii("inatons"),
        dictgen::InsensitiveStr::Ascii("inet"),
        dictgen::InsensitiveStr::Ascii("ralization"),
    ],
    values: &[
        &["number"],
        &["numbered"],
        &["numbering"],
        &["numbers"],
        &["gnomes"],
        &["nominal"],
        &["nomination"],
        &["nominate"],
        &["nominate"],
        &["nomination"],
        &["nominations"],
        &["nomination"],
        &["nomination"],
        &["nominations"],
        &["nominate"],
        &["normalization"],
    ],
    range: 2..=10,
};

static WORD_NOJ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NOJ_CHILDREN),
    value: None,
};

pub static WORD_NOJ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ification"),
        dictgen::InsensitiveStr::Ascii("ifications"),
    ],
    values: &[&["notification"], &["notifications"]],
    range: 9..=10,
};

static WORD_NOI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NOI_CHILDREN),
    value: None,
};

pub static WORD_NOI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ce"),
        dictgen::InsensitiveStr::Ascii("ser"),
    ],
    values: &[&["noise", "nice", "notice"], &["noisier"]],
    range: 2..=3,
};

static WORD_NOH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NOH_CHILDREN),
    value: None,
};

pub static WORD_NOH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ypen")],
    values: &[&["nohyphen"]],
    range: 4..=4,
};

static WORD_NOF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NOF_CHILDREN),
    value: None,
};

pub static WORD_NOF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ified"),
        dictgen::InsensitiveStr::Ascii("ity"),
    ],
    values: &[&["notified"], &["notify"]],
    range: 3..=5,
};

static WORD_NOE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NOE_CHILDREN),
    value: Some(&["not", "no", "node", "know", "now", "note"]),
};

pub static WORD_NOE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[],
    values: &[],
    range: 0..=0,
};

static WORD_NOD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NOD_CHILDREN),
    value: None,
};

pub static WORD_NOD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("el"),
        dictgen::InsensitiveStr::Ascii("els"),
        dictgen::InsensitiveStr::Ascii("ess"),
        dictgen::InsensitiveStr::Ascii("ulated"),
    ],
    values: &[&["model", "nodal"], &["models"], &["nodes"], &["modulated"]],
    range: 2..=6,
};

static WORD_NOC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NOC_CHILDREN),
    value: None,
};

pub static WORD_NOC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("trune"),
        dictgen::InsensitiveStr::Ascii("tunre"),
        dictgen::InsensitiveStr::Ascii("ture"),
        dictgen::InsensitiveStr::Ascii("turen"),
    ],
    values: &[&["nocturne"], &["nocturne"], &["nocturne"], &["nocturne"]],
    range: 4..=5,
};

static WORD_NN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NN_CHILDREN),
    value: None,
};

pub static WORD_NN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("eeded"),
        dictgen::InsensitiveStr::Ascii("er"),
        dictgen::InsensitiveStr::Ascii("ovisheate"),
        dictgen::InsensitiveStr::Ascii("ovisheates"),
        dictgen::InsensitiveStr::Ascii("umber"),
    ],
    values: &[
        &["need"],
        &["needed"],
        &["inner"],
        &["novitiate"],
        &["novitiates"],
        &["number"],
    ],
    range: 2..=10,
};

static WORD_NM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NM_CHILDREN),
    value: None,
};

pub static WORD_NM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ae"),
        dictgen::InsensitiveStr::Ascii("me"),
    ],
    values: &[&["name"], &["name"]],
    range: 2..=2,
};

static WORD_NK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NK_CHILDREN),
    value: None,
};

pub static WORD_NK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("nown"),
        dictgen::InsensitiveStr::Ascii("ow"),
        dictgen::InsensitiveStr::Ascii("wo"),
    ],
    values: &[&["unknown"], &["know"], &["know"]],
    range: 2..=4,
};

static WORD_NI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_NI_CHILDREN),
    value: None,
};

static WORD_NI_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    Some(&WORD_NIC_NODE),
    None,
    Some(&WORD_NIE_NODE),
    Some(&WORD_NIF_NODE),
    Some(&WORD_NIG_NODE),
    Some(&WORD_NIH_NODE),
    None,
    None,
    None,
    Some(&WORD_NIL_NODE),
    Some(&WORD_NIM_NODE),
    Some(&WORD_NIN_NODE),
    None,
    Some(&WORD_NIP_NODE),
    None,
    Some(&WORD_NIR_NODE),
    None,
    Some(&WORD_NIT_NODE),
    Some(&WORD_NIU_NODE),
    Some(&WORD_NIV_NODE),
    None,
    None,
    None,
    None,
];

static WORD_NIV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NIV_CHILDREN),
    value: None,
};

pub static WORD_NIV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("erse"),
        dictgen::InsensitiveStr::Ascii("es"),
    ],
    values: &[
        &["inverse"],
        &[
            "dives", "fives", "hives", "knives", "nieves", "nines", "wives",
        ],
    ],
    range: 2..=4,
};

static WORD_NIU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NIU_CHILDREN),
    value: None,
};

pub static WORD_NIU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("sance")],
    values: &[&["nuisance"]],
    range: 5..=5,
};

static WORD_NIT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NIT_CHILDREN),
    value: None,
};

pub static WORD_NIT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ch"),
        dictgen::InsensitiveStr::Ascii("ched"),
        dictgen::InsensitiveStr::Ascii("ches"),
        dictgen::InsensitiveStr::Ascii("ching"),
        dictgen::InsensitiveStr::Ascii("her"),
        dictgen::InsensitiveStr::Ascii("ification"),
        dictgen::InsensitiveStr::Ascii("ifications"),
        dictgen::InsensitiveStr::Ascii("orgen"),
        dictgen::InsensitiveStr::Ascii("pciking"),
    ],
    values: &[
        &["niche"],
        &["niched"],
        &["niches"],
        &["niching"],
        &["neither"],
        &["notification"],
        &["notifications"],
        &["nitrogen"],
        &["nitpicking"],
    ],
    range: 2..=10,
};

static WORD_NIR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NIR_CHILDREN),
    value: None,
};

pub static WORD_NIR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("togen"),
        dictgen::InsensitiveStr::Ascii("vanna"),
    ],
    values: &[&["nitrogen"], &["nirvana"]],
    range: 5..=5,
};

static WORD_NIP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NIP_CHILDREN),
    value: None,
};

pub static WORD_NIP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ticking")],
    values: &[&["nitpicking"]],
    range: 7..=7,
};

static WORD_NIN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NIN_CHILDREN),
    value: Some(&["inn", "min", "bin", "nine"]),
};

pub static WORD_NIN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eth"),
        dictgen::InsensitiveStr::Ascii("ima"),
        dictgen::InsensitiveStr::Ascii("imal"),
        dictgen::InsensitiveStr::Ascii("imally"),
        dictgen::InsensitiveStr::Ascii("imum"),
        dictgen::InsensitiveStr::Ascii("j"),
        dictgen::InsensitiveStr::Ascii("js"),
        dictgen::InsensitiveStr::Ascii("teenth"),
        dictgen::InsensitiveStr::Ascii("ties"),
        dictgen::InsensitiveStr::Ascii("ty"),
    ],
    values: &[
        &["ninth"],
        &["minima"],
        &["minimal"],
        &["minimally"],
        &["minimum"],
        &["ninja"],
        &["ninja", "ninjas"],
        &["nineteenth"],
        &["nineties"],
        &["ninety", "minty"],
    ],
    range: 1..=6,
};

static WORD_NIM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NIM_CHILDREN),
    value: None,
};

pub static WORD_NIM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ph"),
        dictgen::InsensitiveStr::Ascii("phal"),
        dictgen::InsensitiveStr::Ascii("phean"),
        dictgen::InsensitiveStr::Ascii("phian"),
        dictgen::InsensitiveStr::Ascii("phlike"),
        dictgen::InsensitiveStr::Ascii("pho"),
        dictgen::InsensitiveStr::Ascii("phomania"),
        dictgen::InsensitiveStr::Ascii("phomaniac"),
        dictgen::InsensitiveStr::Ascii("phomaniacs"),
        dictgen::InsensitiveStr::Ascii("phos"),
        dictgen::InsensitiveStr::Ascii("phs"),
        dictgen::InsensitiveStr::Ascii("ute"),
        dictgen::InsensitiveStr::Ascii("utes"),
    ],
    values: &[
        &["nymph"],
        &["nymphal"],
        &["nymphean"],
        &["nymphean"],
        &["nymphlike"],
        &["nympho"],
        &["nymphomania"],
        &["nymphomaniac"],
        &["nymphomaniacs"],
        &["nymphos"],
        &["nymphs"],
        &["minute"],
        &["minutes"],
    ],
    range: 2..=10,
};

static WORD_NIL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NIL_CHILDREN),
    value: None,
};

pub static WORD_NIL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ihism")],
    values: &[&["nihilism"]],
    range: 5..=5,
};

static WORD_NIH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NIH_CHILDREN),
    value: None,
};

pub static WORD_NIH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ilim"),
        dictgen::InsensitiveStr::Ascii("ilisim"),
        dictgen::InsensitiveStr::Ascii("ilsim"),
        dictgen::InsensitiveStr::Ascii("ther"),
    ],
    values: &[&["nihilism"], &["nihilism"], &["nihilism"], &["neither"]],
    range: 4..=6,
};

static WORD_NIG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NIG_CHILDREN),
    value: None,
};

pub static WORD_NIG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("hbor"),
        dictgen::InsensitiveStr::Ascii("hborhood"),
        dictgen::InsensitiveStr::Ascii("hboring"),
        dictgen::InsensitiveStr::Ascii("hlties"),
        dictgen::InsensitiveStr::Ascii("hlty"),
        dictgen::InsensitiveStr::Ascii("hther"),
        dictgen::InsensitiveStr::Ascii("htime"),
        dictgen::InsensitiveStr::Ascii("htlcub"),
        dictgen::InsensitiveStr::Ascii("htley"),
        dictgen::InsensitiveStr::Ascii("htlie"),
        dictgen::InsensitiveStr::Ascii("htmarket"),
        dictgen::InsensitiveStr::Ascii("htmates"),
        dictgen::InsensitiveStr::Ascii("htmears"),
        dictgen::InsensitiveStr::Ascii("htmeres"),
        dictgen::InsensitiveStr::Ascii("thclub"),
        dictgen::InsensitiveStr::Ascii("thlife"),
        dictgen::InsensitiveStr::Ascii("thly"),
        dictgen::InsensitiveStr::Ascii("thmare"),
        dictgen::InsensitiveStr::Ascii("thmares"),
    ],
    values: &[
        &["neighbor"],
        &["neighborhood"],
        &["neighboring"],
        &["nightlies"],
        &["nightly"],
        &["neither"],
        &["nighttime"],
        &["nightclub"],
        &["nightly"],
        &["nightlife"],
        &["nightmare"],
        &["nightmares"],
        &["nightmares"],
        &["nightmares"],
        &["nightclub"],
        &["nightlife"],
        &["nightly"],
        &["nightmare"],
        &["nightmares"],
    ],
    range: 4..=8,
};

static WORD_NIF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NIF_CHILDREN),
    value: None,
};

pub static WORD_NIF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("es"),
    ],
    values: &[&["knife"], &["knives"]],
    range: 1..=2,
};

static WORD_NIE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NIE_CHILDREN),
    value: None,
};

pub static WORD_NIE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ar"),
        dictgen::InsensitiveStr::Ascii("arest"),
        dictgen::InsensitiveStr::Ascii("ghbor"),
        dictgen::InsensitiveStr::Ascii("ghborhood"),
        dictgen::InsensitiveStr::Ascii("ghborhoods"),
        dictgen::InsensitiveStr::Ascii("ghboring"),
        dictgen::InsensitiveStr::Ascii("ghbour"),
        dictgen::InsensitiveStr::Ascii("ghbourhood"),
        dictgen::InsensitiveStr::Ascii("ghbourhoods"),
        dictgen::InsensitiveStr::Ascii("ghbours"),
        dictgen::InsensitiveStr::Ascii("ther"),
        dictgen::InsensitiveStr::Ascii("ve"),
        dictgen::InsensitiveStr::Ascii("veatay"),
        dictgen::InsensitiveStr::Ascii("vely"),
    ],
    values: &[
        &["near"],
        &["nearest"],
        &["neighbor"],
        &["neighborhood"],
        &["neighborhoods"],
        &["neighboring"],
        &["neighbour"],
        &["neighbourhood"],
        &["neighbourhood"],
        &["neighbours"],
        &["neither"],
        &["naive"],
        &["naivete"],
        &["naively"],
    ],
    range: 2..=11,
};

static WORD_NIC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NIC_CHILDREN),
    value: None,
};

pub static WORD_NIC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("kanme"),
        dictgen::InsensitiveStr::Ascii("kmane"),
    ],
    values: &[&["nickname"], &["nickname"]],
    range: 5..=5,
};

static WORD_NE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_NE_CHILDREN),
    value: None,
};

static WORD_NE_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_NEA_NODE),
    None,
    Some(&WORD_NEC_NODE),
    Some(&WORD_NED_NODE),
    Some(&WORD_NEE_NODE),
    Some(&WORD_NEF_NODE),
    Some(&WORD_NEG_NODE),
    None,
    Some(&WORD_NEI_NODE),
    None,
    None,
    Some(&WORD_NEL_NODE),
    None,
    Some(&WORD_NEN_NODE),
    Some(&WORD_NEO_NODE),
    None,
    None,
    Some(&WORD_NER_NODE),
    Some(&WORD_NES_NODE),
    Some(&WORD_NET_NODE),
    Some(&WORD_NEU_NODE),
    Some(&WORD_NEV_NODE),
    Some(&WORD_NEW_NODE),
    Some(&WORD_NEX_NODE),
    None,
    None,
];

static WORD_NEX_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NEX_CHILDREN),
    value: None,
};

pub static WORD_NEX_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ting"),
        dictgen::InsensitiveStr::Ascii("twork"),
    ],
    values: &[&["nesting", "texting"], &["network"]],
    range: 4..=5,
};

static WORD_NEW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NEW_CHILDREN),
    value: None,
};

pub static WORD_NEW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ance"),
        dictgen::InsensitiveStr::Ascii("anced"),
        dictgen::InsensitiveStr::Ascii("ances"),
        dictgen::InsensitiveStr::Ascii("ancing"),
        dictgen::InsensitiveStr::Ascii("caslte"),
        dictgen::InsensitiveStr::Ascii("caste"),
        dictgen::InsensitiveStr::Ascii("castel"),
        dictgen::InsensitiveStr::Ascii("ine"),
        dictgen::InsensitiveStr::Ascii("ines"),
        dictgen::InsensitiveStr::Ascii("letters"),
        dictgen::InsensitiveStr::Ascii("lsetter"),
        dictgen::InsensitiveStr::Ascii("matic"),
        dictgen::InsensitiveStr::Ascii("matically"),
        dictgen::InsensitiveStr::Ascii("maticly"),
        dictgen::InsensitiveStr::Ascii("monectomies"),
        dictgen::InsensitiveStr::Ascii("monectomy"),
        dictgen::InsensitiveStr::Ascii("monia"),
        dictgen::InsensitiveStr::Ascii("monic"),
        dictgen::InsensitiveStr::Ascii("monitis"),
        dictgen::InsensitiveStr::Ascii("ork"),
        dictgen::InsensitiveStr::Ascii("orks"),
        dictgen::InsensitiveStr::Ascii("sans"),
        dictgen::InsensitiveStr::Ascii("sanses"),
        dictgen::InsensitiveStr::Ascii("settler"),
        dictgen::InsensitiveStr::Ascii("slatter"),
        dictgen::InsensitiveStr::Ascii("slines"),
        dictgen::InsensitiveStr::Ascii("spapaers"),
        dictgen::InsensitiveStr::Ascii("spappers"),
        dictgen::InsensitiveStr::Ascii("thon"),
        dictgen::InsensitiveStr::Ascii("tork"),
        dictgen::InsensitiveStr::Ascii("twork"),
    ],
    values: &[
        &["nuance"],
        &["nuanced"],
        &["nuances"],
        &["nuancing"],
        &["newcastle"],
        &["newcastle"],
        &["newcastle"],
        &["newline"],
        &["newlines"],
        &["newsletters"],
        &["newsletter"],
        &["pneumatic"],
        &["pneumatically"],
        &["pneumatically"],
        &["pneumonectomies"],
        &["pneumonectomy"],
        &["pneumonia"],
        &["pneumonic"],
        &["pneumonitis"],
        &["network"],
        &["networks"],
        &["nuisance"],
        &["nuisances"],
        &["newsletter"],
        &["newsletter"],
        &["newlines"],
        &["newspapers"],
        &["newspapers"],
        &["newton"],
        &["network"],
        &["network"],
    ],
    range: 3..=11,
};

static WORD_NEV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NEV_CHILDREN),
    value: None,
};

pub static WORD_NEV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("elop"),
        dictgen::InsensitiveStr::Ascii("elope"),
        dictgen::InsensitiveStr::Ascii("eloped"),
        dictgen::InsensitiveStr::Ascii("elopes"),
        dictgen::InsensitiveStr::Ascii("eloping"),
        dictgen::InsensitiveStr::Ascii("elops"),
        dictgen::InsensitiveStr::Ascii("ere"),
        dictgen::InsensitiveStr::Ascii("eretheless"),
        dictgen::InsensitiveStr::Ascii("erhteless"),
        dictgen::InsensitiveStr::Ascii("ers"),
        dictgen::InsensitiveStr::Ascii("erthelss"),
        dictgen::InsensitiveStr::Ascii("erthless"),
    ],
    values: &[
        &["envelop"],
        &["envelop", "envelope"],
        &["enveloped"],
        &["envelopes"],
        &["enveloping"],
        &["envelops"],
        &["never"],
        &["nevertheless"],
        &["nevertheless"],
        &["never"],
        &["nevertheless"],
        &["nevertheless"],
    ],
    range: 3..=10,
};

static WORD_NEU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NEU_CHILDREN),
    value: None,
};

pub static WORD_NEU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("meric"),
        dictgen::InsensitiveStr::Ascii("monectomies"),
        dictgen::InsensitiveStr::Ascii("monectomy"),
        dictgen::InsensitiveStr::Ascii("monia"),
        dictgen::InsensitiveStr::Ascii("monic"),
        dictgen::InsensitiveStr::Ascii("monically"),
        dictgen::InsensitiveStr::Ascii("monicly"),
        dictgen::InsensitiveStr::Ascii("monics"),
        dictgen::InsensitiveStr::Ascii("monitis"),
        dictgen::InsensitiveStr::Ascii("orscience"),
        dictgen::InsensitiveStr::Ascii("ralogical"),
        dictgen::InsensitiveStr::Ascii("roligical"),
        dictgen::InsensitiveStr::Ascii("rologia"),
        dictgen::InsensitiveStr::Ascii("rologial"),
        dictgen::InsensitiveStr::Ascii("ronas"),
        dictgen::InsensitiveStr::Ascii("rosceince"),
        dictgen::InsensitiveStr::Ascii("rosciene"),
        dictgen::InsensitiveStr::Ascii("roscienze"),
        dictgen::InsensitiveStr::Ascii("rosicence"),
        dictgen::InsensitiveStr::Ascii("rton"),
        dictgen::InsensitiveStr::Ascii("terd"),
        dictgen::InsensitiveStr::Ascii("ton"),
        dictgen::InsensitiveStr::Ascii("traal"),
        dictgen::InsensitiveStr::Ascii("trailty"),
        dictgen::InsensitiveStr::Ascii("trallity"),
        dictgen::InsensitiveStr::Ascii("tralt"),
        dictgen::InsensitiveStr::Ascii("traly"),
    ],
    values: &[
        &["numeric"],
        &["pneumonectomies"],
        &["pneumonectomy"],
        &["pneumonia"],
        &["mnemonic", "pneumonic"],
        &["mnemonically"],
        &["mnemonically"],
        &["mnemonics"],
        &["pneumonitis"],
        &["neuroscience"],
        &["neurological"],
        &["neurological"],
        &["neurological"],
        &["neurological"],
        &["neurons"],
        &["neuroscience"],
        &["neuroscience"],
        &["neuroscience"],
        &["neuroscience"],
        &["neutron"],
        &["neutered"],
        &["neutron"],
        &["neutral"],
        &["neutrality"],
        &["neutrality"],
        &["neutrality"],
        &["neutrality"],
    ],
    range: 3..=11,
};

static WORD_NET_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NET_CHILDREN),
    value: None,
};

pub static WORD_NET_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("acpe"),
        dictgen::InsensitiveStr::Ascii("boook"),
        dictgen::InsensitiveStr::Ascii("cape"),
        dictgen::InsensitiveStr::Ascii("hods"),
        dictgen::InsensitiveStr::Ascii("iher"),
        dictgen::InsensitiveStr::Ascii("ocde"),
        dictgen::InsensitiveStr::Ascii("owrk"),
        dictgen::InsensitiveStr::Ascii("owrking"),
        dictgen::InsensitiveStr::Ascii("owrks"),
        dictgen::InsensitiveStr::Ascii("ropolitan"),
        dictgen::InsensitiveStr::Ascii("ruality"),
        dictgen::InsensitiveStr::Ascii("scpe"),
        dictgen::InsensitiveStr::Ascii("ural"),
        dictgen::InsensitiveStr::Ascii("urality"),
        dictgen::InsensitiveStr::Ascii("uron"),
        dictgen::InsensitiveStr::Ascii("wplit"),
        dictgen::InsensitiveStr::Ascii("wrok"),
        dictgen::InsensitiveStr::Ascii("wroked"),
        dictgen::InsensitiveStr::Ascii("wroking"),
        dictgen::InsensitiveStr::Ascii("wroks"),
        dictgen::InsensitiveStr::Ascii("wrork"),
    ],
    values: &[
        &["netscape"],
        &["netbook"],
        &["netscape"],
        &["methods"],
        &["neither"],
        &["netcode"],
        &["network"],
        &["networking"],
        &["networks"],
        &["metropolitan"],
        &["neutrality"],
        &["netscape"],
        &["neutral", "natural"],
        &["neutrality"],
        &["neutron"],
        &["netsplit"],
        &["network"],
        &["networked"],
        &["networking"],
        &["networks"],
        &["network"],
    ],
    range: 4..=9,
};

static WORD_NES_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NES_CHILDREN),
    value: None,
};

pub static WORD_NES_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cesaries"),
        dictgen::InsensitiveStr::Ascii("cesarily"),
        dictgen::InsensitiveStr::Ascii("cesarrily"),
        dictgen::InsensitiveStr::Ascii("cesarry"),
        dictgen::InsensitiveStr::Ascii("cessarily"),
        dictgen::InsensitiveStr::Ascii("cessary"),
        dictgen::InsensitiveStr::Ascii("esarily"),
        dictgen::InsensitiveStr::Ascii("lave"),
        dictgen::InsensitiveStr::Ascii("sary"),
        dictgen::InsensitiveStr::Ascii("sasarily"),
        dictgen::InsensitiveStr::Ascii("sasary"),
        dictgen::InsensitiveStr::Ascii("secarilt"),
        dictgen::InsensitiveStr::Ascii("secarily"),
        dictgen::InsensitiveStr::Ascii("secarry"),
        dictgen::InsensitiveStr::Ascii("secary"),
        dictgen::InsensitiveStr::Ascii("seccarily"),
        dictgen::InsensitiveStr::Ascii("seccary"),
        dictgen::InsensitiveStr::Ascii("sesarily"),
        dictgen::InsensitiveStr::Ascii("sesary"),
        dictgen::InsensitiveStr::Ascii("sessarily"),
        dictgen::InsensitiveStr::Ascii("sessary"),
        dictgen::InsensitiveStr::Ascii("talgia"),
        dictgen::InsensitiveStr::Ascii("talgic"),
        dictgen::InsensitiveStr::Ascii("talgically"),
        dictgen::InsensitiveStr::Ascii("talgicly"),
        dictgen::InsensitiveStr::Ascii("tin"),
        dictgen::InsensitiveStr::Ascii("tolgia"),
        dictgen::InsensitiveStr::Ascii("tolgic"),
        dictgen::InsensitiveStr::Ascii("tolgically"),
        dictgen::InsensitiveStr::Ascii("tolgicly"),
        dictgen::InsensitiveStr::Ascii("twork"),
    ],
    values: &[
        &["necessaries"],
        &["necessarily"],
        &["necessarily"],
        &["necessary"],
        &["necessarily"],
        &["necessary"],
        &["necessarily"],
        &["enslave"],
        &["necessary"],
        &["necessarily"],
        &["necessary"],
        &["necessarily"],
        &["necessarily"],
        &["necessary"],
        &["necessary"],
        &["necessarily"],
        &["necessary"],
        &["necessarily"],
        &["necessary"],
        &["necessarily"],
        &["necessary"],
        &["nostalgia"],
        &["nostalgic"],
        &["nostalgically"],
        &["nostalgically"],
        &["nesting"],
        &["nostalgia"],
        &["nostalgic"],
        &["nostalgically"],
        &["nostalgically"],
        &["network"],
    ],
    range: 3..=10,
};

static WORD_NER_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NER_CHILDREN),
    value: None,
};

pub static WORD_NER_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("al"),
        dictgen::InsensitiveStr::Ascii("ally"),
        dictgen::InsensitiveStr::Ascii("aly"),
        dictgen::InsensitiveStr::Ascii("ative"),
        dictgen::InsensitiveStr::Ascii("atively"),
        dictgen::InsensitiveStr::Ascii("atives"),
        dictgen::InsensitiveStr::Ascii("comancer"),
        dictgen::InsensitiveStr::Ascii("uological"),
        dictgen::InsensitiveStr::Ascii("uons"),
        dictgen::InsensitiveStr::Ascii("uoscience"),
        dictgen::InsensitiveStr::Ascii("vana"),
        dictgen::InsensitiveStr::Ascii("vanic"),
        dictgen::InsensitiveStr::Ascii("ver"),
    ],
    values: &[
        &["neural"],
        &["neurally"],
        &["neurally"],
        &["narrative", "negative"],
        &["narratively", "negatively"],
        &["narratives", "negatives"],
        &["necromancer"],
        &["neurological"],
        &["neurons"],
        &["neuroscience"],
        &["nirvana"],
        &["nirvanic"],
        &["never"],
    ],
    range: 2..=9,
};

static WORD_NEO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NEO_CHILDREN),
    value: None,
};

pub static WORD_NEO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("litic"),
        dictgen::InsensitiveStr::Ascii("roscience"),
    ],
    values: &[&["neolithic"], &["neuroscience"]],
    range: 5..=9,
};

static WORD_NEN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NEN_CHILDREN),
    value: None,
};

pub static WORD_NEN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("viroment")],
    values: &[&["environment"]],
    range: 8..=8,
};

static WORD_NEL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NEL_CHILDREN),
    value: None,
};

pub static WORD_NEL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ink")],
    values: &[&["netlink"]],
    range: 3..=3,
};

static WORD_NEI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_NEI_CHILDREN),
    value: None,
};

static WORD_NEI_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    Some(&WORD_NEIB_NODE),
    Some(&WORD_NEIC_NODE),
    None,
    None,
    None,
    Some(&WORD_NEIG_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_NEIT_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_NEIT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NEIT_CHILDREN),
    value: None,
};

pub static WORD_NEIT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("er")],
    values: &[&["neither"]],
    range: 2..=2,
};

static WORD_NEIG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_NEIG_CHILDREN),
    value: None,
};

static WORD_NEIG_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    Some(&WORD_NEIGB_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_NEIGH_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_NEIGH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_NEIGH_CHILDREN),
    value: None,
};

static WORD_NEIGH_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    Some(&WORD_NEIGHB_NODE),
    None,
    None,
    Some(&WORD_NEIGHE_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_NEIGHO_NODE),
    None,
    None,
    Some(&WORD_NEIGHR_NODE),
    None,
    Some(&WORD_NEIGHT_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_NEIGHT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NEIGHT_CHILDREN),
    value: Some(&["neither"]),
};

pub static WORD_NEIGHT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("bor"),
        dictgen::InsensitiveStr::Ascii("borhood"),
        dictgen::InsensitiveStr::Ascii("borhoods"),
        dictgen::InsensitiveStr::Ascii("boring"),
        dictgen::InsensitiveStr::Ascii("bors"),
        dictgen::InsensitiveStr::Ascii("bour"),
        dictgen::InsensitiveStr::Ascii("bourhood"),
        dictgen::InsensitiveStr::Ascii("bourhoods"),
        dictgen::InsensitiveStr::Ascii("bouring"),
        dictgen::InsensitiveStr::Ascii("bours"),
        dictgen::InsensitiveStr::Ascii("er"),
        dictgen::InsensitiveStr::Ascii("obr"),
        dictgen::InsensitiveStr::Ascii("obrhood"),
        dictgen::InsensitiveStr::Ascii("obrhoods"),
        dictgen::InsensitiveStr::Ascii("obring"),
        dictgen::InsensitiveStr::Ascii("obrs"),
    ],
    values: &[
        &["neighbor"],
        &["neighborhood"],
        &["neighborhoods"],
        &["neighboring"],
        &["neighbors"],
        &["neighbour"],
        &["neighbourhood"],
        &["neighbourhoods"],
        &["neighbouring"],
        &["neighbours"],
        &["neither"],
        &["neighbor"],
        &["neighborhood"],
        &["neighborhoods"],
        &["neighboring"],
        &["neighbors"],
    ],
    range: 2..=9,
};

static WORD_NEIGHR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NEIGHR_CHILDREN),
    value: None,
};

pub static WORD_NEIGHR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("or"),
        dictgen::InsensitiveStr::Ascii("orhood"),
        dictgen::InsensitiveStr::Ascii("orhoods"),
        dictgen::InsensitiveStr::Ascii("oring"),
        dictgen::InsensitiveStr::Ascii("ors"),
        dictgen::InsensitiveStr::Ascii("our"),
        dictgen::InsensitiveStr::Ascii("ourhood"),
        dictgen::InsensitiveStr::Ascii("ourhoods"),
        dictgen::InsensitiveStr::Ascii("ouring"),
        dictgen::InsensitiveStr::Ascii("ours"),
    ],
    values: &[
        &["neighbor"],
        &["neighborhood"],
        &["neighborhoods"],
        &["neighboring"],
        &["neighbors"],
        &["neighbour"],
        &["neighbourhood"],
        &["neighbourhoods"],
        &["neighbouring"],
        &["neighbours"],
    ],
    range: 2..=8,
};

static WORD_NEIGHO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NEIGHO_CHILDREN),
    value: None,
};

pub static WORD_NEIGHO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("br"),
        dictgen::InsensitiveStr::Ascii("brhood"),
        dictgen::InsensitiveStr::Ascii("brhoods"),
        dictgen::InsensitiveStr::Ascii("bring"),
        dictgen::InsensitiveStr::Ascii("brs"),
        dictgen::InsensitiveStr::Ascii("r"),
        dictgen::InsensitiveStr::Ascii("rhood"),
        dictgen::InsensitiveStr::Ascii("rhoods"),
        dictgen::InsensitiveStr::Ascii("ring"),
        dictgen::InsensitiveStr::Ascii("rs"),
        dictgen::InsensitiveStr::Ascii("ur"),
        dictgen::InsensitiveStr::Ascii("urhood"),
        dictgen::InsensitiveStr::Ascii("urhoods"),
        dictgen::InsensitiveStr::Ascii("uring"),
        dictgen::InsensitiveStr::Ascii("urs"),
    ],
    values: &[
        &["neighbor"],
        &["neighborhood"],
        &["neighborhoods"],
        &["neighboring"],
        &["neighbors"],
        &["neighbor"],
        &["neighborhood"],
        &["neighborhoods"],
        &["neighboring"],
        &["neighbors"],
        &["neighbour"],
        &["neighbourhood"],
        &["neighbourhoods"],
        &["neighbouring"],
        &["neighbours"],
    ],
    range: 1..=7,
};

static WORD_NEIGHE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NEIGHE_CHILDREN),
    value: None,
};

pub static WORD_NEIGHE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("r")],
    values: &[&["neither"]],
    range: 1..=1,
};

static WORD_NEIGHB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_NEIGHB_CHILDREN),
    value: None,
};

static WORD_NEIGHB_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_NEIGHBA_NODE),
    Some(&WORD_NEIGHBB_NODE),
    None,
    None,
    Some(&WORD_NEIGHBE_NODE),
    None,
    None,
    Some(&WORD_NEIGHBH_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_NEIGHBO_NODE),
    None,
    None,
    Some(&WORD_NEIGHBR_NODE),
    None,
    None,
    Some(&WORD_NEIGHBU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_NEIGHBU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NEIGHBU_CHILDREN),
    value: None,
};

pub static WORD_NEIGHBU_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("r"),
            dictgen::InsensitiveStr::Ascii("rhood"),
            dictgen::InsensitiveStr::Ascii("rhoods"),
            dictgen::InsensitiveStr::Ascii("ring"),
            dictgen::InsensitiveStr::Ascii("rs"),
        ],
        values: &[
            &["neighbor"],
            &["neighborhood"],
            &["neighborhoods"],
            &["neighboring"],
            &["neighbors"],
        ],
        range: 1..=6,
    };

static WORD_NEIGHBR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NEIGHBR_CHILDREN),
    value: Some(&["neighbor"]),
};

pub static WORD_NEIGHBR_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("ohood"),
            dictgen::InsensitiveStr::Ascii("s"),
        ],
        values: &[&["neighborhoods"], &["neighbors"]],
        range: 1..=5,
    };

static WORD_NEIGHBO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_NEIGHBO_CHILDREN),
    value: None,
};

static WORD_NEIGHBO_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_NEIGHBOA_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_NEIGHBOH_NODE),
    Some(&WORD_NEIGHBOI_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_NEIGHBOO_NODE),
    None,
    None,
    Some(&WORD_NEIGHBOR_NODE),
    Some(&WORD_NEIGHBOS_NODE),
    Some(&WORD_NEIGHBOT_NODE),
    Some(&WORD_NEIGHBOU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_NEIGHBOU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NEIGHBOU_CHILDREN),
    value: None,
};

pub static WORD_NEIGHBOU_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("ing"),
            dictgen::InsensitiveStr::Ascii("rbood"),
            dictgen::InsensitiveStr::Ascii("rgh"),
            dictgen::InsensitiveStr::Ascii("rghs"),
            dictgen::InsensitiveStr::Ascii("rgood"),
            dictgen::InsensitiveStr::Ascii("rgs"),
            dictgen::InsensitiveStr::Ascii("rhhod"),
            dictgen::InsensitiveStr::Ascii("rhhods"),
            dictgen::InsensitiveStr::Ascii("rhhood"),
            dictgen::InsensitiveStr::Ascii("rhhoods"),
            dictgen::InsensitiveStr::Ascii("rhing"),
            dictgen::InsensitiveStr::Ascii("rhod"),
            dictgen::InsensitiveStr::Ascii("rhodd"),
            dictgen::InsensitiveStr::Ascii("rhodds"),
            dictgen::InsensitiveStr::Ascii("rhods"),
            dictgen::InsensitiveStr::Ascii("rhooding"),
            dictgen::InsensitiveStr::Ascii("rhoof"),
            dictgen::InsensitiveStr::Ascii("rhoofs"),
            dictgen::InsensitiveStr::Ascii("rhoood"),
            dictgen::InsensitiveStr::Ascii("rhooods"),
            dictgen::InsensitiveStr::Ascii("rhoor"),
            dictgen::InsensitiveStr::Ascii("rhoors"),
            dictgen::InsensitiveStr::Ascii("rhoud"),
            dictgen::InsensitiveStr::Ascii("rhouds"),
            dictgen::InsensitiveStr::Ascii("rood"),
            dictgen::InsensitiveStr::Ascii("s"),
            dictgen::InsensitiveStr::Ascii("t"),
            dictgen::InsensitiveStr::Ascii("thood"),
            dictgen::InsensitiveStr::Ascii("thoods"),
            dictgen::InsensitiveStr::Ascii("ts"),
        ],
        values: &[
            &["neighbouring"],
            &["neighbourhood"],
            &["neighbour"],
            &["neighbours"],
            &["neighbourhood"],
            &["neighbours"],
            &["neighbourhood"],
            &["neighbourhoods"],
            &["neighbourhood"],
            &["neighbourhoods"],
            &["neighbouring"],
            &["neighbourhood"],
            &["neighbourhood"],
            &["neighbourhoods"],
            &["neighbourhoods"],
            &["neighbouring"],
            &["neighbourhood"],
            &["neighbourhoods"],
            &["neighbourhood"],
            &["neighbourhoods"],
            &["neighbour"],
            &["neighbours"],
            &["neighbourhood"],
            &["neighbourhoods"],
            &["neighbourhood"],
            &["neighbours"],
            &["neighbour"],
            &["neighbourhood"],
            &["neighbourhoods"],
            &["neighbours"],
        ],
        range: 1..=8,
    };

static WORD_NEIGHBOT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NEIGHBOT_CHILDREN),
    value: Some(&["neighbor"]),
};

pub static WORD_NEIGHBOT_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("hood"),
            dictgen::InsensitiveStr::Ascii("hoods"),
            dictgen::InsensitiveStr::Ascii("s"),
        ],
        values: &[&["neighborhood"], &["neighborhoods"], &["neighbors"]],
        range: 1..=5,
    };

static WORD_NEIGHBOS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NEIGHBOS_CHILDREN),
    value: Some(&["neighbors"]),
};

pub static WORD_NEIGHBOS_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[],
        values: &[],
        range: 0..=0,
    };

static WORD_NEIGHBOR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NEIGHBOR_CHILDREN),
    value: None,
};

pub static WORD_NEIGHBOR_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("ds"),
            dictgen::InsensitiveStr::Ascii("ehood"),
            dictgen::InsensitiveStr::Ascii("es"),
            dictgen::InsensitiveStr::Ascii("gh"),
            dictgen::InsensitiveStr::Ascii("ghs"),
            dictgen::InsensitiveStr::Ascii("hhod"),
            dictgen::InsensitiveStr::Ascii("hhods"),
            dictgen::InsensitiveStr::Ascii("hhood"),
            dictgen::InsensitiveStr::Ascii("hhoods"),
            dictgen::InsensitiveStr::Ascii("hing"),
            dictgen::InsensitiveStr::Ascii("hod"),
            dictgen::InsensitiveStr::Ascii("hodd"),
            dictgen::InsensitiveStr::Ascii("hodds"),
            dictgen::InsensitiveStr::Ascii("hods"),
            dictgen::InsensitiveStr::Ascii("hooding"),
            dictgen::InsensitiveStr::Ascii("hoof"),
            dictgen::InsensitiveStr::Ascii("hoofs"),
            dictgen::InsensitiveStr::Ascii("hoood"),
            dictgen::InsensitiveStr::Ascii("hooods"),
            dictgen::InsensitiveStr::Ascii("hoor"),
            dictgen::InsensitiveStr::Ascii("hoors"),
            dictgen::InsensitiveStr::Ascii("houd"),
            dictgen::InsensitiveStr::Ascii("houds"),
        ],
        values: &[
            &["neighbors"],
            &["neighborhood"],
            &["neighbors"],
            &["neighbor"],
            &["neighbors"],
            &["neighborhood"],
            &["neighborhoods"],
            &["neighborhood"],
            &["neighborhoods"],
            &["neighboring"],
            &["neighborhood"],
            &["neighborhood"],
            &["neighborhoods"],
            &["neighborhoods"],
            &["neighboring"],
            &["neighborhood"],
            &["neighborhoods"],
            &["neighborhoods", "neighborhood"],
            &["neighborhoods"],
            &["neighbor"],
            &["neighbors"],
            &["neighborhood"],
            &["neighborhoods"],
        ],
        range: 2..=7,
    };

static WORD_NEIGHBOO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NEIGHBOO_CHILDREN),
    value: None,
};

pub static WORD_NEIGHBOO_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("d"),
            dictgen::InsensitiveStr::Ascii("ds"),
            dictgen::InsensitiveStr::Ascii("r"),
            dictgen::InsensitiveStr::Ascii("rdhood"),
            dictgen::InsensitiveStr::Ascii("rdhoods"),
            dictgen::InsensitiveStr::Ascii("rhod"),
            dictgen::InsensitiveStr::Ascii("rhods"),
            dictgen::InsensitiveStr::Ascii("rhood"),
            dictgen::InsensitiveStr::Ascii("rhoods"),
            dictgen::InsensitiveStr::Ascii("rhoud"),
            dictgen::InsensitiveStr::Ascii("ring"),
            dictgen::InsensitiveStr::Ascii("rs"),
        ],
        values: &[
            &["neighborhood"],
            &["neighborhoods"],
            &["neighbor", "neighbour"],
            &["neighborhood"],
            &["neighborhoods"],
            &["neighbourhood", "neighborhood"],
            &["neighborhoods"],
            &["neighborhood"],
            &["neighborhoods"],
            &["neighbourhood"],
            &["neighboring"],
            &["neighbors", "neighbours"],
        ],
        range: 1..=7,
    };

static WORD_NEIGHBOI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NEIGHBOI_CHILDREN),
    value: None,
};

pub static WORD_NEIGHBOI_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[dictgen::InsensitiveStr::Ascii("ng")],
        values: &[&["neighboring"]],
        range: 2..=2,
    };

static WORD_NEIGHBOH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NEIGHBOH_CHILDREN),
    value: None,
};

pub static WORD_NEIGHBOH_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("ood"),
            dictgen::InsensitiveStr::Ascii("oods"),
        ],
        values: &[&["neighborhood"], &["neighborhoods"]],
        range: 3..=4,
    };

static WORD_NEIGHBOA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NEIGHBOA_CHILDREN),
    value: None,
};

pub static WORD_NEIGHBOA_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("rd"),
            dictgen::InsensitiveStr::Ascii("rds"),
        ],
        values: &[&["neighborhood"], &["neighborhoods"]],
        range: 2..=3,
    };

static WORD_NEIGHBH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NEIGHBH_CHILDREN),
    value: None,
};

pub static WORD_NEIGHBH_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("or"),
            dictgen::InsensitiveStr::Ascii("orhood"),
            dictgen::InsensitiveStr::Ascii("orhoods"),
            dictgen::InsensitiveStr::Ascii("oring"),
            dictgen::InsensitiveStr::Ascii("ors"),
        ],
        values: &[
            &["neighbor"],
            &["neighborhood"],
            &["neighborhoods"],
            &["neighboring"],
            &["neighbors"],
        ],
        range: 2..=7,
    };

static WORD_NEIGHBE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NEIGHBE_CHILDREN),
    value: None,
};

pub static WORD_NEIGHBE_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("ard"),
            dictgen::InsensitiveStr::Ascii("ards"),
            dictgen::InsensitiveStr::Ascii("hood"),
            dictgen::InsensitiveStr::Ascii("hoods"),
            dictgen::InsensitiveStr::Ascii("ing"),
            dictgen::InsensitiveStr::Ascii("od"),
            dictgen::InsensitiveStr::Ascii("ods"),
            dictgen::InsensitiveStr::Ascii("or"),
            dictgen::InsensitiveStr::Ascii("ordhood"),
            dictgen::InsensitiveStr::Ascii("ordhoods"),
            dictgen::InsensitiveStr::Ascii("orhod"),
            dictgen::InsensitiveStr::Ascii("orhods"),
            dictgen::InsensitiveStr::Ascii("orhood"),
            dictgen::InsensitiveStr::Ascii("orhoods"),
            dictgen::InsensitiveStr::Ascii("ors"),
            dictgen::InsensitiveStr::Ascii("r"),
            dictgen::InsensitiveStr::Ascii("rgh"),
            dictgen::InsensitiveStr::Ascii("rghs"),
            dictgen::InsensitiveStr::Ascii("rhhod"),
            dictgen::InsensitiveStr::Ascii("rhhods"),
            dictgen::InsensitiveStr::Ascii("rhhood"),
            dictgen::InsensitiveStr::Ascii("rhhoods"),
            dictgen::InsensitiveStr::Ascii("rhing"),
            dictgen::InsensitiveStr::Ascii("rhod"),
            dictgen::InsensitiveStr::Ascii("rhodd"),
            dictgen::InsensitiveStr::Ascii("rhodds"),
            dictgen::InsensitiveStr::Ascii("rhods"),
            dictgen::InsensitiveStr::Ascii("rhood"),
            dictgen::InsensitiveStr::Ascii("rhooding"),
            dictgen::InsensitiveStr::Ascii("rhoods"),
            dictgen::InsensitiveStr::Ascii("rhoof"),
            dictgen::InsensitiveStr::Ascii("rhoofs"),
            dictgen::InsensitiveStr::Ascii("rhoood"),
            dictgen::InsensitiveStr::Ascii("rhooods"),
            dictgen::InsensitiveStr::Ascii("rhoor"),
            dictgen::InsensitiveStr::Ascii("rhoors"),
            dictgen::InsensitiveStr::Ascii("rhoud"),
            dictgen::InsensitiveStr::Ascii("rhouds"),
            dictgen::InsensitiveStr::Ascii("ring"),
            dictgen::InsensitiveStr::Ascii("rs"),
            dictgen::InsensitiveStr::Ascii("s"),
            dictgen::InsensitiveStr::Ascii("t"),
            dictgen::InsensitiveStr::Ascii("thood"),
            dictgen::InsensitiveStr::Ascii("thoods"),
            dictgen::InsensitiveStr::Ascii("ts"),
            dictgen::InsensitiveStr::Ascii("uing"),
            dictgen::InsensitiveStr::Ascii("urgh"),
            dictgen::InsensitiveStr::Ascii("urghs"),
            dictgen::InsensitiveStr::Ascii("urhing"),
            dictgen::InsensitiveStr::Ascii("urhooding"),
            dictgen::InsensitiveStr::Ascii("urhoor"),
            dictgen::InsensitiveStr::Ascii("urhoors"),
            dictgen::InsensitiveStr::Ascii("us"),
            dictgen::InsensitiveStr::Ascii("ut"),
            dictgen::InsensitiveStr::Ascii("uthood"),
            dictgen::InsensitiveStr::Ascii("uthoods"),
            dictgen::InsensitiveStr::Ascii("uts"),
        ],
        values: &[
            &["neighborhood"],
            &["neighborhoods"],
            &["neighborhood"],
            &["neighborhoods"],
            &["neighboring"],
            &["neighborhood"],
            &["neighborhoods"],
            &["neighbor"],
            &["neighborhood"],
            &["neighborhoods"],
            &["neighborhood"],
            &["neighborhoods"],
            &["neighborhood"],
            &["neighborhoods"],
            &["neighbors"],
            &["neighbor"],
            &["neighbor"],
            &["neighbors"],
            &["neighborhood"],
            &["neighborhoods"],
            &["neighborhood"],
            &["neighborhoods"],
            &["neighboring"],
            &["neighborhood"],
            &["neighborhood"],
            &["neighborhoods"],
            &["neighborhoods"],
            &["neighborhood"],
            &["neighboring"],
            &["neighborhoods"],
            &["neighborhood"],
            &["neighborhoods"],
            &["neighborhood"],
            &["neighborhoods"],
            &["neighbor"],
            &["neighbors"],
            &["neighborhood"],
            &["neighborhoods"],
            &["neighboring"],
            &["neighbors"],
            &["neighbors"],
            &["neighbor"],
            &["neighborhood"],
            &["neighborhoods"],
            &["neighbors"],
            &["neighbouring"],
            &["neighbour"],
            &["neighbours"],
            &["neighbouring"],
            &["neighbouring"],
            &["neighbour"],
            &["neighbours"],
            &["neighbours"],
            &["neighbour"],
            &["neighbourhood"],
            &["neighbourhoods"],
            &["neighbours"],
        ],
        range: 1..=9,
    };

static WORD_NEIGHBB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NEIGHBB_CHILDREN),
    value: None,
};

pub static WORD_NEIGHBB_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("or"),
            dictgen::InsensitiveStr::Ascii("orhood"),
            dictgen::InsensitiveStr::Ascii("orhoods"),
            dictgen::InsensitiveStr::Ascii("oring"),
            dictgen::InsensitiveStr::Ascii("ors"),
        ],
        values: &[
            &["neighbor"],
            &["neighborhood"],
            &["neighborhoods"],
            &["neighboring"],
            &["neighbors"],
        ],
        range: 2..=7,
    };

static WORD_NEIGHBA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NEIGHBA_CHILDREN),
    value: None,
};

pub static WORD_NEIGHBA_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("r"),
            dictgen::InsensitiveStr::Ascii("rhood"),
            dictgen::InsensitiveStr::Ascii("rhoods"),
            dictgen::InsensitiveStr::Ascii("ring"),
            dictgen::InsensitiveStr::Ascii("rs"),
        ],
        values: &[
            &["neighbor"],
            &["neighborhood"],
            &["neighborhoods"],
            &["neighboring"],
            &["neighbors"],
        ],
        range: 1..=6,
    };

static WORD_NEIGB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NEIGB_CHILDREN),
    value: None,
};

pub static WORD_NEIGB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("hor"),
        dictgen::InsensitiveStr::Ascii("horhood"),
        dictgen::InsensitiveStr::Ascii("horhoods"),
        dictgen::InsensitiveStr::Ascii("hors"),
        dictgen::InsensitiveStr::Ascii("hour"),
        dictgen::InsensitiveStr::Ascii("hourhood"),
        dictgen::InsensitiveStr::Ascii("hours"),
        dictgen::InsensitiveStr::Ascii("or"),
        dictgen::InsensitiveStr::Ascii("orhood"),
        dictgen::InsensitiveStr::Ascii("oring"),
        dictgen::InsensitiveStr::Ascii("ors"),
        dictgen::InsensitiveStr::Ascii("our"),
        dictgen::InsensitiveStr::Ascii("ourhood"),
        dictgen::InsensitiveStr::Ascii("ouring"),
        dictgen::InsensitiveStr::Ascii("ours"),
    ],
    values: &[
        &["neighbor"],
        &["neighborhoods", "neighborhood"],
        &["neighborhoods"],
        &["neighbors"],
        &["neighbour"],
        &["neighbourhood"],
        &["neighbours"],
        &["neighbor"],
        &["neighborhood"],
        &["neighboring"],
        &["neighbors"],
        &["neighbour"],
        &["neighbourhood"],
        &["neighbouring"],
        &["neighbours"],
    ],
    range: 2..=8,
};

static WORD_NEIC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NEIC_CHILDREN),
    value: None,
};

pub static WORD_NEIC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("e")],
    values: &[&["niece", "nice"]],
    range: 1..=1,
};

static WORD_NEIB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NEIB_CHILDREN),
    value: None,
};

pub static WORD_NEIB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("hbors"),
        dictgen::InsensitiveStr::Ascii("hbours"),
        dictgen::InsensitiveStr::Ascii("or"),
        dictgen::InsensitiveStr::Ascii("orhood"),
        dictgen::InsensitiveStr::Ascii("orhoods"),
        dictgen::InsensitiveStr::Ascii("ors"),
    ],
    values: &[
        &["neighbors"],
        &["neighbours"],
        &["neighbor"],
        &["neighborhood"],
        &["neighborhoods"],
        &["neighbors"],
    ],
    range: 2..=7,
};

static WORD_NEG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_NEG_CHILDREN),
    value: None,
};

static WORD_NEG_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_NEGA_NODE),
    None,
    None,
    None,
    Some(&WORD_NEGE_NODE),
    None,
    None,
    None,
    Some(&WORD_NEGI_NODE),
    None,
    None,
    Some(&WORD_NEGL_NODE),
    None,
    None,
    Some(&WORD_NEGO_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_NEGT_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_NEGT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NEGT_CHILDREN),
    value: None,
};

pub static WORD_NEGT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ive")],
    values: &[&["negative"]],
    range: 3..=3,
};

static WORD_NEGO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_NEGO_CHILDREN),
    value: None,
};

static WORD_NEGO_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_NEGOA_NODE),
    None,
    Some(&WORD_NEGOC_NODE),
    None,
    None,
    None,
    Some(&WORD_NEGOG_NODE),
    None,
    Some(&WORD_NEGOI_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_NEGOP_NODE),
    None,
    None,
    Some(&WORD_NEGOS_NODE),
    Some(&WORD_NEGOT_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_NEGOZ_NODE),
];

static WORD_NEGOZ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NEGOZ_CHILDREN),
    value: None,
};

pub static WORD_NEGOZ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("iable"),
        dictgen::InsensitiveStr::Ascii("iate"),
        dictgen::InsensitiveStr::Ascii("iated"),
        dictgen::InsensitiveStr::Ascii("iates"),
        dictgen::InsensitiveStr::Ascii("iating"),
        dictgen::InsensitiveStr::Ascii("iation"),
        dictgen::InsensitiveStr::Ascii("iations"),
        dictgen::InsensitiveStr::Ascii("iator"),
        dictgen::InsensitiveStr::Ascii("iators"),
    ],
    values: &[
        &["negotiable"],
        &["negotiate"],
        &["negotiated"],
        &["negotiates"],
        &["negotiating"],
        &["negotiation"],
        &["negotiations"],
        &["negotiator"],
        &["negotiators"],
    ],
    range: 4..=7,
};

static WORD_NEGOT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_NEGOT_CHILDREN),
    value: None,
};

static WORD_NEGOT_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_NEGOTA_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_NEGOTH_NODE),
    Some(&WORD_NEGOTI_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_NEGOTI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_NEGOTI_CHILDREN),
    value: None,
};

static WORD_NEGOTI_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_NEGOTIA_NODE),
    Some(&WORD_NEGOTIB_NODE),
    Some(&WORD_NEGOTIC_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_NEGOTIN_NODE),
    Some(&WORD_NEGOTIO_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_NEGOTIT_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_NEGOTIT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NEGOTIT_CHILDREN),
    value: None,
};

pub static WORD_NEGOTIT_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("able"),
            dictgen::InsensitiveStr::Ascii("ae"),
            dictgen::InsensitiveStr::Ascii("aed"),
            dictgen::InsensitiveStr::Ascii("aes"),
            dictgen::InsensitiveStr::Ascii("aing"),
            dictgen::InsensitiveStr::Ascii("aion"),
            dictgen::InsensitiveStr::Ascii("aions"),
            dictgen::InsensitiveStr::Ascii("aor"),
            dictgen::InsensitiveStr::Ascii("aors"),
            dictgen::InsensitiveStr::Ascii("ate"),
            dictgen::InsensitiveStr::Ascii("ated"),
            dictgen::InsensitiveStr::Ascii("ates"),
            dictgen::InsensitiveStr::Ascii("ating"),
            dictgen::InsensitiveStr::Ascii("ation"),
            dictgen::InsensitiveStr::Ascii("ations"),
            dictgen::InsensitiveStr::Ascii("ator"),
            dictgen::InsensitiveStr::Ascii("ators"),
            dictgen::InsensitiveStr::Ascii("e"),
            dictgen::InsensitiveStr::Ascii("ed"),
            dictgen::InsensitiveStr::Ascii("es"),
            dictgen::InsensitiveStr::Ascii("ing"),
            dictgen::InsensitiveStr::Ascii("ion"),
            dictgen::InsensitiveStr::Ascii("ions"),
            dictgen::InsensitiveStr::Ascii("or"),
            dictgen::InsensitiveStr::Ascii("ors"),
        ],
        values: &[
            &["negotiable"],
            &["negotiate"],
            &["negotiated"],
            &["negotiates"],
            &["negotiating"],
            &["negotiation"],
            &["negotiations"],
            &["negotiator"],
            &["negotiators"],
            &["negotiate"],
            &["negotiated"],
            &["negotiates"],
            &["negotiating"],
            &["negotiation"],
            &["negotiations"],
            &["negotiator"],
            &["negotiators"],
            &["negotiate"],
            &["negotiated"],
            &["negotiates"],
            &["negotiating"],
            &["negotiation"],
            &["negotiations"],
            &["negotiator"],
            &["negotiators"],
        ],
        range: 1..=6,
    };

static WORD_NEGOTIO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NEGOTIO_CHILDREN),
    value: None,
};

pub static WORD_NEGOTIO_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("able"),
            dictgen::InsensitiveStr::Ascii("ate"),
            dictgen::InsensitiveStr::Ascii("ated"),
            dictgen::InsensitiveStr::Ascii("ates"),
            dictgen::InsensitiveStr::Ascii("ating"),
            dictgen::InsensitiveStr::Ascii("ation"),
            dictgen::InsensitiveStr::Ascii("ations"),
            dictgen::InsensitiveStr::Ascii("ator"),
            dictgen::InsensitiveStr::Ascii("ators"),
            dictgen::InsensitiveStr::Ascii("ble"),
            dictgen::InsensitiveStr::Ascii("n"),
            dictgen::InsensitiveStr::Ascii("nable"),
            dictgen::InsensitiveStr::Ascii("nate"),
            dictgen::InsensitiveStr::Ascii("nated"),
            dictgen::InsensitiveStr::Ascii("nates"),
            dictgen::InsensitiveStr::Ascii("nating"),
            dictgen::InsensitiveStr::Ascii("nation"),
            dictgen::InsensitiveStr::Ascii("nations"),
            dictgen::InsensitiveStr::Ascii("nator"),
            dictgen::InsensitiveStr::Ascii("nators"),
            dictgen::InsensitiveStr::Ascii("ns"),
            dictgen::InsensitiveStr::Ascii("table"),
            dictgen::InsensitiveStr::Ascii("tate"),
            dictgen::InsensitiveStr::Ascii("tated"),
            dictgen::InsensitiveStr::Ascii("tates"),
            dictgen::InsensitiveStr::Ascii("tating"),
            dictgen::InsensitiveStr::Ascii("tation"),
            dictgen::InsensitiveStr::Ascii("tations"),
            dictgen::InsensitiveStr::Ascii("tator"),
            dictgen::InsensitiveStr::Ascii("tators"),
            dictgen::InsensitiveStr::Ascii("te"),
            dictgen::InsensitiveStr::Ascii("ted"),
            dictgen::InsensitiveStr::Ascii("tes"),
            dictgen::InsensitiveStr::Ascii("ting"),
            dictgen::InsensitiveStr::Ascii("tion"),
            dictgen::InsensitiveStr::Ascii("tions"),
            dictgen::InsensitiveStr::Ascii("tor"),
            dictgen::InsensitiveStr::Ascii("tors"),
        ],
        values: &[
            &["negotiable"],
            &["negotiate"],
            &["negotiated"],
            &["negotiates"],
            &["negotiating"],
            &["negotiation"],
            &["negotiations"],
            &["negotiator"],
            &["negotiators"],
            &["negotiable"],
            &["negotiation"],
            &["negotiable"],
            &["negotiate"],
            &["negotiated"],
            &["negotiates"],
            &["negotiating"],
            &["negotiation"],
            &["negotiations"],
            &["negotiator"],
            &["negotiators"],
            &["negotiations"],
            &["negotiable"],
            &["negotiate"],
            &["negotiated"],
            &["negotiates"],
            &["negotiating"],
            &["negotiation"],
            &["negotiations"],
            &["negotiator"],
            &["negotiators"],
            &["negotiate"],
            &["negotiated"],
            &["negotiates"],
            &["negotiating"],
            &["negotiation"],
            &["negotiations"],
            &["negotiator"],
            &["negotiators"],
        ],
        range: 1..=7,
    };

static WORD_NEGOTIN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NEGOTIN_CHILDREN),
    value: None,
};

pub static WORD_NEGOTIN_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[dictgen::InsensitiveStr::Ascii("ate")],
        values: &[&["negotiate"]],
        range: 3..=3,
    };

static WORD_NEGOTIC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NEGOTIC_CHILDREN),
    value: None,
};

pub static WORD_NEGOTIC_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("able"),
            dictgen::InsensitiveStr::Ascii("ate"),
            dictgen::InsensitiveStr::Ascii("ated"),
            dictgen::InsensitiveStr::Ascii("ates"),
            dictgen::InsensitiveStr::Ascii("ating"),
            dictgen::InsensitiveStr::Ascii("ation"),
            dictgen::InsensitiveStr::Ascii("ations"),
            dictgen::InsensitiveStr::Ascii("ator"),
            dictgen::InsensitiveStr::Ascii("ators"),
        ],
        values: &[
            &["negotiable"],
            &["negotiate"],
            &["negotiated"],
            &["negotiates"],
            &["negotiating"],
            &["negotiation"],
            &["negotiations"],
            &["negotiator"],
            &["negotiators"],
        ],
        range: 3..=6,
    };

static WORD_NEGOTIB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NEGOTIB_CHILDREN),
    value: None,
};

pub static WORD_NEGOTIB_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[dictgen::InsensitiveStr::Ascii("le")],
        values: &[&["negotiable"]],
        range: 2..=2,
    };

static WORD_NEGOTIA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NEGOTIA_CHILDREN),
    value: None,
};

pub static WORD_NEGOTIA_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("ion"),
            dictgen::InsensitiveStr::Ascii("ning"),
            dictgen::InsensitiveStr::Ascii("tians"),
            dictgen::InsensitiveStr::Ascii("tie"),
            dictgen::InsensitiveStr::Ascii("tied"),
            dictgen::InsensitiveStr::Ascii("tiing"),
            dictgen::InsensitiveStr::Ascii("tin"),
            dictgen::InsensitiveStr::Ascii("tiong"),
            dictgen::InsensitiveStr::Ascii("tiors"),
            dictgen::InsensitiveStr::Ascii("tive"),
            dictgen::InsensitiveStr::Ascii("ton"),
            dictgen::InsensitiveStr::Ascii("tons"),
        ],
        values: &[
            &["negotiation"],
            &["negotiating"],
            &["negotiations"],
            &["negotiated"],
            &["negotiate"],
            &["negotiating"],
            &["negotiations"],
            &["negotiating"],
            &["negotiations"],
            &["negotiate"],
            &["negotiation"],
            &["negotiations"],
        ],
        range: 3..=5,
    };

static WORD_NEGOTH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NEGOTH_CHILDREN),
    value: None,
};

pub static WORD_NEGOTH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("iable"),
        dictgen::InsensitiveStr::Ascii("iate"),
        dictgen::InsensitiveStr::Ascii("iated"),
        dictgen::InsensitiveStr::Ascii("iates"),
        dictgen::InsensitiveStr::Ascii("iating"),
        dictgen::InsensitiveStr::Ascii("iation"),
        dictgen::InsensitiveStr::Ascii("iations"),
        dictgen::InsensitiveStr::Ascii("iator"),
        dictgen::InsensitiveStr::Ascii("iators"),
    ],
    values: &[
        &["negotiable"],
        &["negotiate"],
        &["negotiated"],
        &["negotiates"],
        &["negotiating"],
        &["negotiation"],
        &["negotiations"],
        &["negotiator"],
        &["negotiators"],
    ],
    range: 4..=7,
};

static WORD_NEGOTA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NEGOTA_CHILDREN),
    value: None,
};

pub static WORD_NEGOTA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ble"),
        dictgen::InsensitiveStr::Ascii("iable"),
        dictgen::InsensitiveStr::Ascii("iate"),
        dictgen::InsensitiveStr::Ascii("iated"),
        dictgen::InsensitiveStr::Ascii("iates"),
        dictgen::InsensitiveStr::Ascii("iating"),
        dictgen::InsensitiveStr::Ascii("iation"),
        dictgen::InsensitiveStr::Ascii("iations"),
        dictgen::InsensitiveStr::Ascii("iator"),
        dictgen::InsensitiveStr::Ascii("iators"),
        dictgen::InsensitiveStr::Ascii("ible"),
        dictgen::InsensitiveStr::Ascii("ite"),
        dictgen::InsensitiveStr::Ascii("ited"),
        dictgen::InsensitiveStr::Ascii("ites"),
        dictgen::InsensitiveStr::Ascii("iting"),
        dictgen::InsensitiveStr::Ascii("ition"),
        dictgen::InsensitiveStr::Ascii("itions"),
        dictgen::InsensitiveStr::Ascii("itor"),
        dictgen::InsensitiveStr::Ascii("itors"),
        dictgen::InsensitiveStr::Ascii("te"),
        dictgen::InsensitiveStr::Ascii("ted"),
        dictgen::InsensitiveStr::Ascii("tes"),
        dictgen::InsensitiveStr::Ascii("tiable"),
        dictgen::InsensitiveStr::Ascii("tiate"),
        dictgen::InsensitiveStr::Ascii("tiated"),
        dictgen::InsensitiveStr::Ascii("tiates"),
        dictgen::InsensitiveStr::Ascii("tiating"),
        dictgen::InsensitiveStr::Ascii("tiation"),
        dictgen::InsensitiveStr::Ascii("tiations"),
        dictgen::InsensitiveStr::Ascii("tiator"),
        dictgen::InsensitiveStr::Ascii("tiators"),
        dictgen::InsensitiveStr::Ascii("tible"),
        dictgen::InsensitiveStr::Ascii("tie"),
        dictgen::InsensitiveStr::Ascii("tied"),
        dictgen::InsensitiveStr::Ascii("ties"),
        dictgen::InsensitiveStr::Ascii("ting"),
        dictgen::InsensitiveStr::Ascii("tion"),
        dictgen::InsensitiveStr::Ascii("tions"),
        dictgen::InsensitiveStr::Ascii("tior"),
        dictgen::InsensitiveStr::Ascii("tiors"),
        dictgen::InsensitiveStr::Ascii("tor"),
        dictgen::InsensitiveStr::Ascii("tors"),
    ],
    values: &[
        &["negotiable"],
        &["negotiable"],
        &["negotiate"],
        &["negotiated"],
        &["negotiates"],
        &["negotiating"],
        &["negotiation"],
        &["negotiations"],
        &["negotiator"],
        &["negotiators"],
        &["negotiable"],
        &["negotiate"],
        &["negotiated"],
        &["negotiates"],
        &["negotiating"],
        &["negotiation"],
        &["negotiations"],
        &["negotiator"],
        &["negotiators"],
        &["negotiate"],
        &["negotiated"],
        &["negotiates"],
        &["negotiable"],
        &["negotiate"],
        &["negotiated"],
        &["negotiates"],
        &["negotiating"],
        &["negotiation"],
        &["negotiations"],
        &["negotiator"],
        &["negotiators"],
        &["negotiable"],
        &["negotiate"],
        &["negotiated"],
        &["negotiates"],
        &["negotiating"],
        &["negotiation"],
        &["negotiations"],
        &["negotiator"],
        &["negotiators"],
        &["negotiator"],
        &["negotiators"],
    ],
    range: 2..=8,
};

static WORD_NEGOS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NEGOS_CHILDREN),
    value: None,
};

pub static WORD_NEGOS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("iable"),
        dictgen::InsensitiveStr::Ascii("iate"),
        dictgen::InsensitiveStr::Ascii("iated"),
        dictgen::InsensitiveStr::Ascii("iates"),
        dictgen::InsensitiveStr::Ascii("iating"),
        dictgen::InsensitiveStr::Ascii("iation"),
        dictgen::InsensitiveStr::Ascii("iations"),
        dictgen::InsensitiveStr::Ascii("iator"),
        dictgen::InsensitiveStr::Ascii("iators"),
    ],
    values: &[
        &["negotiable"],
        &["negotiate"],
        &["negotiated"],
        &["negotiates"],
        &["negotiating"],
        &["negotiation"],
        &["negotiations"],
        &["negotiator"],
        &["negotiators"],
    ],
    range: 4..=7,
};

static WORD_NEGOP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NEGOP_CHILDREN),
    value: None,
};

pub static WORD_NEGOP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("tionsotiable"),
        dictgen::InsensitiveStr::Ascii("tionsotiate"),
        dictgen::InsensitiveStr::Ascii("tionsotiated"),
        dictgen::InsensitiveStr::Ascii("tionsotiates"),
        dictgen::InsensitiveStr::Ascii("tionsotiating"),
        dictgen::InsensitiveStr::Ascii("tionsotiation"),
        dictgen::InsensitiveStr::Ascii("tionsotiations"),
        dictgen::InsensitiveStr::Ascii("tionsotiator"),
        dictgen::InsensitiveStr::Ascii("tionsotiators"),
    ],
    values: &[
        &["negotiable"],
        &["negotiate"],
        &["negotiated"],
        &["negotiates"],
        &["negotiating"],
        &["negotiation"],
        &["negotiations"],
        &["negotiator"],
        &["negotiators"],
    ],
    range: 11..=14,
};

static WORD_NEGOI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NEGOI_CHILDREN),
    value: None,
};

pub static WORD_NEGOI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("table"),
        dictgen::InsensitiveStr::Ascii("tate"),
        dictgen::InsensitiveStr::Ascii("tated"),
        dictgen::InsensitiveStr::Ascii("tates"),
        dictgen::InsensitiveStr::Ascii("tating"),
        dictgen::InsensitiveStr::Ascii("tation"),
        dictgen::InsensitiveStr::Ascii("tations"),
        dictgen::InsensitiveStr::Ascii("tator"),
        dictgen::InsensitiveStr::Ascii("tators"),
    ],
    values: &[
        &["negotiable"],
        &["negotiate"],
        &["negotiated"],
        &["negotiates"],
        &["negotiating"],
        &["negotiation"],
        &["negotiations"],
        &["negotiator"],
        &["negotiators"],
    ],
    range: 4..=7,
};

static WORD_NEGOG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NEGOG_CHILDREN),
    value: None,
};

pub static WORD_NEGOG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("iated"),
        dictgen::InsensitiveStr::Ascii("tiable"),
        dictgen::InsensitiveStr::Ascii("tiate"),
        dictgen::InsensitiveStr::Ascii("tiated"),
        dictgen::InsensitiveStr::Ascii("tiates"),
        dictgen::InsensitiveStr::Ascii("tiating"),
        dictgen::InsensitiveStr::Ascii("tiation"),
        dictgen::InsensitiveStr::Ascii("tiations"),
        dictgen::InsensitiveStr::Ascii("tiator"),
        dictgen::InsensitiveStr::Ascii("tiators"),
    ],
    values: &[
        &["negotiated"],
        &["negotiable"],
        &["negotiate"],
        &["negotiated"],
        &["negotiates"],
        &["negotiating"],
        &["negotiation"],
        &["negotiations"],
        &["negotiator"],
        &["negotiators"],
    ],
    range: 5..=8,
};

static WORD_NEGOC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NEGOC_CHILDREN),
    value: None,
};

pub static WORD_NEGOC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("iable"),
        dictgen::InsensitiveStr::Ascii("iate"),
        dictgen::InsensitiveStr::Ascii("iated"),
        dictgen::InsensitiveStr::Ascii("iates"),
        dictgen::InsensitiveStr::Ascii("iating"),
        dictgen::InsensitiveStr::Ascii("iation"),
        dictgen::InsensitiveStr::Ascii("iations"),
        dictgen::InsensitiveStr::Ascii("iator"),
        dictgen::InsensitiveStr::Ascii("iators"),
    ],
    values: &[
        &["negotiable"],
        &["negotiate"],
        &["negotiated"],
        &["negotiates"],
        &["negotiating"],
        &["negotiation"],
        &["negotiations"],
        &["negotiator"],
        &["negotiators"],
    ],
    range: 4..=7,
};

static WORD_NEGOA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NEGOA_CHILDREN),
    value: None,
};

pub static WORD_NEGOA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ble"),
        dictgen::InsensitiveStr::Ascii("te"),
        dictgen::InsensitiveStr::Ascii("ted"),
        dictgen::InsensitiveStr::Ascii("tes"),
        dictgen::InsensitiveStr::Ascii("tiable"),
        dictgen::InsensitiveStr::Ascii("tiate"),
        dictgen::InsensitiveStr::Ascii("tiated"),
        dictgen::InsensitiveStr::Ascii("tiates"),
        dictgen::InsensitiveStr::Ascii("tiating"),
        dictgen::InsensitiveStr::Ascii("tiation"),
        dictgen::InsensitiveStr::Ascii("tiations"),
        dictgen::InsensitiveStr::Ascii("tiator"),
        dictgen::InsensitiveStr::Ascii("tiators"),
        dictgen::InsensitiveStr::Ascii("ting"),
        dictgen::InsensitiveStr::Ascii("tion"),
        dictgen::InsensitiveStr::Ascii("tions"),
        dictgen::InsensitiveStr::Ascii("tor"),
        dictgen::InsensitiveStr::Ascii("tors"),
    ],
    values: &[
        &["negotiable"],
        &["negotiate"],
        &["negotiated"],
        &["negotiates"],
        &["negotiable"],
        &["negotiate"],
        &["negotiated"],
        &["negotiates"],
        &["negotiating"],
        &["negotiation"],
        &["negotiations"],
        &["negotiator"],
        &["negotiators"],
        &["negotiating"],
        &["negotiation"],
        &["negotiations"],
        &["negotiator"],
        &["negotiators"],
    ],
    range: 2..=8,
};

static WORD_NEGL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NEGL_CHILDREN),
    value: None,
};

pub static WORD_NEGL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("acting"),
        dictgen::InsensitiveStr::Ascii("agence"),
        dictgen::InsensitiveStr::Ascii("ectn"),
        dictgen::InsensitiveStr::Ascii("egance"),
        dictgen::InsensitiveStr::Ascii("egible"),
        dictgen::InsensitiveStr::Ascii("egting"),
        dictgen::InsensitiveStr::Ascii("ibible"),
        dictgen::InsensitiveStr::Ascii("ible"),
        dictgen::InsensitiveStr::Ascii("icence"),
        dictgen::InsensitiveStr::Ascii("icible"),
        dictgen::InsensitiveStr::Ascii("icting"),
        dictgen::InsensitiveStr::Ascii("igable"),
        dictgen::InsensitiveStr::Ascii("igance"),
        dictgen::InsensitiveStr::Ascii("igble"),
        dictgen::InsensitiveStr::Ascii("igeable"),
        dictgen::InsensitiveStr::Ascii("igeble"),
        dictgen::InsensitiveStr::Ascii("igente"),
        dictgen::InsensitiveStr::Ascii("igiable"),
    ],
    values: &[
        &["neglecting"],
        &["negligence"],
        &["neglecting"],
        &["negligence"],
        &["negligible"],
        &["neglecting"],
        &["negligible"],
        &["negligible"],
        &["negligence"],
        &["negligible"],
        &["neglecting"],
        &["negligible"],
        &["negligence"],
        &["negligible"],
        &["negligible"],
        &["negligible"],
        &["negligence"],
        &["negligible"],
    ],
    range: 4..=7,
};

static WORD_NEGI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NEGI_CHILDREN),
    value: None,
};

pub static WORD_NEGI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ble"),
        dictgen::InsensitiveStr::Ascii("lgence"),
        dictgen::InsensitiveStr::Ascii("otate"),
        dictgen::InsensitiveStr::Ascii("otated"),
        dictgen::InsensitiveStr::Ascii("otating"),
        dictgen::InsensitiveStr::Ascii("tiable"),
        dictgen::InsensitiveStr::Ascii("tiate"),
        dictgen::InsensitiveStr::Ascii("tiated"),
        dictgen::InsensitiveStr::Ascii("tiates"),
        dictgen::InsensitiveStr::Ascii("tiating"),
        dictgen::InsensitiveStr::Ascii("tiation"),
        dictgen::InsensitiveStr::Ascii("tiations"),
        dictgen::InsensitiveStr::Ascii("tiator"),
        dictgen::InsensitiveStr::Ascii("tiators"),
        dictgen::InsensitiveStr::Ascii("tive"),
    ],
    values: &[
        &["negligible"],
        &["negligence"],
        &["negotiate"],
        &["negotiated"],
        &["negotiating"],
        &["negotiable"],
        &["negotiate"],
        &["negotiated"],
        &["negotiates"],
        &["negotiating"],
        &["negotiation"],
        &["negotiations"],
        &["negotiator"],
        &["negotiators"],
        &["negative"],
    ],
    range: 3..=8,
};

static WORD_NEGE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NEGE_CHILDREN),
    value: None,
};

pub static WORD_NEGE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("lcting")],
    values: &[&["neglecting"]],
    range: 6..=6,
};

static WORD_NEGA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NEGA_CHILDREN),
    value: None,
};

pub static WORD_NEGA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ive"),
        dictgen::InsensitiveStr::Ascii("rive"),
        dictgen::InsensitiveStr::Ascii("tiotiable"),
        dictgen::InsensitiveStr::Ascii("tiotiate"),
        dictgen::InsensitiveStr::Ascii("tiotiated"),
        dictgen::InsensitiveStr::Ascii("tiotiates"),
        dictgen::InsensitiveStr::Ascii("tiotiating"),
        dictgen::InsensitiveStr::Ascii("tiotiation"),
        dictgen::InsensitiveStr::Ascii("tiotiations"),
        dictgen::InsensitiveStr::Ascii("tiotiator"),
        dictgen::InsensitiveStr::Ascii("tiotiators"),
        dictgen::InsensitiveStr::Ascii("tiv"),
        dictgen::InsensitiveStr::Ascii("tivaty"),
        dictgen::InsensitiveStr::Ascii("tiveity"),
        dictgen::InsensitiveStr::Ascii("tivelly"),
        dictgen::InsensitiveStr::Ascii("tivitiy"),
        dictgen::InsensitiveStr::Ascii("tivley"),
        dictgen::InsensitiveStr::Ascii("tivy"),
        dictgen::InsensitiveStr::Ascii("tve"),
    ],
    values: &[
        &["negative"],
        &["negative"],
        &["negotiable"],
        &["negotiate"],
        &["negotiated"],
        &["negotiates"],
        &["negotiating"],
        &["negotiation"],
        &["negotiations"],
        &["negotiator"],
        &["negotiators"],
        &["negative"],
        &["negativity"],
        &["negativity"],
        &["negatively"],
        &["negativity"],
        &["negatively"],
        &["negativity"],
        &["negative"],
    ],
    range: 3..=11,
};

static WORD_NEF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NEF_CHILDREN),
    value: None,
};

pub static WORD_NEF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("arios")],
    values: &[&["nefarious"]],
    range: 5..=5,
};

static WORD_NEE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NEE_CHILDREN),
    value: None,
};

pub static WORD_NEE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("de"),
        dictgen::InsensitiveStr::Ascii("deed"),
        dictgen::InsensitiveStr::Ascii("dels"),
        dictgen::InsensitiveStr::Ascii("dlees"),
        dictgen::InsensitiveStr::Ascii("dleslly"),
        dictgen::InsensitiveStr::Ascii("dlessley"),
        dictgen::InsensitiveStr::Ascii("dlessy"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("eded"),
        dictgen::InsensitiveStr::Ascii("eding"),
        dictgen::InsensitiveStr::Ascii("edle"),
        dictgen::InsensitiveStr::Ascii("edles"),
        dictgen::InsensitiveStr::Ascii("edless"),
        dictgen::InsensitiveStr::Ascii("eds"),
        dictgen::InsensitiveStr::Ascii("eed"),
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("s"),
        dictgen::InsensitiveStr::Ascii("sd"),
        dictgen::InsensitiveStr::Ascii("sds"),
        dictgen::InsensitiveStr::Ascii("sted"),
        dictgen::InsensitiveStr::Ascii("sting"),
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("ther"),
    ],
    values: &[
        &["needed", "need"],
        &["needed"],
        &["needles"],
        &["needles"],
        &["needlessly"],
        &["needlessly"],
        &["needlessly"],
        &["need", "needed"],
        &["needed"],
        &["needing"],
        &["needle"],
        &["needles", "needless"],
        &["needless", "needles"],
        &["needs"],
        &["need", "needed"],
        &["knees", "needs"],
        &["needs"],
        &["needs"],
        &["needs"],
        &["nested"],
        &["nesting"],
        &["need", "neat"],
        &["neither"],
    ],
    range: 1..=8,
};

static WORD_NED_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NED_CHILDREN),
    value: Some(&["need", "end"]),
};

pub static WORD_NED_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("d"),
        dictgen::InsensitiveStr::Ascii("ded"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("ia"),
        dictgen::InsensitiveStr::Ascii("ium"),
        dictgen::InsensitiveStr::Ascii("iums"),
        dictgen::InsensitiveStr::Ascii("le"),
        dictgen::InsensitiveStr::Ascii("les"),
        dictgen::InsensitiveStr::Ascii("less"),
        dictgen::InsensitiveStr::Ascii("lessly"),
        dictgen::InsensitiveStr::Ascii("s"),
    ],
    values: &[
        &["need"],
        &["needed"],
        &["needed"],
        &["media"],
        &["medium"],
        &["mediums"],
        &["needle"],
        &["needles", "needless"],
        &["needless", "needles"],
        &["endlessly"],
        &["needs"],
    ],
    range: 1..=6,
};

static WORD_NEC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_NEC_CHILDREN),
    value: None,
};

static WORD_NEC_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_NECA_NODE),
    None,
    Some(&WORD_NECC_NODE),
    None,
    Some(&WORD_NECE_NODE),
    None,
    None,
    Some(&WORD_NECH_NODE),
    None,
    None,
    Some(&WORD_NECK_NODE),
    None,
    None,
    None,
    Some(&WORD_NECO_NODE),
    None,
    None,
    Some(&WORD_NECR_NODE),
    Some(&WORD_NECS_NODE),
    Some(&WORD_NECT_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_NECT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NECT_CHILDREN),
    value: None,
};

pub static WORD_NECT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ode")],
    values: &[&["netcode"]],
    range: 3..=3,
};

static WORD_NECS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NECS_CHILDREN),
    value: None,
};

pub static WORD_NECS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("sary")],
    values: &[&["necessary"]],
    range: 4..=4,
};

static WORD_NECR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NECR_CHILDREN),
    value: None,
};

pub static WORD_NECR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("omacer"),
        dictgen::InsensitiveStr::Ascii("omamcer"),
        dictgen::InsensitiveStr::Ascii("omaner"),
        dictgen::InsensitiveStr::Ascii("omanser"),
        dictgen::InsensitiveStr::Ascii("omencer"),
    ],
    values: &[
        &["necromancer"],
        &["necromancer"],
        &["necromancer"],
        &["necromancer"],
        &["necromancer"],
    ],
    range: 6..=7,
};

static WORD_NECO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NECO_CHILDREN),
    value: None,
};

pub static WORD_NECO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("nstitutional"),
        dictgen::InsensitiveStr::Ascii("rmancer"),
    ],
    values: &[&["unconstitutional"], &["necromancer"]],
    range: 7..=12,
};

static WORD_NECK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NECK_CHILDREN),
    value: None,
};

pub static WORD_NECK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("bead"),
        dictgen::InsensitiveStr::Ascii("bearders"),
        dictgen::InsensitiveStr::Ascii("beardese"),
        dictgen::InsensitiveStr::Ascii("beardest"),
        dictgen::InsensitiveStr::Ascii("beardies"),
        dictgen::InsensitiveStr::Ascii("beardius"),
        dictgen::InsensitiveStr::Ascii("beardos"),
        dictgen::InsensitiveStr::Ascii("beardus"),
        dictgen::InsensitiveStr::Ascii("beared"),
        dictgen::InsensitiveStr::Ascii("bears"),
        dictgen::InsensitiveStr::Ascii("boards"),
        dictgen::InsensitiveStr::Ascii("bread"),
        dictgen::InsensitiveStr::Ascii("breads"),
        dictgen::InsensitiveStr::Ascii("neards"),
    ],
    values: &[
        &["neckbeard"],
        &["neckbeards"],
        &["neckbeards"],
        &["neckbeards"],
        &["neckbeards"],
        &["neckbeards"],
        &["neckbeards"],
        &["neckbeards"],
        &["neckbeard"],
        &["neckbeards"],
        &["neckbeards"],
        &["neckbeard"],
        &["neckbeards"],
        &["neckbeards"],
    ],
    range: 4..=8,
};

static WORD_NECH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NECH_CHILDREN),
    value: None,
};

pub static WORD_NECH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("anism")],
    values: &[&["mechanism"]],
    range: 5..=5,
};

static WORD_NECE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NECE_CHILDREN),
    value: None,
};

pub static WORD_NECE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("sarily"),
        dictgen::InsensitiveStr::Ascii("sarrily"),
        dictgen::InsensitiveStr::Ascii("sarry"),
        dictgen::InsensitiveStr::Ascii("sary"),
        dictgen::InsensitiveStr::Ascii("ssaery"),
        dictgen::InsensitiveStr::Ascii("ssairly"),
        dictgen::InsensitiveStr::Ascii("ssairy"),
        dictgen::InsensitiveStr::Ascii("ssar"),
        dictgen::InsensitiveStr::Ascii("ssarally"),
        dictgen::InsensitiveStr::Ascii("ssaraly"),
        dictgen::InsensitiveStr::Ascii("ssarilly"),
        dictgen::InsensitiveStr::Ascii("ssarilyn"),
        dictgen::InsensitiveStr::Ascii("ssariy"),
        dictgen::InsensitiveStr::Ascii("ssarly"),
        dictgen::InsensitiveStr::Ascii("ssarry"),
        dictgen::InsensitiveStr::Ascii("ssaryly"),
        dictgen::InsensitiveStr::Ascii("ssaties"),
        dictgen::InsensitiveStr::Ascii("ssay"),
        dictgen::InsensitiveStr::Ascii("sseraly"),
        dictgen::InsensitiveStr::Ascii("sserily"),
        dictgen::InsensitiveStr::Ascii("ssery"),
        dictgen::InsensitiveStr::Ascii("ssesary"),
        dictgen::InsensitiveStr::Ascii("ssiate"),
        dictgen::InsensitiveStr::Ascii("ssiates"),
        dictgen::InsensitiveStr::Ascii("ssite"),
        dictgen::InsensitiveStr::Ascii("ssites"),
        dictgen::InsensitiveStr::Ascii("ssitites"),
        dictgen::InsensitiveStr::Ascii("ssitive"),
    ],
    values: &[
        &["necessarily"],
        &["necessarily"],
        &["necessary"],
        &["necessary"],
        &["necessary"],
        &["necessarily"],
        &["necessarily"],
        &["necessary"],
        &["necessarily"],
        &["necessarily"],
        &["necessarily"],
        &["necessarily"],
        &["necessary", "necessarily"],
        &["necessary", "necessarily"],
        &["necessary"],
        &["necessarily"],
        &["necessities"],
        &["necessary"],
        &["necessarily"],
        &["necessarily"],
        &["necessary"],
        &["necessary"],
        &["necessitate"],
        &["necessities"],
        &["necessities"],
        &["necessities"],
        &["necessities"],
        &["necessities"],
    ],
    range: 4..=8,
};

static WORD_NECC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NECC_CHILDREN),
    value: None,
};

pub static WORD_NECC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ecarily"),
        dictgen::InsensitiveStr::Ascii("ecary"),
        dictgen::InsensitiveStr::Ascii("esarily"),
        dictgen::InsensitiveStr::Ascii("esary"),
        dictgen::InsensitiveStr::Ascii("essarily"),
        dictgen::InsensitiveStr::Ascii("essarly"),
        dictgen::InsensitiveStr::Ascii("essarry"),
        dictgen::InsensitiveStr::Ascii("essary"),
        dictgen::InsensitiveStr::Ascii("essities"),
        dictgen::InsensitiveStr::Ascii("essity"),
        dictgen::InsensitiveStr::Ascii("isary"),
        dictgen::InsensitiveStr::Ascii("sessary"),
    ],
    values: &[
        &["necessarily"],
        &["necessary"],
        &["necessarily"],
        &["necessary"],
        &["necessarily"],
        &["necessarily"],
        &["necessary"],
        &["necessary"],
        &["necessities"],
        &["necessity"],
        &["necessary"],
        &["necessary"],
    ],
    range: 5..=8,
};

static WORD_NECA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NECA_CHILDREN),
    value: None,
};

pub static WORD_NECA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ssary"),
        dictgen::InsensitiveStr::Ascii("ssery"),
        dictgen::InsensitiveStr::Ascii("ssry"),
        dictgen::InsensitiveStr::Ascii("use"),
    ],
    values: &[&["necessary"], &["necessary"], &["necessary"], &["because"]],
    range: 3..=5,
};

static WORD_NEA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NEA_CHILDREN),
    value: None,
};

pub static WORD_NEA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("d"),
        dictgen::InsensitiveStr::Ascii("ded"),
        dictgen::InsensitiveStr::Ascii("der"),
        dictgen::InsensitiveStr::Ascii("ders"),
        dictgen::InsensitiveStr::Ascii("ding"),
        dictgen::InsensitiveStr::Ascii("ds"),
        dictgen::InsensitiveStr::Ascii("dy"),
        dictgen::InsensitiveStr::Ascii("gtive"),
        dictgen::InsensitiveStr::Ascii("ly"),
        dictgen::InsensitiveStr::Ascii("res"),
        dictgen::InsensitiveStr::Ascii("rset"),
        dictgen::InsensitiveStr::Ascii("st"),
    ],
    values: &[
        &["need", "head", "knead"],
        &["needed", "kneaded", "headed"],
        &["header", "kneader"],
        &["headers", "kneaders"],
        &["heading", "kneading", "needing"],
        &["heads", "kneads", "needs"],
        &["needy"],
        &["negative"],
        &["nearly", "newly"],
        &["nearest"],
        &["nearest"],
        &["nearest", "beast"],
    ],
    range: 1..=5,
};

static WORD_ND_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ND_CHILDREN),
    value: Some(&["and"]),
};

pub static WORD_ND_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("efined"),
        dictgen::InsensitiveStr::Ascii("oe"),
        dictgen::InsensitiveStr::Ascii("oes"),
    ],
    values: &[&["undefined"], &["node"], &["nodes"]],
    range: 2..=6,
};

static WORD_NC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NC_CHILDREN),
    value: None,
};

pub static WORD_NC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("lude"),
    ],
    values: &[&["nice", "once"], &["include"]],
    range: 1..=4,
};

static WORD_NA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_NA_CHILDREN),
    value: None,
};

static WORD_NA_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_NAA_NODE),
    None,
    Some(&WORD_NAC_NODE),
    Some(&WORD_NAD_NODE),
    Some(&WORD_NAE_NODE),
    Some(&WORD_NAF_NODE),
    Some(&WORD_NAG_NODE),
    Some(&WORD_NAH_NODE),
    Some(&WORD_NAI_NODE),
    None,
    None,
    None,
    Some(&WORD_NAM_NODE),
    Some(&WORD_NAN_NODE),
    Some(&WORD_NAO_NODE),
    Some(&WORD_NAP_NODE),
    None,
    Some(&WORD_NAR_NODE),
    Some(&WORD_NAS_NODE),
    Some(&WORD_NAT_NODE),
    Some(&WORD_NAU_NODE),
    Some(&WORD_NAV_NODE),
    Some(&WORD_NAW_NODE),
    Some(&WORD_NAX_NODE),
    Some(&WORD_NAY_NODE),
    Some(&WORD_NAZ_NODE),
];

static WORD_NAZ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NAZ_CHILDREN),
    value: None,
};

pub static WORD_NAZ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ereth"),
        dictgen::InsensitiveStr::Ascii("ionalists"),
    ],
    values: &[&["nazareth"], &["nationalists"]],
    range: 5..=9,
};

static WORD_NAY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NAY_CHILDREN),
    value: None,
};

pub static WORD_NAY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("bhor"),
        dictgen::InsensitiveStr::Ascii("bhorhood"),
        dictgen::InsensitiveStr::Ascii("bhorhoods"),
        dictgen::InsensitiveStr::Ascii("bhorly"),
        dictgen::InsensitiveStr::Ascii("bhors"),
        dictgen::InsensitiveStr::Ascii("bor"),
        dictgen::InsensitiveStr::Ascii("borhood"),
        dictgen::InsensitiveStr::Ascii("borhoods"),
        dictgen::InsensitiveStr::Ascii("borly"),
        dictgen::InsensitiveStr::Ascii("bors"),
        dictgen::InsensitiveStr::Ascii("bour"),
        dictgen::InsensitiveStr::Ascii("bourhood"),
        dictgen::InsensitiveStr::Ascii("bourhoods"),
        dictgen::InsensitiveStr::Ascii("bourly"),
        dictgen::InsensitiveStr::Ascii("bours"),
    ],
    values: &[
        &["neighbor"],
        &["neighborhood"],
        &["neighborhoods"],
        &["neighborly"],
        &["neighbors"],
        &["neighbor"],
        &["neighborhood"],
        &["neighborhoods"],
        &["neighborly"],
        &["neighbors"],
        &["neighbour"],
        &["neighbourhood"],
        &["neighbourhoods"],
        &["neighbourly"],
        &["neighbours"],
    ],
    range: 3..=9,
};

static WORD_NAX_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NAX_CHILDREN),
    value: Some(&["max", "nad"]),
};

pub static WORD_NAX_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ima"),
        dictgen::InsensitiveStr::Ascii("imal"),
        dictgen::InsensitiveStr::Ascii("imum"),
    ],
    values: &[&["maxima"], &["maximal"], &["maximum"]],
    range: 3..=4,
};

static WORD_NAW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NAW_CHILDREN),
    value: None,
};

pub static WORD_NAW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("sea"),
        dictgen::InsensitiveStr::Ascii("seous"),
        dictgen::InsensitiveStr::Ascii("seously"),
        dictgen::InsensitiveStr::Ascii("shea"),
        dictgen::InsensitiveStr::Ascii("shes"),
        dictgen::InsensitiveStr::Ascii("shesly"),
        dictgen::InsensitiveStr::Ascii("shus"),
        dictgen::InsensitiveStr::Ascii("shusly"),
    ],
    values: &[
        &["nausea"],
        &["nauseous"],
        &["nauseously"],
        &["nausea"],
        &["nauseous"],
        &["nauseously"],
        &["nauseous"],
        &["nauseously"],
    ],
    range: 3..=7,
};

static WORD_NAV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NAV_CHILDREN),
    value: None,
};

pub static WORD_NAV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("agate"),
        dictgen::InsensitiveStr::Ascii("agating"),
        dictgen::InsensitiveStr::Ascii("agation"),
        dictgen::InsensitiveStr::Ascii("agitation"),
        dictgen::InsensitiveStr::Ascii("giation"),
        dictgen::InsensitiveStr::Ascii("iagte"),
        dictgen::InsensitiveStr::Ascii("iagted"),
        dictgen::InsensitiveStr::Ascii("iagtes"),
        dictgen::InsensitiveStr::Ascii("iagting"),
        dictgen::InsensitiveStr::Ascii("iagtion"),
        dictgen::InsensitiveStr::Ascii("igatie"),
        dictgen::InsensitiveStr::Ascii("igatin"),
        dictgen::InsensitiveStr::Ascii("igato"),
        dictgen::InsensitiveStr::Ascii("igatore"),
        dictgen::InsensitiveStr::Ascii("itvely"),
        dictgen::InsensitiveStr::Ascii("tive"),
        dictgen::InsensitiveStr::Ascii("tives"),
    ],
    values: &[
        &["navigate"],
        &["navigating"],
        &["navigation"],
        &["navigation"],
        &["navigation"],
        &["navigate"],
        &["navigated"],
        &["navigates"],
        &["navigating"],
        &["navigation"],
        &["navigate"],
        &["navigation"],
        &["navigation"],
        &["navigate"],
        &["natively"],
        &["native"],
        &["natives"],
    ],
    range: 4..=9,
};

static WORD_NAU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NAU_CHILDREN),
    value: None,
};

pub static WORD_NAU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("esous"),
        dictgen::InsensitiveStr::Ascii("ghtly"),
        dictgen::InsensitiveStr::Ascii("gthy"),
        dictgen::InsensitiveStr::Ascii("itlus"),
        dictgen::InsensitiveStr::Ascii("seos"),
        dictgen::InsensitiveStr::Ascii("seuos"),
        dictgen::InsensitiveStr::Ascii("tils"),
        dictgen::InsensitiveStr::Ascii("tiuls"),
        dictgen::InsensitiveStr::Ascii("tlius"),
        dictgen::InsensitiveStr::Ascii("tral"),
        dictgen::InsensitiveStr::Ascii("tres"),
        dictgen::InsensitiveStr::Ascii("tulis"),
    ],
    values: &[
        &["nauseous"],
        &["naughty"],
        &["naughty"],
        &["nautilus"],
        &["nauseous"],
        &["nauseous"],
        &["nautilus"],
        &["nautilus"],
        &["nautilus"],
        &["natural", "neutral"],
        &["natures"],
        &["nautilus"],
    ],
    range: 4..=5,
};

static WORD_NAT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_NAT_CHILDREN),
    value: None,
};

static WORD_NAT_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    Some(&WORD_NATC_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_NATI_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_NATR_NODE),
    None,
    None,
    Some(&WORD_NATU_NODE),
    Some(&WORD_NATV_NODE),
    None,
    None,
    None,
    None,
];

static WORD_NATV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NATV_CHILDREN),
    value: None,
};

pub static WORD_NATV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("igation")],
    values: &[&["navigation"]],
    range: 7..=7,
};

static WORD_NATU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NATU_CHILDREN),
    value: None,
};

pub static WORD_NATU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ilus"),
        dictgen::InsensitiveStr::Ascii("raly"),
        dictgen::InsensitiveStr::Ascii("rels"),
        dictgen::InsensitiveStr::Ascii("rely"),
        dictgen::InsensitiveStr::Ascii("rens"),
        dictgen::InsensitiveStr::Ascii("rual"),
        dictgen::InsensitiveStr::Ascii("rually"),
    ],
    values: &[
        &["nautilus"],
        &["naturally"],
        &["natures"],
        &["naturally"],
        &["natures"],
        &["natural"],
        &["naturally"],
    ],
    range: 4..=6,
};

static WORD_NATR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NATR_CHILDREN),
    value: None,
};

pub static WORD_NATR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ual"),
        dictgen::InsensitiveStr::Ascii("ually"),
    ],
    values: &[&["natural"], &["naturally"]],
    range: 3..=5,
};

static WORD_NATI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NATI_CHILDREN),
    value: None,
};

pub static WORD_NATI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("evly"),
        dictgen::InsensitiveStr::Ascii("nal"),
        dictgen::InsensitiveStr::Ascii("nalism"),
        dictgen::InsensitiveStr::Ascii("nalist"),
        dictgen::InsensitiveStr::Ascii("nalists"),
        dictgen::InsensitiveStr::Ascii("nally"),
        dictgen::InsensitiveStr::Ascii("nals"),
        dictgen::InsensitiveStr::Ascii("oanl"),
        dictgen::InsensitiveStr::Ascii("oanlism"),
        dictgen::InsensitiveStr::Ascii("oanlist"),
        dictgen::InsensitiveStr::Ascii("oanlistic"),
        dictgen::InsensitiveStr::Ascii("oanlists"),
        dictgen::InsensitiveStr::Ascii("oanlly"),
        dictgen::InsensitiveStr::Ascii("oanls"),
        dictgen::InsensitiveStr::Ascii("onaal"),
        dictgen::InsensitiveStr::Ascii("onailty"),
        dictgen::InsensitiveStr::Ascii("onales"),
        dictgen::InsensitiveStr::Ascii("onalesl"),
        dictgen::InsensitiveStr::Ascii("onalis"),
        dictgen::InsensitiveStr::Ascii("onalisic"),
        dictgen::InsensitiveStr::Ascii("onalisim"),
        dictgen::InsensitiveStr::Ascii("onalisitc"),
        dictgen::InsensitiveStr::Ascii("onalisitic"),
        dictgen::InsensitiveStr::Ascii("onalisn"),
        dictgen::InsensitiveStr::Ascii("onalistc"),
        dictgen::InsensitiveStr::Ascii("onalistes"),
        dictgen::InsensitiveStr::Ascii("onalistics"),
        dictgen::InsensitiveStr::Ascii("onalisties"),
        dictgen::InsensitiveStr::Ascii("onalistisch"),
        dictgen::InsensitiveStr::Ascii("onalistische"),
        dictgen::InsensitiveStr::Ascii("onalistisen"),
        dictgen::InsensitiveStr::Ascii("onalistisk"),
        dictgen::InsensitiveStr::Ascii("onalistiska"),
        dictgen::InsensitiveStr::Ascii("onalistiske"),
        dictgen::InsensitiveStr::Ascii("onalistiskt"),
        dictgen::InsensitiveStr::Ascii("onalistista"),
        dictgen::InsensitiveStr::Ascii("onalististic"),
        dictgen::InsensitiveStr::Ascii("onalit"),
        dictgen::InsensitiveStr::Ascii("onalite"),
        dictgen::InsensitiveStr::Ascii("onalites"),
        dictgen::InsensitiveStr::Ascii("onalitic"),
        dictgen::InsensitiveStr::Ascii("onalits"),
        dictgen::InsensitiveStr::Ascii("onalitys"),
        dictgen::InsensitiveStr::Ascii("onaliy"),
        dictgen::InsensitiveStr::Ascii("onalizm"),
        dictgen::InsensitiveStr::Ascii("onallity"),
        dictgen::InsensitiveStr::Ascii("onalsim"),
        dictgen::InsensitiveStr::Ascii("onalsitic"),
        dictgen::InsensitiveStr::Ascii("onalsits"),
        dictgen::InsensitiveStr::Ascii("onalties"),
        dictgen::InsensitiveStr::Ascii("onalty"),
        dictgen::InsensitiveStr::Ascii("onaly"),
        dictgen::InsensitiveStr::Ascii("onas"),
        dictgen::InsensitiveStr::Ascii("onella"),
        dictgen::InsensitiveStr::Ascii("onsl"),
        dictgen::InsensitiveStr::Ascii("que"),
        dictgen::InsensitiveStr::Ascii("v"),
        dictgen::InsensitiveStr::Ascii("velly"),
        dictgen::InsensitiveStr::Ascii("velyx"),
        dictgen::InsensitiveStr::Ascii("vey"),
        dictgen::InsensitiveStr::Ascii("vley"),
    ],
    values: &[
        &["natively"],
        &["matinal", "national"],
        &["nationalism"],
        &["nationalist"],
        &["nationalists"],
        &["nationally"],
        &["nationals"],
        &["national"],
        &["nationalism"],
        &["nationalist"],
        &["nationalistic"],
        &["nationalists"],
        &["nationally"],
        &["nationals"],
        &["national"],
        &["nationality"],
        &["nationals"],
        &["nationals"],
        &["nationals"],
        &["nationalistic"],
        &["nationalism"],
        &["nationalistic"],
        &["nationalistic"],
        &["nationals"],
        &["nationalistic"],
        &["nationalists"],
        &["nationalists"],
        &["nationalists"],
        &["nationalists"],
        &["nationalistic"],
        &["nationalists"],
        &["nationalists"],
        &["nationalists"],
        &["nationalists"],
        &["nationalists"],
        &["nationalists"],
        &["nationalistic"],
        &["nationalist"],
        &["nationalist"],
        &["nationalist"],
        &["nationalistic"],
        &["nationalist"],
        &["nationalist"],
        &["nationality"],
        &["nationalism"],
        &["nationally"],
        &["nationalism"],
        &["nationalistic"],
        &["nationalists"],
        &["nationalist"],
        &["nationality"],
        &["nationally"],
        &["nationals"],
        &["national"],
        &["nationals"],
        &["antique"],
        &["native"],
        &["natively"],
        &["natively"],
        &["natively"],
        &["natively"],
    ],
    range: 1..=12,
};

static WORD_NATC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NATC_CHILDREN),
    value: None,
};

pub static WORD_NATC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("hed"),
        dictgen::InsensitiveStr::Ascii("hes"),
    ],
    values: &[&["matched"], &["matches"]],
    range: 3..=3,
};

static WORD_NAS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NAS_CHILDREN),
    value: None,
};

pub static WORD_NAS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("euous"),
        dictgen::InsensitiveStr::Ascii("hvile"),
        dictgen::InsensitiveStr::Ascii("hvillle"),
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("talgea"),
        dictgen::InsensitiveStr::Ascii("ted"),
        dictgen::InsensitiveStr::Ascii("tershem"),
        dictgen::InsensitiveStr::Ascii("tershems"),
        dictgen::InsensitiveStr::Ascii("tershum"),
        dictgen::InsensitiveStr::Ascii("tershums"),
        dictgen::InsensitiveStr::Ascii("tersiem"),
        dictgen::InsensitiveStr::Ascii("tersiems"),
        dictgen::InsensitiveStr::Ascii("tersium"),
        dictgen::InsensitiveStr::Ascii("tersiums"),
        dictgen::InsensitiveStr::Ascii("tertiem"),
        dictgen::InsensitiveStr::Ascii("tertiems"),
        dictgen::InsensitiveStr::Ascii("tertium"),
        dictgen::InsensitiveStr::Ascii("tertiums"),
        dictgen::InsensitiveStr::Ascii("ting"),
        dictgen::InsensitiveStr::Ascii("tly"),
        dictgen::InsensitiveStr::Ascii("ts"),
        dictgen::InsensitiveStr::Ascii("turshem"),
        dictgen::InsensitiveStr::Ascii("turshems"),
        dictgen::InsensitiveStr::Ascii("turshum"),
        dictgen::InsensitiveStr::Ascii("turshums"),
        dictgen::InsensitiveStr::Ascii("tyness"),
        dictgen::InsensitiveStr::Ascii("ueous"),
        dictgen::InsensitiveStr::Ascii("vhille"),
    ],
    values: &[
        &["nauseous"],
        &["nashville"],
        &["nashville"],
        &["mast", "nasty", "nest"],
        &["nostalgia"],
        &["nested"],
        &["nasturtium"],
        &["nasturtiums"],
        &["nasturtium"],
        &["nasturtiums"],
        &["nasturtium"],
        &["nasturtiums"],
        &["nasturtium"],
        &["nasturtiums"],
        &["nasturtium"],
        &["nasturtiums"],
        &["nasturtium"],
        &["nasturtiums"],
        &["nesting"],
        &["nasty"],
        &["masts", "nests"],
        &["nasturtium"],
        &["nasturtiums"],
        &["nasturtium"],
        &["nasturtiums"],
        &["nastiness"],
        &["nauseous"],
        &["nashville"],
    ],
    range: 1..=8,
};

static WORD_NAR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NAR_CHILDREN),
    value: None,
};

pub static WORD_NAR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cassism"),
        dictgen::InsensitiveStr::Ascii("cassist"),
        dictgen::InsensitiveStr::Ascii("cessist"),
        dictgen::InsensitiveStr::Ascii("ciscism"),
        dictgen::InsensitiveStr::Ascii("ciscist"),
        dictgen::InsensitiveStr::Ascii("cisissim"),
        dictgen::InsensitiveStr::Ascii("cisissm"),
        dictgen::InsensitiveStr::Ascii("cisisst"),
        dictgen::InsensitiveStr::Ascii("cisisstic"),
        dictgen::InsensitiveStr::Ascii("cisissts"),
        dictgen::InsensitiveStr::Ascii("cisists"),
        dictgen::InsensitiveStr::Ascii("cisscism"),
        dictgen::InsensitiveStr::Ascii("cisscist"),
        dictgen::InsensitiveStr::Ascii("cissicm"),
        dictgen::InsensitiveStr::Ascii("cissict"),
        dictgen::InsensitiveStr::Ascii("cissictic"),
        dictgen::InsensitiveStr::Ascii("cissim"),
        dictgen::InsensitiveStr::Ascii("cissisim"),
        dictgen::InsensitiveStr::Ascii("cissisism"),
        dictgen::InsensitiveStr::Ascii("cissisist"),
        dictgen::InsensitiveStr::Ascii("cissisitc"),
        dictgen::InsensitiveStr::Ascii("cissisitic"),
        dictgen::InsensitiveStr::Ascii("cississm"),
        dictgen::InsensitiveStr::Ascii("cississt"),
        dictgen::InsensitiveStr::Ascii("cississtic"),
        dictgen::InsensitiveStr::Ascii("cississts"),
        dictgen::InsensitiveStr::Ascii("cissistc"),
        dictgen::InsensitiveStr::Ascii("cissit"),
        dictgen::InsensitiveStr::Ascii("cissitc"),
        dictgen::InsensitiveStr::Ascii("cissitic"),
        dictgen::InsensitiveStr::Ascii("cissits"),
        dictgen::InsensitiveStr::Ascii("cissm"),
        dictgen::InsensitiveStr::Ascii("cisssism"),
        dictgen::InsensitiveStr::Ascii("cisssist"),
        dictgen::InsensitiveStr::Ascii("cissstic"),
        dictgen::InsensitiveStr::Ascii("cisst"),
        dictgen::InsensitiveStr::Ascii("cissts"),
        dictgen::InsensitiveStr::Ascii("coticos"),
        dictgen::InsensitiveStr::Ascii("cotis"),
        dictgen::InsensitiveStr::Ascii("ctoics"),
        dictgen::InsensitiveStr::Ascii("hwal"),
        dictgen::InsensitiveStr::Ascii("l"),
        dictgen::InsensitiveStr::Ascii("led"),
        dictgen::InsensitiveStr::Ascii("ling"),
        dictgen::InsensitiveStr::Ascii("ls"),
        dictgen::InsensitiveStr::Ascii("ly"),
        dictgen::InsensitiveStr::Ascii("rativas"),
        dictgen::InsensitiveStr::Ascii("rativos"),
        dictgen::InsensitiveStr::Ascii("ritives"),
        dictgen::InsensitiveStr::Ascii("ssicistic"),
        dictgen::InsensitiveStr::Ascii("wharl"),
    ],
    values: &[
        &["narcissism"],
        &["narcissist"],
        &["narcissist"],
        &["narcissism"],
        &["narcissist"],
        &["narcissism"],
        &["narcissism"],
        &["narcissist"],
        &["narcissistic"],
        &["narcissist"],
        &["narcissist"],
        &["narcissism"],
        &["narcissist"],
        &["narcissism"],
        &["narcissist"],
        &["narcissistic"],
        &["narcissism"],
        &["narcissism"],
        &["narcissism"],
        &["narcissist"],
        &["narcissist"],
        &["narcissistic"],
        &["narcissism"],
        &["narcissist"],
        &["narcissistic"],
        &["narcissist"],
        &["narcissistic"],
        &["narcissist"],
        &["narcissist"],
        &["narcissistic"],
        &["narcissist"],
        &["narcissism"],
        &["narcissism"],
        &["narcissist"],
        &["narcissist"],
        &["narcissist"],
        &["narcissist"],
        &["narcotics"],
        &["narcotics"],
        &["narcotics"],
        &["narwhal"],
        &[
            "earl", "farl", "gnarl", "marl", "nail", "nark", "nary", "snarl",
        ],
        &["gnarled", "nailed", "narked", "snarled"],
        &["gnarling", "nailing", "narking", "snarling"],
        &[
            "earls", "farls", "gnarls", "marls", "nails", "narks", "snarls",
        ],
        &["gnarly"],
        &["narratives"],
        &["narratives"],
        &["narratives"],
        &["narcissistic"],
        &["narwhal"],
    ],
    range: 1..=10,
};

static WORD_NAP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NAP_CHILDREN),
    value: None,
};

pub static WORD_NAP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cakes"),
        dictgen::InsensitiveStr::Ascii("loeon"),
        dictgen::InsensitiveStr::Ascii("oelon"),
        dictgen::InsensitiveStr::Ascii("olean"),
        dictgen::InsensitiveStr::Ascii("olen"),
        dictgen::InsensitiveStr::Ascii("oleonian"),
        dictgen::InsensitiveStr::Ascii("oloen"),
        dictgen::InsensitiveStr::Ascii("om"),
        dictgen::InsensitiveStr::Ascii("omed"),
        dictgen::InsensitiveStr::Ascii("omes"),
        dictgen::InsensitiveStr::Ascii("oming"),
        dictgen::InsensitiveStr::Ascii("ommed"),
        dictgen::InsensitiveStr::Ascii("ommes"),
        dictgen::InsensitiveStr::Ascii("omming"),
        dictgen::InsensitiveStr::Ascii("omms"),
        dictgen::InsensitiveStr::Ascii("oms"),
    ],
    values: &[
        &["pancakes"],
        &["napoleon"],
        &["napoleon"],
        &["napoleon"],
        &["napoleon"],
        &["napoleonic"],
        &["napoleon"],
        &["napalm"],
        &["napalmed"],
        &["napalms"],
        &["napalming"],
        &["napalmed"],
        &["napalms"],
        &["napalming"],
        &["napalms"],
        &["napalms"],
    ],
    range: 2..=8,
};

static WORD_NAO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NAO_CHILDREN),
    value: None,
};

pub static WORD_NAO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("pleon")],
    values: &[&["napoleon"]],
    range: 5..=5,
};

static WORD_NAN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NAN_CHILDREN),
    value: None,
};

pub static WORD_NAN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("osecod"),
        dictgen::InsensitiveStr::Ascii("osecods"),
        dictgen::InsensitiveStr::Ascii("osencond"),
        dictgen::InsensitiveStr::Ascii("osenconds"),
        dictgen::InsensitiveStr::Ascii("oseond"),
        dictgen::InsensitiveStr::Ascii("oseonds"),
    ],
    values: &[
        &["name"],
        &["nanosecond"],
        &["nanoseconds"],
        &["nanosecond"],
        &["nanoseconds"],
        &["nanosecond"],
        &["nanoseconds"],
    ],
    range: 1..=9,
};

static WORD_NAM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NAM_CHILDREN),
    value: Some(&["name"]),
};

pub static WORD_NAM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aed"),
        dictgen::InsensitiveStr::Ascii("aes"),
        dictgen::InsensitiveStr::Ascii("d"),
        dictgen::InsensitiveStr::Ascii("eing"),
        dictgen::InsensitiveStr::Ascii("emespace"),
        dictgen::InsensitiveStr::Ascii("epace"),
        dictgen::InsensitiveStr::Ascii("epsace"),
        dictgen::InsensitiveStr::Ascii("epsaces"),
        dictgen::InsensitiveStr::Ascii("esapce"),
        dictgen::InsensitiveStr::Ascii("esapced"),
        dictgen::InsensitiveStr::Ascii("esapces"),
        dictgen::InsensitiveStr::Ascii("esd"),
        dictgen::InsensitiveStr::Ascii("ess"),
        dictgen::InsensitiveStr::Ascii("esspaces"),
        dictgen::InsensitiveStr::Ascii("me"),
        dictgen::InsensitiveStr::Ascii("ne"),
        dictgen::InsensitiveStr::Ascii("ned"),
        dictgen::InsensitiveStr::Ascii("nes"),
        dictgen::InsensitiveStr::Ascii("nespace"),
        dictgen::InsensitiveStr::Ascii("nespaces"),
        dictgen::InsensitiveStr::Ascii("s"),
        dictgen::InsensitiveStr::Ascii("space"),
        dictgen::InsensitiveStr::Ascii("spaces"),
    ],
    values: &[
        &["named"],
        &["names"],
        &["named", "name"],
        &["naming"],
        &["namespace"],
        &["namespace"],
        &["namespace"],
        &["namespaces"],
        &["namespace"],
        &["namespaced"],
        &["namespaces"],
        &["named", "names"],
        &["names"],
        &["namespaces"],
        &["name"],
        &["name"],
        &["named"],
        &["names"],
        &["namespace"],
        &["namespaces"],
        &["names"],
        &["namespace"],
        &["namespaces"],
    ],
    range: 1..=8,
};

static WORD_NAI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NAI_CHILDREN),
    value: None,
};

pub static WORD_NAI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("bhor"),
        dictgen::InsensitiveStr::Ascii("bhorhood"),
        dictgen::InsensitiveStr::Ascii("bhorhoods"),
        dictgen::InsensitiveStr::Ascii("bhorly"),
        dictgen::InsensitiveStr::Ascii("bhors"),
        dictgen::InsensitiveStr::Ascii("bor"),
        dictgen::InsensitiveStr::Ascii("borhood"),
        dictgen::InsensitiveStr::Ascii("borhoods"),
        dictgen::InsensitiveStr::Ascii("borly"),
        dictgen::InsensitiveStr::Ascii("bors"),
        dictgen::InsensitiveStr::Ascii("eve"),
        dictgen::InsensitiveStr::Ascii("vity"),
    ],
    values: &[
        &["neighbor"],
        &["neighborhood"],
        &["neighborhoods"],
        &["neighborly"],
        &["neighbor", "neighbors"],
        &["neighbor"],
        &["neighborhood"],
        &["neighborhoods"],
        &["neighborly"],
        &["neighbors"],
        &["naive"],
        &["naivety"],
    ],
    range: 3..=9,
};

static WORD_NAH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NAH_CHILDREN),
    value: None,
};

pub static WORD_NAH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("sville")],
    values: &[&["nashville"]],
    range: 6..=6,
};

static WORD_NAG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NAG_CHILDREN),
    value: None,
};

pub static WORD_NAG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ative"),
        dictgen::InsensitiveStr::Ascii("atively"),
        dictgen::InsensitiveStr::Ascii("atives"),
        dictgen::InsensitiveStr::Ascii("ivate"),
        dictgen::InsensitiveStr::Ascii("ivating"),
        dictgen::InsensitiveStr::Ascii("ivation"),
    ],
    values: &[
        &["negative"],
        &["negatively"],
        &["negatives"],
        &["navigate"],
        &["navigating"],
        &["navigation"],
    ],
    range: 5..=7,
};

static WORD_NAF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NAF_CHILDREN),
    value: None,
};

pub static WORD_NAF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("erious")],
    values: &[&["nefarious"]],
    range: 6..=6,
};

static WORD_NAE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NAE_CHILDREN),
    value: None,
};

pub static WORD_NAE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("rly")],
    values: &[&["nearly", "gnarly"]],
    range: 3..=3,
};

static WORD_NAD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NAD_CHILDREN),
    value: None,
};

pub static WORD_NAD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ly")],
    values: &[&["badly"]],
    range: 2..=2,
};

static WORD_NAC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NAC_CHILDREN),
    value: None,
};

pub static WORD_NAC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ionalistic"),
        dictgen::InsensitiveStr::Ascii("ionalists"),
        dictgen::InsensitiveStr::Ascii("rotics"),
    ],
    values: &[&["nationalistic"], &["nationalists"], &["narcotics"]],
    range: 6..=10,
};

static WORD_NAA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_NAA_CHILDREN),
    value: None,
};

pub static WORD_NAA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("me")],
    values: &[&["name"]],
    range: 2..=2,
};

static WORD_M_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_M_CHILDREN),
    value: None,
};

static WORD_M_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_MA_NODE),
    None,
    Some(&WORD_MC_NODE),
    Some(&WORD_MD_NODE),
    Some(&WORD_ME_NODE),
    None,
    None,
    Some(&WORD_MH_NODE),
    Some(&WORD_MI_NODE),
    Some(&WORD_MJ_NODE),
    Some(&WORD_MK_NODE),
    None,
    Some(&WORD_MM_NODE),
    Some(&WORD_MN_NODE),
    Some(&WORD_MO_NODE),
    Some(&WORD_MP_NODE),
    None,
    Some(&WORD_MR_NODE),
    Some(&WORD_MS_NODE),
    Some(&WORD_MT_NODE),
    Some(&WORD_MU_NODE),
    None,
    Some(&WORD_MW_NODE),
    None,
    Some(&WORD_MY_NODE),
    None,
];

static WORD_MY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MY_CHILDREN),
    value: None,
};

pub static WORD_MY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("abe"),
        dictgen::InsensitiveStr::Ascii("be"),
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("htical"),
        dictgen::InsensitiveStr::Ascii("itereator"),
        dictgen::InsensitiveStr::Ascii("psace"),
        dictgen::InsensitiveStr::Ascii("raid"),
        dictgen::InsensitiveStr::Ascii("sapce"),
        dictgen::InsensitiveStr::Ascii("sef"),
        dictgen::InsensitiveStr::Ascii("sefl"),
        dictgen::InsensitiveStr::Ascii("sekf"),
        dictgen::InsensitiveStr::Ascii("selfe"),
        dictgen::InsensitiveStr::Ascii("selfes"),
        dictgen::InsensitiveStr::Ascii("selv"),
        dictgen::InsensitiveStr::Ascii("selve"),
        dictgen::InsensitiveStr::Ascii("selves"),
        dictgen::InsensitiveStr::Ascii("sitcal"),
        dictgen::InsensitiveStr::Ascii("slef"),
        dictgen::InsensitiveStr::Ascii("soganistic"),
        dictgen::InsensitiveStr::Ascii("sogenistic"),
        dictgen::InsensitiveStr::Ascii("sogonistic"),
        dictgen::InsensitiveStr::Ascii("sogynist"),
        dictgen::InsensitiveStr::Ascii("sogyny"),
        dictgen::InsensitiveStr::Ascii("sterieus"),
        dictgen::InsensitiveStr::Ascii("sterieuse"),
        dictgen::InsensitiveStr::Ascii("steriosly"),
        dictgen::InsensitiveStr::Ascii("sterioulsy"),
        dictgen::InsensitiveStr::Ascii("steriouly"),
        dictgen::InsensitiveStr::Ascii("steriousy"),
        dictgen::InsensitiveStr::Ascii("steris"),
        dictgen::InsensitiveStr::Ascii("sterise"),
        dictgen::InsensitiveStr::Ascii("sterous"),
        dictgen::InsensitiveStr::Ascii("stql"),
        dictgen::InsensitiveStr::Ascii("strow"),
        dictgen::InsensitiveStr::Ascii("strows"),
        dictgen::InsensitiveStr::Ascii("thraic"),
        dictgen::InsensitiveStr::Ascii("u"),
    ],
    values: &[
        &["maybe"],
        &["maybe"],
        &["may", "my"],
        &["mythical"],
        &["myiterator"],
        &["myspace"],
        &["myriad"],
        &["myspace"],
        &["myself"],
        &["myself"],
        &["myself"],
        &["myself"],
        &["myself"],
        &["myself"],
        &["myself"],
        &["myself"],
        &["mystical"],
        &["myself"],
        &["misogynistic"],
        &["misogynistic"],
        &["misogynistic"],
        &["misogynist"],
        &["misogyny"],
        &["mysteries"],
        &["mysteries"],
        &["mysteriously"],
        &["mysteriously"],
        &["mysteriously"],
        &["mysteriously"],
        &["mysteries"],
        &["mysteries"],
        &["mysterious"],
        &["mysql"],
        &["maestro"],
        &["maestros"],
        &["mithraic"],
        &["my"],
    ],
    range: 1..=10,
};

static WORD_MW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MW_CHILDREN),
    value: None,
};

pub static WORD_MW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("cos")],
    values: &[&["macos"]],
    range: 3..=3,
};

static WORD_MU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_MU_CHILDREN),
    value: None,
};

static WORD_MU_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    Some(&WORD_MUC_NODE),
    Some(&WORD_MUD_NODE),
    Some(&WORD_MUE_NODE),
    Some(&WORD_MUF_NODE),
    None,
    None,
    Some(&WORD_MUI_NODE),
    None,
    Some(&WORD_MUK_NODE),
    Some(&WORD_MUL_NODE),
    Some(&WORD_MUM_NODE),
    Some(&WORD_MUN_NODE),
    None,
    None,
    None,
    Some(&WORD_MUR_NODE),
    Some(&WORD_MUS_NODE),
    Some(&WORD_MUT_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_MUY_NODE),
    None,
];

static WORD_MUY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MUY_CHILDREN),
    value: None,
};

pub static WORD_MUY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("st")],
    values: &[&["must"]],
    range: 2..=2,
};

static WORD_MUT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MUT_CHILDREN),
    value: None,
};

pub static WORD_MUT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ablity"),
        dictgen::InsensitiveStr::Ascii("atin"),
        dictgen::InsensitiveStr::Ascii("atiohn"),
        dictgen::InsensitiveStr::Ascii("bal"),
        dictgen::InsensitiveStr::Ascii("bale"),
        dictgen::InsensitiveStr::Ascii("ch"),
        dictgen::InsensitiveStr::Ascii("ches"),
        dictgen::InsensitiveStr::Ascii("ecies"),
        dictgen::InsensitiveStr::Ascii("exs"),
        dictgen::InsensitiveStr::Ascii("i"),
        dictgen::InsensitiveStr::Ascii("ialted"),
        dictgen::InsensitiveStr::Ascii("ialtion"),
        dictgen::InsensitiveStr::Ascii("icast"),
        dictgen::InsensitiveStr::Ascii("ices"),
        dictgen::InsensitiveStr::Ascii("iindex"),
        dictgen::InsensitiveStr::Ascii("ilatin"),
        dictgen::InsensitiveStr::Ascii("ilcast"),
        dictgen::InsensitiveStr::Ascii("iliated"),
        dictgen::InsensitiveStr::Ascii("imarked"),
        dictgen::InsensitiveStr::Ascii("ipath"),
        dictgen::InsensitiveStr::Ascii("ipl"),
        dictgen::InsensitiveStr::Ascii("iple"),
        dictgen::InsensitiveStr::Ascii("iply"),
        dictgen::InsensitiveStr::Ascii("ipule"),
        dictgen::InsensitiveStr::Ascii("li"),
        dictgen::InsensitiveStr::Ascii("liated"),
        dictgen::InsensitiveStr::Ascii("liation"),
        dictgen::InsensitiveStr::Ascii("linational"),
        dictgen::InsensitiveStr::Ascii("linationals"),
        dictgen::InsensitiveStr::Ascii("lipart"),
        dictgen::InsensitiveStr::Ascii("liplayer"),
        dictgen::InsensitiveStr::Ascii("liple"),
        dictgen::InsensitiveStr::Ascii("lipler"),
        dictgen::InsensitiveStr::Ascii("liples"),
        dictgen::InsensitiveStr::Ascii("liplication"),
        dictgen::InsensitiveStr::Ascii("liplicites"),
        dictgen::InsensitiveStr::Ascii("liplied"),
        dictgen::InsensitiveStr::Ascii("liplier"),
        dictgen::InsensitiveStr::Ascii("lipliers"),
        dictgen::InsensitiveStr::Ascii("liply"),
        dictgen::InsensitiveStr::Ascii("liplying"),
        dictgen::InsensitiveStr::Ascii("litasking"),
        dictgen::InsensitiveStr::Ascii("litude"),
        dictgen::InsensitiveStr::Ascii("liverse"),
        dictgen::InsensitiveStr::Ascii("ully"),
        dictgen::InsensitiveStr::Ascii("ux"),
        dictgen::InsensitiveStr::Ascii("uxes"),
        dictgen::InsensitiveStr::Ascii("uxs"),
    ],
    values: &[
        &["mutability"],
        &["mutation"],
        &["mutation"],
        &["mutable"],
        &["mutable"],
        &["much"],
        &["matches"],
        &["mutexes"],
        &["mutexes"],
        &["multi"],
        &["mutilated"],
        &["mutilation"],
        &["multicast"],
        &["mutexes"],
        &["multiindex"],
        &["mutilation"],
        &["multicast"],
        &["mutilated"],
        &["multimarked"],
        &["multipath"],
        &["multiple", "multiply"],
        &["multiple"],
        &["multiply"],
        &["multiple"],
        &["multi"],
        &["mutilated"],
        &["mutilation"],
        &["multinational"],
        &["multinational"],
        &["multipart"],
        &["multiplayer"],
        &["multiple"],
        &["multiplier", "multiple"],
        &["multiples"],
        &["multiplication"],
        &["multiplicities"],
        &["multiplied"],
        &["multiplier"],
        &["multipliers"],
        &["multiply"],
        &["multiplying"],
        &["multitasking"],
        &["multitude"],
        &["multiverse"],
        &["mutually"],
        &["mutex"],
        &["mutexes"],
        &["mutexes"],
    ],
    range: 1..=11,
};

static WORD_MUS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MUS_CHILDREN),
    value: None,
};

pub static WORD_MUS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cel"),
        dictgen::InsensitiveStr::Ascii("cels"),
        dictgen::InsensitiveStr::Ascii("cial"),
        dictgen::InsensitiveStr::Ascii("cially"),
        dictgen::InsensitiveStr::Ascii("cician"),
        dictgen::InsensitiveStr::Ascii("cicians"),
        dictgen::InsensitiveStr::Ascii("cil"),
        dictgen::InsensitiveStr::Ascii("cils"),
        dictgen::InsensitiveStr::Ascii("cluar"),
        dictgen::InsensitiveStr::Ascii("cualr"),
        dictgen::InsensitiveStr::Ascii("culair"),
        dictgen::InsensitiveStr::Ascii("culaire"),
        dictgen::InsensitiveStr::Ascii("el"),
        dictgen::InsensitiveStr::Ascii("els"),
        dictgen::InsensitiveStr::Ascii("hrom"),
        dictgen::InsensitiveStr::Ascii("hrooom"),
        dictgen::InsensitiveStr::Ascii("hroooms"),
        dictgen::InsensitiveStr::Ascii("icains"),
        dictgen::InsensitiveStr::Ascii("icallity"),
        dictgen::InsensitiveStr::Ascii("icaly"),
        dictgen::InsensitiveStr::Ascii("il"),
        dictgen::InsensitiveStr::Ascii("ilms"),
        dictgen::InsensitiveStr::Ascii("ils"),
        dictgen::InsensitiveStr::Ascii("lces"),
        dictgen::InsensitiveStr::Ascii("sil"),
        dictgen::InsensitiveStr::Ascii("sils"),
        dictgen::InsensitiveStr::Ascii("tash"),
        dictgen::InsensitiveStr::Ascii("tator"),
        dictgen::InsensitiveStr::Ascii("te"),
        dictgen::InsensitiveStr::Ascii("uclar"),
        dictgen::InsensitiveStr::Ascii("uems"),
    ],
    values: &[
        &["muscle", "mussel"],
        &["mussels", "muscles"],
        &["musical"],
        &["musically"],
        &["musician"],
        &["musicians"],
        &["muscle", "mussel"],
        &["muscles", "mussels"],
        &["muscular"],
        &["muscular"],
        &["muscular"],
        &["muscular"],
        &["muscle", "mussel"],
        &["muscles", "mussels"],
        &["mushroom"],
        &["mushroom"],
        &["mushroom"],
        &["musicians"],
        &["musically"],
        &["musically"],
        &["muscle", "mussel"],
        &["muslims"],
        &["muscles", "mussels"],
        &["muscles"],
        &["muscle", "mussel"],
        &["muscles", "mussels"],
        &["mustache"],
        &["mutator"],
        &["must"],
        &["muscular"],
        &["museums"],
    ],
    range: 2..=8,
};

static WORD_MUR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MUR_CHILDREN),
    value: None,
};

pub static WORD_MUR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("derd"),
        dictgen::InsensitiveStr::Ascii("dererd"),
        dictgen::InsensitiveStr::Ascii("derered"),
        dictgen::InsensitiveStr::Ascii("dereres"),
        dictgen::InsensitiveStr::Ascii("dererous"),
        dictgen::InsensitiveStr::Ascii("deres"),
        dictgen::InsensitiveStr::Ascii("derus"),
        dictgen::InsensitiveStr::Ascii("r"),
    ],
    values: &[
        &["murdered"],
        &["murdered"],
        &["murdered"],
        &["murderers"],
        &["murderers"],
        &["murders"],
        &["murders"],
        &["myrrh"],
    ],
    range: 1..=8,
};

static WORD_MUN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MUN_CHILDREN),
    value: None,
};

pub static WORD_MUN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("bers"),
        dictgen::InsensitiveStr::Ascii("chis"),
        dictgen::InsensitiveStr::Ascii("cipalities"),
        dictgen::InsensitiveStr::Ascii("cipality"),
        dictgen::InsensitiveStr::Ascii("dance"),
        dictgen::InsensitiveStr::Ascii("dande"),
        dictgen::InsensitiveStr::Ascii("iches"),
        dictgen::InsensitiveStr::Ascii("iciple"),
        dictgen::InsensitiveStr::Ascii("ipulative"),
        dictgen::InsensitiveStr::Ascii("nicipality"),
        dictgen::InsensitiveStr::Ascii("ute"),
    ],
    values: &[
        &["numbers"],
        &["munchies"],
        &["municipalities"],
        &["municipality"],
        &["mundane"],
        &["mundane"],
        &["munchies"],
        &["municipal"],
        &["manipulative"],
        &["municipality"],
        &["minute"],
    ],
    range: 3..=10,
};

static WORD_MUM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MUM_CHILDREN),
    value: None,
};

pub static WORD_MUM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ber"),
        dictgen::InsensitiveStr::Ascii("bers"),
    ],
    values: &[&["number"], &["numbers"]],
    range: 3..=4,
};

static WORD_MUL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_MUL_CHILDREN),
    value: None,
};

static WORD_MUL_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_MULI_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_MULS_NODE),
    Some(&WORD_MULT_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_MULT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_MULT_CHILDREN),
    value: None,
};

static WORD_MULT_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_MULTI_NODE),
    None,
    None,
    Some(&WORD_MULTL_NODE),
    None,
    None,
    None,
    Some(&WORD_MULTP_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_MULTY_NODE),
    None,
];

static WORD_MULTY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MULTY_CHILDREN),
    value: Some(&["multi"]),
};

pub static WORD_MULTY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("player"),
        dictgen::InsensitiveStr::Ascii("plying"),
    ],
    values: &[&["multiplayer"], &["multiplying"]],
    range: 6..=6,
};

static WORD_MULTP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MULTP_CHILDREN),
    value: None,
};

pub static WORD_MULTP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ile"),
        dictgen::InsensitiveStr::Ascii("le"),
        dictgen::InsensitiveStr::Ascii("les"),
        dictgen::InsensitiveStr::Ascii("lied"),
        dictgen::InsensitiveStr::Ascii("lier"),
        dictgen::InsensitiveStr::Ascii("liers"),
        dictgen::InsensitiveStr::Ascii("lies"),
        dictgen::InsensitiveStr::Ascii("ly"),
        dictgen::InsensitiveStr::Ascii("lying"),
    ],
    values: &[
        &["multiple"],
        &["multiple"],
        &["multiples"],
        &["multiplied"],
        &["multiplier"],
        &["multipliers"],
        &["multiples", "multiplies"],
        &["multiply"],
        &["multiplying"],
    ],
    range: 2..=5,
};

static WORD_MULTL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MULTL_CHILDREN),
    value: None,
};

pub static WORD_MULTL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ine"),
        dictgen::InsensitiveStr::Ascii("iple"),
        dictgen::InsensitiveStr::Ascii("iples"),
        dictgen::InsensitiveStr::Ascii("iplied"),
        dictgen::InsensitiveStr::Ascii("iplier"),
        dictgen::InsensitiveStr::Ascii("ipliers"),
        dictgen::InsensitiveStr::Ascii("iplies"),
        dictgen::InsensitiveStr::Ascii("iply"),
        dictgen::InsensitiveStr::Ascii("iplying"),
    ],
    values: &[
        &["multiline"],
        &["multiple"],
        &["multiples"],
        &["multiplied"],
        &["multiplier"],
        &["multipliers"],
        &["multiplies"],
        &["multiply"],
        &["multiplying"],
    ],
    range: 3..=7,
};

static WORD_MULTI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MULTI_CHILDREN),
    value: None,
};

pub static WORD_MULTI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ble"),
        dictgen::InsensitiveStr::Ascii("bye"),
        dictgen::InsensitiveStr::Ascii("cat"),
        dictgen::InsensitiveStr::Ascii("cultralism"),
        dictgen::InsensitiveStr::Ascii("dimensinal"),
        dictgen::InsensitiveStr::Ascii("dimension"),
        dictgen::InsensitiveStr::Ascii("dimensionnal"),
        dictgen::InsensitiveStr::Ascii("dimentionnal"),
        dictgen::InsensitiveStr::Ascii("ecast"),
        dictgen::InsensitiveStr::Ascii("fuction"),
        dictgen::InsensitiveStr::Ascii("langual"),
        dictgen::InsensitiveStr::Ascii("le"),
        dictgen::InsensitiveStr::Ascii("lpe"),
        dictgen::InsensitiveStr::Ascii("lpier"),
        dictgen::InsensitiveStr::Ascii("mational"),
        dictgen::InsensitiveStr::Ascii("natinal"),
        dictgen::InsensitiveStr::Ascii("nationella"),
        dictgen::InsensitiveStr::Ascii("palyer"),
        dictgen::InsensitiveStr::Ascii("pe"),
        dictgen::InsensitiveStr::Ascii("pes"),
        dictgen::InsensitiveStr::Ascii("piler"),
        dictgen::InsensitiveStr::Ascii("pilers"),
        dictgen::InsensitiveStr::Ascii("pl"),
        dictgen::InsensitiveStr::Ascii("plaer"),
        dictgen::InsensitiveStr::Ascii("plater"),
        dictgen::InsensitiveStr::Ascii("playe"),
        dictgen::InsensitiveStr::Ascii("playr"),
        dictgen::InsensitiveStr::Ascii("plays"),
        dictgen::InsensitiveStr::Ascii("plebgs"),
        dictgen::InsensitiveStr::Ascii("pled"),
        dictgen::InsensitiveStr::Ascii("pleies"),
        dictgen::InsensitiveStr::Ascii("pler"),
        dictgen::InsensitiveStr::Ascii("plers"),
        dictgen::InsensitiveStr::Ascii("pleye"),
        dictgen::InsensitiveStr::Ascii("plicacion"),
        dictgen::InsensitiveStr::Ascii("plicaiton"),
        dictgen::InsensitiveStr::Ascii("plicativo"),
        dictgen::InsensitiveStr::Ascii("plicaton"),
        dictgen::InsensitiveStr::Ascii("pliciaton"),
        dictgen::InsensitiveStr::Ascii("plicites"),
        dictgen::InsensitiveStr::Ascii("plicty"),
        dictgen::InsensitiveStr::Ascii("plikation"),
        dictgen::InsensitiveStr::Ascii("pling"),
        dictgen::InsensitiveStr::Ascii("pllication"),
        dictgen::InsensitiveStr::Ascii("plr"),
        dictgen::InsensitiveStr::Ascii("pls"),
        dictgen::InsensitiveStr::Ascii("plyed"),
        dictgen::InsensitiveStr::Ascii("plyer"),
        dictgen::InsensitiveStr::Ascii("plyng"),
        dictgen::InsensitiveStr::Ascii("presistion"),
        dictgen::InsensitiveStr::Ascii("pul"),
        dictgen::InsensitiveStr::Ascii("py"),
        dictgen::InsensitiveStr::Ascii("pyling"),
        dictgen::InsensitiveStr::Ascii("taksing"),
        dictgen::InsensitiveStr::Ascii("taskng"),
        dictgen::InsensitiveStr::Ascii("threded"),
        dictgen::InsensitiveStr::Ascii("tudine"),
        dictgen::InsensitiveStr::Ascii("tute"),
        dictgen::InsensitiveStr::Ascii("verese"),
        dictgen::InsensitiveStr::Ascii("vriate"),
        dictgen::InsensitiveStr::Ascii("xsite"),
    ],
    values: &[
        &["multiple"],
        &["multibyte"],
        &["multicast"],
        &["multiculturalism"],
        &["multidimensional"],
        &["multidimensional"],
        &["multidimensional"],
        &["multidimensional"],
        &["multicast"],
        &["multifunction"],
        &["multilingual"],
        &["multiple"],
        &["multiple"],
        &["multiplier"],
        &["multinational"],
        &["multinational"],
        &["multinational"],
        &["multiplayer"],
        &["multiple"],
        &["multiples"],
        &["multiplier"],
        &["multipliers"],
        &["multiple", "multiply"],
        &["multiplier"],
        &["multiplayer"],
        &["multiply"],
        &["multiply"],
        &["multiply"],
        &["multiples"],
        &["multiplied"],
        &["multiples"],
        &["multiplier", "multiple"],
        &["multipliers"],
        &["multiply"],
        &["multiplication"],
        &["multiplication"],
        &["multiplication"],
        &["multiplication"],
        &["multiplication"],
        &["multiplicities"],
        &["multiplicity"],
        &["multiplication"],
        &["multiplying"],
        &["multiplication"],
        &["multiplier"],
        &["multiples"],
        &["multiplied"],
        &["multiple"],
        &["multiplying"],
        &["multiprecision"],
        &["multiple"],
        &["multiply"],
        &["multiplying"],
        &["multitasking"],
        &["multitasking"],
        &["multithreaded"],
        &["multitude"],
        &["multitude"],
        &["multiverse"],
        &["multivariate"],
        &["multisite"],
    ],
    range: 2..=12,
};

static WORD_MULS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MULS_CHILDREN),
    value: None,
};

pub static WORD_MULS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ims")],
    values: &[&["muslims"]],
    range: 3..=3,
};

static WORD_MULI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MULI_CHILDREN),
    value: None,
};

pub static WORD_MULI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("part"),
        dictgen::InsensitiveStr::Ascii("ple"),
        dictgen::InsensitiveStr::Ascii("ples"),
        dictgen::InsensitiveStr::Ascii("tated"),
        dictgen::InsensitiveStr::Ascii("tation"),
        dictgen::InsensitiveStr::Ascii("thread"),
        dictgen::InsensitiveStr::Ascii("tiple"),
        dictgen::InsensitiveStr::Ascii("tiplier"),
        dictgen::InsensitiveStr::Ascii("tipliers"),
        dictgen::InsensitiveStr::Ascii("tnational"),
        dictgen::InsensitiveStr::Ascii("tnationals"),
        dictgen::InsensitiveStr::Ascii("tpart"),
        dictgen::InsensitiveStr::Ascii("tpath"),
        dictgen::InsensitiveStr::Ascii("tplayer"),
        dictgen::InsensitiveStr::Ascii("tple"),
        dictgen::InsensitiveStr::Ascii("tples"),
        dictgen::InsensitiveStr::Ascii("tplication"),
        dictgen::InsensitiveStr::Ascii("tplicative"),
        dictgen::InsensitiveStr::Ascii("tplied"),
        dictgen::InsensitiveStr::Ascii("tplier"),
        dictgen::InsensitiveStr::Ascii("tpliers"),
        dictgen::InsensitiveStr::Ascii("tply"),
        dictgen::InsensitiveStr::Ascii("tplying"),
        dictgen::InsensitiveStr::Ascii("ttasking"),
        dictgen::InsensitiveStr::Ascii("tverse"),
    ],
    values: &[
        &["multipart"],
        &["multiple"],
        &["multiples"],
        &["mutilated"],
        &["mutilation"],
        &["multithread"],
        &["multiple"],
        &["multiplier"],
        &["multipliers"],
        &["multinational"],
        &["multinational"],
        &["multipart"],
        &["multipath"],
        &["multiplayer"],
        &["multiple"],
        &["multiples"],
        &["multiplication"],
        &["multiplicative"],
        &["multiplied"],
        &["multiplier"],
        &["multipliers"],
        &["multiply"],
        &["multiplying"],
        &["multitasking"],
        &["multiverse"],
    ],
    range: 3..=10,
};

static WORD_MUK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MUK_CHILDREN),
    value: None,
};

pub static WORD_MUK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("titasking")],
    values: &[&["multitasking"]],
    range: 9..=9,
};

static WORD_MUI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MUI_CHILDREN),
    value: None,
};

pub static WORD_MUI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ltiple"),
        dictgen::InsensitiveStr::Ascii("ltiples"),
    ],
    values: &[&["multiple"], &["multiples"]],
    range: 6..=7,
};

static WORD_MUF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MUF_CHILDREN),
    value: None,
};

pub static WORD_MUF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("fings"),
        dictgen::InsensitiveStr::Ascii("finus"),
    ],
    values: &[&["muffins"], &["muffins"]],
    range: 5..=5,
};

static WORD_MUE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MUE_CHILDREN),
    value: None,
};

pub static WORD_MUE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("sums"),
        dictgen::InsensitiveStr::Ascii("xt"),
    ],
    values: &[&["museums"], &["mutex"]],
    range: 2..=4,
};

static WORD_MUD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MUD_CHILDREN),
    value: None,
};

pub static WORD_MUD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("er"),
        dictgen::InsensitiveStr::Ascii("ering"),
        dictgen::InsensitiveStr::Ascii("ule"),
        dictgen::InsensitiveStr::Ascii("ules"),
    ],
    values: &[&["murder"], &["murdering"], &["module"], &["modules"]],
    range: 2..=5,
};

static WORD_MUC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MUC_CHILDREN),
    value: None,
};

pub static WORD_MUC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("isians"),
        dictgen::InsensitiveStr::Ascii("nhies"),
        dictgen::InsensitiveStr::Ascii("uous"),
    ],
    values: &[&["musicians"], &["munchies"], &["mucous"]],
    range: 4..=6,
};

static WORD_MT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MT_CHILDREN),
    value: None,
};

pub static WORD_MT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("hod"),
        dictgen::InsensitiveStr::Ascii("uually"),
    ],
    values: &[&["method"], &["mutually"]],
    range: 3..=6,
};

static WORD_MS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MS_CHILDREN),
    value: None,
};

pub static WORD_MS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("sing"),
        dictgen::InsensitiveStr::Ascii("ssge"),
        dictgen::InsensitiveStr::Ascii("ytical"),
    ],
    values: &[&["missing"], &["message"], &["mystical"]],
    range: 4..=6,
};

static WORD_MR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MR_CHILDREN),
    value: None,
};

pub static WORD_MR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("oe")],
    values: &[&["more"]],
    range: 2..=2,
};

static WORD_MP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MP_CHILDREN),
    value: None,
};

pub static WORD_MP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ort")],
    values: &[&["import"]],
    range: 3..=3,
};

static WORD_MO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_MO_CHILDREN),
    value: None,
};

static WORD_MO_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_MOA_NODE),
    Some(&WORD_MOB_NODE),
    Some(&WORD_MOC_NODE),
    Some(&WORD_MOD_NODE),
    Some(&WORD_MOE_NODE),
    Some(&WORD_MOF_NODE),
    None,
    Some(&WORD_MOH_NODE),
    Some(&WORD_MOI_NODE),
    None,
    None,
    Some(&WORD_MOL_NODE),
    Some(&WORD_MOM_NODE),
    Some(&WORD_MON_NODE),
    Some(&WORD_MOO_NODE),
    Some(&WORD_MOP_NODE),
    None,
    Some(&WORD_MOR_NODE),
    Some(&WORD_MOS_NODE),
    Some(&WORD_MOT_NODE),
    Some(&WORD_MOU_NODE),
    Some(&WORD_MOV_NODE),
    None,
    None,
    None,
    Some(&WORD_MOZ_NODE),
];

static WORD_MOZ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MOZ_CHILDREN),
    value: None,
};

pub static WORD_MOZ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("iila"),
        dictgen::InsensitiveStr::Ascii("ila"),
        dictgen::InsensitiveStr::Ascii("illia"),
        dictgen::InsensitiveStr::Ascii("illla"),
        dictgen::InsensitiveStr::Ascii("zaralla"),
        dictgen::InsensitiveStr::Ascii("zarela"),
        dictgen::InsensitiveStr::Ascii("zeralla"),
        dictgen::InsensitiveStr::Ascii("zilla"),
        dictgen::InsensitiveStr::Ascii("zorella"),
    ],
    values: &[
        &["mozilla"],
        &["mozilla"],
        &["mozilla"],
        &["mozilla"],
        &["mozzarella"],
        &["mozzarella"],
        &["mozzarella"],
        &["mozilla"],
        &["mozzarella"],
    ],
    range: 3..=7,
};

static WORD_MOV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MOV_CHILDREN),
    value: None,
};

pub static WORD_MOV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ebackwrd"),
        dictgen::InsensitiveStr::Ascii("eble"),
        dictgen::InsensitiveStr::Ascii("ei"),
        dictgen::InsensitiveStr::Ascii("emement"),
        dictgen::InsensitiveStr::Ascii("emements"),
        dictgen::InsensitiveStr::Ascii("ememnt"),
        dictgen::InsensitiveStr::Ascii("ememnts"),
        dictgen::InsensitiveStr::Ascii("ememt"),
        dictgen::InsensitiveStr::Ascii("ememts"),
        dictgen::InsensitiveStr::Ascii("emet"),
        dictgen::InsensitiveStr::Ascii("emets"),
        dictgen::InsensitiveStr::Ascii("emment"),
        dictgen::InsensitiveStr::Ascii("emments"),
        dictgen::InsensitiveStr::Ascii("emnet"),
        dictgen::InsensitiveStr::Ascii("emnets"),
        dictgen::InsensitiveStr::Ascii("emnt"),
        dictgen::InsensitiveStr::Ascii("emnts"),
        dictgen::InsensitiveStr::Ascii("epseed"),
        dictgen::InsensitiveStr::Ascii("esped"),
        dictgen::InsensitiveStr::Ascii("espeeed"),
        dictgen::InsensitiveStr::Ascii("ied"),
        dictgen::InsensitiveStr::Ascii("ment"),
    ],
    values: &[
        &["movebackward"],
        &["movable"],
        &["movie"],
        &["movement"],
        &["movements"],
        &["movement"],
        &["movements"],
        &["movement"],
        &["movements"],
        &["movement"],
        &["movements"],
        &["movement"],
        &["movements"],
        &["movement"],
        &["movements"],
        &["movement"],
        &["movements"],
        &["movespeed"],
        &["movespeed"],
        &["movespeed"],
        &["moved", "movie"],
        &["movement"],
    ],
    range: 2..=8,
};

static WORD_MOU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MOU_CHILDREN),
    value: None,
};

pub static WORD_MOU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("dle"),
        dictgen::InsensitiveStr::Ascii("dles"),
        dictgen::InsensitiveStr::Ascii("dule"),
        dictgen::InsensitiveStr::Ascii("dules"),
        dictgen::InsensitiveStr::Ascii("nment"),
        dictgen::InsensitiveStr::Ascii("npoint"),
        dictgen::InsensitiveStr::Ascii("nring"),
        dictgen::InsensitiveStr::Ascii("ntan"),
        dictgen::InsensitiveStr::Ascii("nth"),
        dictgen::InsensitiveStr::Ascii("nths"),
        dictgen::InsensitiveStr::Ascii("ntian"),
        dictgen::InsensitiveStr::Ascii("ntpiont"),
        dictgen::InsensitiveStr::Ascii("ntpionts"),
        dictgen::InsensitiveStr::Ascii("spointer"),
        dictgen::InsensitiveStr::Ascii("stace"),
        dictgen::InsensitiveStr::Ascii("stahce"),
        dictgen::InsensitiveStr::Ascii("sturizing"),
        dictgen::InsensitiveStr::Ascii("thpeace"),
        dictgen::InsensitiveStr::Ascii("thpeice"),
        dictgen::InsensitiveStr::Ascii("thpeices"),
        dictgen::InsensitiveStr::Ascii("tn"),
        dictgen::InsensitiveStr::Ascii("tned"),
        dictgen::InsensitiveStr::Ascii("tning"),
        dictgen::InsensitiveStr::Ascii("tnpoint"),
        dictgen::InsensitiveStr::Ascii("tnpoints"),
        dictgen::InsensitiveStr::Ascii("tns"),
        dictgen::InsensitiveStr::Ascii("vement"),
        dictgen::InsensitiveStr::Ascii("vements"),
    ],
    values: &[
        &["module"],
        &["modules"],
        &["module"],
        &["modules"],
        &["monument"],
        &["mountpoint"],
        &["mourning"],
        &["mountain"],
        &["month", "mouth"],
        &["months", "mouths"],
        &["mountain"],
        &["mountpoint"],
        &["mountpoints"],
        &["mousepointer"],
        &["moustache"],
        &["moustache"],
        &["moisturizing"],
        &["mouthpiece"],
        &["mouthpiece"],
        &["mouthpiece"],
        &["mount"],
        &["mounted"],
        &["mounting"],
        &["mountpoint"],
        &["mountpoints"],
        &["mounts"],
        &["movement"],
        &["movements"],
    ],
    range: 2..=9,
};

static WORD_MOT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MOT_CHILDREN),
    value: None,
};

pub static WORD_MOT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ation"),
        dictgen::InsensitiveStr::Ascii("eef"),
        dictgen::InsensitiveStr::Ascii("eefs"),
        dictgen::InsensitiveStr::Ascii("ehrboard"),
        dictgen::InsensitiveStr::Ascii("eur"),
        dictgen::InsensitiveStr::Ascii("eured"),
        dictgen::InsensitiveStr::Ascii("euring"),
        dictgen::InsensitiveStr::Ascii("eurs"),
        dictgen::InsensitiveStr::Ascii("hebroard"),
        dictgen::InsensitiveStr::Ascii("herbaord"),
        dictgen::InsensitiveStr::Ascii("herbaords"),
        dictgen::InsensitiveStr::Ascii("herbard"),
        dictgen::InsensitiveStr::Ascii("herboad"),
        dictgen::InsensitiveStr::Ascii("herboads"),
        dictgen::InsensitiveStr::Ascii("herboars"),
        dictgen::InsensitiveStr::Ascii("herborad"),
        dictgen::InsensitiveStr::Ascii("herborads"),
        dictgen::InsensitiveStr::Ascii("herbord"),
        dictgen::InsensitiveStr::Ascii("herbords"),
        dictgen::InsensitiveStr::Ascii("herobard"),
        dictgen::InsensitiveStr::Ascii("hing"),
        dictgen::InsensitiveStr::Ascii("hreboard"),
        dictgen::InsensitiveStr::Ascii("ivacional"),
        dictgen::InsensitiveStr::Ascii("ivaiton"),
        dictgen::InsensitiveStr::Ascii("ivatie"),
        dictgen::InsensitiveStr::Ascii("ivatin"),
        dictgen::InsensitiveStr::Ascii("ivatinal"),
        dictgen::InsensitiveStr::Ascii("ivationals"),
        dictgen::InsensitiveStr::Ascii("ivationnal"),
        dictgen::InsensitiveStr::Ascii("ivet"),
        dictgen::InsensitiveStr::Ascii("iviated"),
        dictgen::InsensitiveStr::Ascii("iviation"),
        dictgen::InsensitiveStr::Ascii("nage"),
        dictgen::InsensitiveStr::Ascii("ononic"),
        dictgen::InsensitiveStr::Ascii("oral"),
        dictgen::InsensitiveStr::Ascii("orcicle"),
        dictgen::InsensitiveStr::Ascii("orcicles"),
        dictgen::InsensitiveStr::Ascii("orcyce"),
        dictgen::InsensitiveStr::Ascii("orcylce"),
        dictgen::InsensitiveStr::Ascii("orcylces"),
        dictgen::InsensitiveStr::Ascii("orcyles"),
        dictgen::InsensitiveStr::Ascii("oroal"),
        dictgen::InsensitiveStr::Ascii("orolja"),
        dictgen::InsensitiveStr::Ascii("orollas"),
        dictgen::InsensitiveStr::Ascii("oroloa"),
        dictgen::InsensitiveStr::Ascii("ovational"),
    ],
    values: &[
        &["notation", "rotation", "motivation"],
        &["motif"],
        &["motifs"],
        &["motherboard"],
        &["motor"],
        &["motored"],
        &["motoring"],
        &["motors"],
        &["motherboards"],
        &["motherboard"],
        &["motherboards"],
        &["motherboard"],
        &["motherboard"],
        &["motherboards"],
        &["motherboards"],
        &["motherboard"],
        &["motherboards"],
        &["motherboard"],
        &["motherboards"],
        &["motherboards"],
        &["nothing"],
        &["motherboards"],
        &["motivational"],
        &["motivations", "motivation"],
        &["motivate"],
        &["motivations"],
        &["motivational"],
        &["motivations"],
        &["motivational"],
        &["motivate"],
        &["motivated"],
        &["motivation"],
        &["montage"],
        &["monotonic"],
        &["motorola"],
        &["motorcycle"],
        &["motorcycles"],
        &["motorcycles"],
        &["motorcycle"],
        &["motorcycles"],
        &["motorcycles"],
        &["motorola"],
        &["motorola"],
        &["motorola"],
        &["motorola"],
        &["motivational"],
    ],
    range: 3..=10,
};

static WORD_MOS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MOS_CHILDREN),
    value: None,
};

pub static WORD_MOS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("iturizer"),
        dictgen::InsensitiveStr::Ascii("iturizing"),
        dictgen::InsensitiveStr::Ascii("lty"),
        dictgen::InsensitiveStr::Ascii("nter"),
        dictgen::InsensitiveStr::Ascii("nters"),
        dictgen::InsensitiveStr::Ascii("ntrosity"),
        dictgen::InsensitiveStr::Ascii("queto"),
        dictgen::InsensitiveStr::Ascii("quite"),
        dictgen::InsensitiveStr::Ascii("quitero"),
        dictgen::InsensitiveStr::Ascii("quiters"),
        dictgen::InsensitiveStr::Ascii("quitto"),
        dictgen::InsensitiveStr::Ascii("qutio"),
        dictgen::InsensitiveStr::Ascii("tlky"),
        dictgen::InsensitiveStr::Ascii("ture"),
        dictgen::InsensitiveStr::Ascii("ty"),
        dictgen::InsensitiveStr::Ascii("ue"),
    ],
    values: &[
        &["more", "mouse", "mode"],
        &["moisturizer"],
        &["moisturizing"],
        &["mostly"],
        &["monster"],
        &["monsters"],
        &["monstrosity"],
        &["mosquitoes"],
        &["mosquitoes"],
        &["mosquito"],
        &["mosquitoes"],
        &["mosquito"],
        &["mosquito"],
        &["mostly"],
        &["moisture"],
        &["mostly"],
        &["mosque", "mouse"],
    ],
    range: 1..=9,
};

static WORD_MOR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MOR_CHILDREN),
    value: Some(&["more"]),
};

pub static WORD_MOR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("atlity"),
        dictgen::InsensitiveStr::Ascii("bidley"),
        dictgen::InsensitiveStr::Ascii("bidy"),
        dictgen::InsensitiveStr::Ascii("bildy"),
        dictgen::InsensitiveStr::Ascii("dern"),
        dictgen::InsensitiveStr::Ascii("dibly"),
        dictgen::InsensitiveStr::Ascii("eso"),
        dictgen::InsensitiveStr::Ascii("ever"),
        dictgen::InsensitiveStr::Ascii("evoer"),
        dictgen::InsensitiveStr::Ascii("g"),
        dictgen::InsensitiveStr::Ascii("gage"),
        dictgen::InsensitiveStr::Ascii("gatges"),
        dictgen::InsensitiveStr::Ascii("ges"),
        dictgen::InsensitiveStr::Ascii("gs"),
        dictgen::InsensitiveStr::Ascii("gtages"),
        dictgen::InsensitiveStr::Ascii("hpine"),
        dictgen::InsensitiveStr::Ascii("ibdly"),
        dictgen::InsensitiveStr::Ascii("isette"),
        dictgen::InsensitiveStr::Ascii("malise"),
        dictgen::InsensitiveStr::Ascii("malised"),
        dictgen::InsensitiveStr::Ascii("malises"),
        dictgen::InsensitiveStr::Ascii("malize"),
        dictgen::InsensitiveStr::Ascii("malized"),
        dictgen::InsensitiveStr::Ascii("malizes"),
        dictgen::InsensitiveStr::Ascii("mones"),
        dictgen::InsensitiveStr::Ascii("monisim"),
        dictgen::InsensitiveStr::Ascii("monsim"),
        dictgen::InsensitiveStr::Ascii("monts"),
        dictgen::InsensitiveStr::Ascii("oever"),
        dictgen::InsensitiveStr::Ascii("otola"),
        dictgen::InsensitiveStr::Ascii("phein"),
        dictgen::InsensitiveStr::Ascii("phen"),
        dictgen::InsensitiveStr::Ascii("phie"),
        dictgen::InsensitiveStr::Ascii("phinate"),
        dictgen::InsensitiveStr::Ascii("riosn"),
        dictgen::InsensitiveStr::Ascii("risette"),
        dictgen::InsensitiveStr::Ascii("risound"),
        dictgen::InsensitiveStr::Ascii("roccan"),
        dictgen::InsensitiveStr::Ascii("rocco"),
        dictgen::InsensitiveStr::Ascii("roco"),
        dictgen::InsensitiveStr::Ascii("rsion"),
        dictgen::InsensitiveStr::Ascii("tage"),
        dictgen::InsensitiveStr::Ascii("tailty"),
        dictgen::InsensitiveStr::Ascii("tards"),
        dictgen::InsensitiveStr::Ascii("tarts"),
        dictgen::InsensitiveStr::Ascii("ter"),
        dictgen::InsensitiveStr::Ascii("uning"),
    ],
    values: &[
        &["mortality"],
        &["morbidly"],
        &["morbidly"],
        &["morbidly"],
        &["modern"],
        &["morbidly"],
        &["more"],
        &["moreover"],
        &["moreover"],
        &["morgue"],
        &["mortgage"],
        &["mortgages"],
        &["morgues"],
        &["morgues"],
        &["mortgages"],
        &["morphine"],
        &["morbidly"],
        &["morissette"],
        &["normalise"],
        &["normalised"],
        &["normalises"],
        &["normalize"],
        &["normalized"],
        &["normalizes"],
        &["mormons"],
        &["mormonism"],
        &["mormonism"],
        &["mormons"],
        &["moreover"],
        &["motorola"],
        &["morphine"],
        &["morphine"],
        &["morphine"],
        &["morphine"],
        &["morrison"],
        &["morissette"],
        &["morrison"],
        &["moroccan"],
        &["morocco"],
        &["morocco"],
        &["morrison"],
        &["mortgage"],
        &["mortality"],
        &["mortars"],
        &["mortars"],
        &["mortar"],
        &["mourning"],
    ],
    range: 1..=7,
};

static WORD_MOP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MOP_CHILDREN),
    value: None,
};

pub static WORD_MOP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("dule"),
        dictgen::InsensitiveStr::Ascii("re"),
        dictgen::InsensitiveStr::Ascii("rhine"),
    ],
    values: &[&["module"], &["more"], &["morphine"]],
    range: 2..=5,
};

static WORD_MOO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MOO_CHILDREN),
    value: None,
};

pub static WORD_MOO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("dify"),
        dictgen::InsensitiveStr::Ascii("nligt"),
        dictgen::InsensitiveStr::Ascii("unting"),
    ],
    values: &[&["modify"], &["moonlight"], &["mounting"]],
    range: 4..=6,
};

static WORD_MON_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_MON_CHILDREN),
    value: None,
};

static WORD_MON_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_MONA_NODE),
    None,
    None,
    Some(&WORD_MOND_NODE),
    Some(&WORD_MONE_NODE),
    None,
    Some(&WORD_MONG_NODE),
    None,
    Some(&WORD_MONI_NODE),
    None,
    Some(&WORD_MONK_NODE),
    None,
    None,
    Some(&WORD_MONN_NODE),
    Some(&WORD_MONO_NODE),
    None,
    None,
    Some(&WORD_MONR_NODE),
    Some(&WORD_MONS_NODE),
    Some(&WORD_MONT_NODE),
    Some(&WORD_MONU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_MONU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MONU_CHILDREN),
    value: None,
};

pub static WORD_MONU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("mentaal"),
        dictgen::InsensitiveStr::Ascii("mentais"),
        dictgen::InsensitiveStr::Ascii("mentals"),
        dictgen::InsensitiveStr::Ascii("mentos"),
        dictgen::InsensitiveStr::Ascii("mentous"),
        dictgen::InsensitiveStr::Ascii("mentul"),
        dictgen::InsensitiveStr::Ascii("mentus"),
        dictgen::InsensitiveStr::Ascii("met"),
        dictgen::InsensitiveStr::Ascii("mnet"),
        dictgen::InsensitiveStr::Ascii("mnets"),
    ],
    values: &[
        &["monumental"],
        &["monuments"],
        &["monuments"],
        &["monuments"],
        &["monuments"],
        &["monumental"],
        &["monuments"],
        &["monument"],
        &["monument"],
        &["monuments"],
    ],
    range: 3..=7,
};

static WORD_MONT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MONT_CHILDREN),
    value: None,
};

pub static WORD_MONT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aban"),
        dictgen::InsensitiveStr::Ascii("aeg"),
        dictgen::InsensitiveStr::Ascii("ains"),
        dictgen::InsensitiveStr::Ascii("aj"),
        dictgen::InsensitiveStr::Ascii("ajes"),
        dictgen::InsensitiveStr::Ascii("anha"),
        dictgen::InsensitiveStr::Ascii("ania"),
        dictgen::InsensitiveStr::Ascii("anna"),
        dictgen::InsensitiveStr::Ascii("anous"),
        dictgen::InsensitiveStr::Ascii("anta"),
        dictgen::InsensitiveStr::Ascii("anya"),
        dictgen::InsensitiveStr::Ascii("aran"),
        dictgen::InsensitiveStr::Ascii("eize"),
        dictgen::InsensitiveStr::Ascii("eral"),
        dictgen::InsensitiveStr::Ascii("he"),
        dictgen::InsensitiveStr::Ascii("hes"),
        dictgen::InsensitiveStr::Ascii("ioring"),
        dictgen::InsensitiveStr::Ascii("iors"),
        dictgen::InsensitiveStr::Ascii("ly"),
        dictgen::InsensitiveStr::Ascii("nana"),
        dictgen::InsensitiveStr::Ascii("rel"),
        dictgen::InsensitiveStr::Ascii("s"),
        dictgen::InsensitiveStr::Ascii("ypic"),
    ],
    values: &[
        &["montana"],
        &["montage"],
        &["mountains"],
        &["montage"],
        &["montages"],
        &["montana"],
        &["montana"],
        &["montana"],
        &["mountainous"],
        &["montana"],
        &["montana"],
        &["montana"],
        &["monetize"],
        &["montreal"],
        &["month"],
        &["months"],
        &["monitoring"],
        &["monitors"],
        &["monthly"],
        &["montana"],
        &["montreal"],
        &["months"],
        &["monotypic"],
    ],
    range: 1..=6,
};

static WORD_MONS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MONS_CHILDREN),
    value: None,
};

pub static WORD_MONS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("day"),
        dictgen::InsensitiveStr::Ascii("errat"),
        dictgen::InsensitiveStr::Ascii("terous"),
        dictgen::InsensitiveStr::Ascii("torsity"),
        dictgen::InsensitiveStr::Ascii("torus"),
        dictgen::InsensitiveStr::Ascii("trasity"),
        dictgen::InsensitiveStr::Ascii("tre"),
        dictgen::InsensitiveStr::Ascii("trisity"),
        dictgen::InsensitiveStr::Ascii("trocity"),
        dictgen::InsensitiveStr::Ascii("tros"),
        dictgen::InsensitiveStr::Ascii("trosoty"),
        dictgen::InsensitiveStr::Ascii("trostiy"),
        dictgen::InsensitiveStr::Ascii("trum"),
        dictgen::InsensitiveStr::Ascii("truos"),
    ],
    values: &[
        &["monday"],
        &["montserrat"],
        &["monsters"],
        &["monstrosity"],
        &["monstrous"],
        &["monstrosity"],
        &["monster"],
        &["monstrosity"],
        &["monstrosity"],
        &["monstrous"],
        &["monstrosity"],
        &["monstrosity"],
        &["monster"],
        &["monstrous"],
    ],
    range: 3..=7,
};

static WORD_MONR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MONR_CHILDREN),
    value: None,
};

pub static WORD_MONR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("achy")],
    values: &[&["monarchy"]],
    range: 4..=4,
};

static WORD_MONO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MONO_CHILDREN),
    value: None,
};

pub static WORD_MONO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("chorome"),
        dictgen::InsensitiveStr::Ascii("chromo"),
        dictgen::InsensitiveStr::Ascii("crome"),
        dictgen::InsensitiveStr::Ascii("gameous"),
        dictgen::InsensitiveStr::Ascii("gmay"),
        dictgen::InsensitiveStr::Ascii("gymous"),
        dictgen::InsensitiveStr::Ascii("lgoue"),
        dictgen::InsensitiveStr::Ascii("light"),
        dictgen::InsensitiveStr::Ascii("listic"),
        dictgen::InsensitiveStr::Ascii("lite"),
        dictgen::InsensitiveStr::Ascii("lithisch"),
        dictgen::InsensitiveStr::Ascii("litich"),
        dictgen::InsensitiveStr::Ascii("litihic"),
        dictgen::InsensitiveStr::Ascii("loge"),
        dictgen::InsensitiveStr::Ascii("lopies"),
        dictgen::InsensitiveStr::Ascii("lopy"),
        dictgen::InsensitiveStr::Ascii("lothic"),
        dictgen::InsensitiveStr::Ascii("louge"),
        dictgen::InsensitiveStr::Ascii("lythic"),
        dictgen::InsensitiveStr::Ascii("morpize"),
        dictgen::InsensitiveStr::Ascii("ntonicity"),
        dictgen::InsensitiveStr::Ascii("pace"),
        dictgen::InsensitiveStr::Ascii("pilies"),
        dictgen::InsensitiveStr::Ascii("ploies"),
        dictgen::InsensitiveStr::Ascii("ploy"),
        dictgen::InsensitiveStr::Ascii("polets"),
        dictgen::InsensitiveStr::Ascii("police"),
        dictgen::InsensitiveStr::Ascii("polios"),
        dictgen::InsensitiveStr::Ascii("polis"),
        dictgen::InsensitiveStr::Ascii("pollies"),
        dictgen::InsensitiveStr::Ascii("polly"),
        dictgen::InsensitiveStr::Ascii("poloy"),
        dictgen::InsensitiveStr::Ascii("pols"),
        dictgen::InsensitiveStr::Ascii("thilic"),
        dictgen::InsensitiveStr::Ascii("tir"),
        dictgen::InsensitiveStr::Ascii("tired"),
        dictgen::InsensitiveStr::Ascii("tiring"),
        dictgen::InsensitiveStr::Ascii("tirs"),
    ],
    values: &[
        &["monochrome"],
        &["monochrome"],
        &["monochrome"],
        &["monogamous"],
        &["monogamy"],
        &["monogamous"],
        &["monologue"],
        &["moonlight"],
        &["monolithic"],
        &["monolithic"],
        &["monolithic"],
        &["monolithic"],
        &["monolithic"],
        &["monologue"],
        &["monopolies"],
        &["monopoly"],
        &["monolithic"],
        &["monologue"],
        &["monolithic"],
        &["monomorphize"],
        &["monotonicity"],
        &["monospace"],
        &["monopolies"],
        &["monopolies"],
        &["monopoly"],
        &["monopolies"],
        &["monopolies"],
        &["monopolies"],
        &["monopolies"],
        &["monopolies"],
        &["monopoly"],
        &["monopoly"],
        &["monopolies"],
        &["monolithic"],
        &["monitor"],
        &["monitored"],
        &["monitoring"],
        &["monitors"],
    ],
    range: 3..=9,
};

static WORD_MONN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MONN_CHILDREN),
    value: None,
};

pub static WORD_MONN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("th"),
        dictgen::InsensitiveStr::Ascii("ths"),
    ],
    values: &[&["month"], &["months"]],
    range: 2..=3,
};

static WORD_MONK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MONK_CHILDREN),
    value: None,
};

pub static WORD_MONK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ies")],
    values: &[&["monkeys"]],
    range: 3..=3,
};

static WORD_MONI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MONI_CHILDREN),
    value: None,
};

pub static WORD_MONI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("tary"),
        dictgen::InsensitiveStr::Ascii("ter"),
        dictgen::InsensitiveStr::Ascii("tering"),
        dictgen::InsensitiveStr::Ascii("toing"),
        dictgen::InsensitiveStr::Ascii("tord"),
        dictgen::InsensitiveStr::Ascii("toreada"),
        dictgen::InsensitiveStr::Ascii("toreado"),
        dictgen::InsensitiveStr::Ascii("tores"),
        dictgen::InsensitiveStr::Ascii("tos"),
        dictgen::InsensitiveStr::Ascii("tring"),
    ],
    values: &[
        &["monetary"],
        &["monitor"],
        &["monitoring"],
        &["monitoring"],
        &["monitored"],
        &["monitored"],
        &["monitored"],
        &["monitors"],
        &["monitors"],
        &["monitoring"],
    ],
    range: 3..=7,
};

static WORD_MONG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MONG_CHILDREN),
    value: None,
};

pub static WORD_MONG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("los"),
        dictgen::InsensitiveStr::Ascii("oles"),
        dictgen::InsensitiveStr::Ascii("olos"),
    ],
    values: &[&["mongols"], &["mongols"], &["mongols"]],
    range: 3..=4,
};

static WORD_MONE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MONE_CHILDREN),
    value: Some(&["mono", "money", "none"]),
};

pub static WORD_MONE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("staries"),
        dictgen::InsensitiveStr::Ascii("stary"),
        dictgen::InsensitiveStr::Ascii("stic"),
        dictgen::InsensitiveStr::Ascii("tizare"),
    ],
    values: &[
        &["monasteries"],
        &["monastery", "monetary"],
        &["monastic"],
        &["monetize"],
    ],
    range: 4..=7,
};

static WORD_MOND_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MOND_CHILDREN),
    value: None,
};

pub static WORD_MOND_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ey")],
    values: &[&["monday", "money", "monkey"]],
    range: 2..=2,
};

static WORD_MONA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MONA_CHILDREN),
    value: None,
};

pub static WORD_MONA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("gomous"),
        dictgen::InsensitiveStr::Ascii("gomy"),
        dictgen::InsensitiveStr::Ascii("rcy"),
        dictgen::InsensitiveStr::Ascii("rkey"),
        dictgen::InsensitiveStr::Ascii("rkeys"),
        dictgen::InsensitiveStr::Ascii("rkies"),
        dictgen::InsensitiveStr::Ascii("tge"),
    ],
    values: &[
        &["monogamous"],
        &["monogamy"],
        &["monarchy"],
        &["monarchy"],
        &["monarchies"],
        &["monarchies"],
        &["montage"],
    ],
    range: 3..=6,
};

static WORD_MOM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MOM_CHILDREN),
    value: None,
};

pub static WORD_MOM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ement"),
        dictgen::InsensitiveStr::Ascii("ementarily"),
        dictgen::InsensitiveStr::Ascii("ements"),
        dictgen::InsensitiveStr::Ascii("emtarily"),
        dictgen::InsensitiveStr::Ascii("emtary"),
        dictgen::InsensitiveStr::Ascii("emtn"),
        dictgen::InsensitiveStr::Ascii("entairly"),
        dictgen::InsensitiveStr::Ascii("entaraly"),
        dictgen::InsensitiveStr::Ascii("entarely"),
        dictgen::InsensitiveStr::Ascii("entarilly"),
        dictgen::InsensitiveStr::Ascii("entarly"),
        dictgen::InsensitiveStr::Ascii("enterily"),
        dictgen::InsensitiveStr::Ascii("ento"),
        dictgen::InsensitiveStr::Ascii("entos"),
        dictgen::InsensitiveStr::Ascii("entus"),
        dictgen::InsensitiveStr::Ascii("ery"),
        dictgen::InsensitiveStr::Ascii("ment"),
        dictgen::InsensitiveStr::Ascii("oent"),
        dictgen::InsensitiveStr::Ascii("oment"),
        dictgen::InsensitiveStr::Ascii("omentarily"),
        dictgen::InsensitiveStr::Ascii("omento"),
        dictgen::InsensitiveStr::Ascii("omentos"),
        dictgen::InsensitiveStr::Ascii("oments"),
        dictgen::InsensitiveStr::Ascii("ory"),
    ],
    values: &[
        &["moment"],
        &["momentarily"],
        &["moments"],
        &["momentarily"],
        &["momentary"],
        &["moment"],
        &["momentarily"],
        &["momentarily"],
        &["momentarily"],
        &["momentarily"],
        &["momentarily"],
        &["momentarily"],
        &["memento"],
        &["moments"],
        &["moments"],
        &["memory"],
        &["moment"],
        &["moment"],
        &["moment"],
        &["momentarily"],
        &["memento", "moment"],
        &["mementos", "moments"],
        &["moments"],
        &["memory"],
    ],
    range: 3..=10,
};

static WORD_MOL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MOL_CHILDREN),
    value: None,
};

pub static WORD_MOL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eclues"),
        dictgen::InsensitiveStr::Ascii("eculair"),
        dictgen::InsensitiveStr::Ascii("eculaire"),
        dictgen::InsensitiveStr::Ascii("eculs"),
        dictgen::InsensitiveStr::Ascii("estaion"),
        dictgen::InsensitiveStr::Ascii("estare"),
        dictgen::InsensitiveStr::Ascii("estarle"),
        dictgen::InsensitiveStr::Ascii("estarme"),
        dictgen::InsensitiveStr::Ascii("estarse"),
        dictgen::InsensitiveStr::Ascii("estarte"),
        dictgen::InsensitiveStr::Ascii("estating"),
        dictgen::InsensitiveStr::Ascii("estato"),
        dictgen::InsensitiveStr::Ascii("esterd"),
        dictgen::InsensitiveStr::Ascii("estered"),
        dictgen::InsensitiveStr::Ascii("eststion"),
    ],
    values: &[
        &["molecules"],
        &["molecular"],
        &["molecular"],
        &["molecules"],
        &["molestation"],
        &["molester"],
        &["molester"],
        &["molester"],
        &["molester"],
        &["molester"],
        &["molestation"],
        &["molestation"],
        &["molested"],
        &["molested"],
        &["molestation"],
    ],
    range: 5..=8,
};

static WORD_MOI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MOI_CHILDREN),
    value: None,
};

pub static WORD_MOI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ble"),
        dictgen::InsensitiveStr::Ascii("bles"),
        dictgen::InsensitiveStr::Ascii("nt"),
        dictgen::InsensitiveStr::Ascii("ntor"),
        dictgen::InsensitiveStr::Ascii("ntored"),
        dictgen::InsensitiveStr::Ascii("ntoring"),
        dictgen::InsensitiveStr::Ascii("ntors"),
        dictgen::InsensitiveStr::Ascii("sterizer"),
        dictgen::InsensitiveStr::Ascii("sterizing"),
        dictgen::InsensitiveStr::Ascii("storizing"),
        dictgen::InsensitiveStr::Ascii("struizer"),
        dictgen::InsensitiveStr::Ascii("sturier"),
        dictgen::InsensitiveStr::Ascii("sturizng"),
        dictgen::InsensitiveStr::Ascii("sturizor"),
        dictgen::InsensitiveStr::Ascii("stutizer"),
        dictgen::InsensitiveStr::Ascii("sutrizer"),
        dictgen::InsensitiveStr::Ascii("sutrizing"),
    ],
    values: &[
        &["mobile"],
        &["mobiles"],
        &["mount"],
        &["monitor"],
        &["monitored"],
        &["monitoring"],
        &["monitors"],
        &["moisturizer"],
        &["moisturizing"],
        &["moisturizing"],
        &["moisturizer"],
        &["moisturizer"],
        &["moisturizing"],
        &["moisturizer"],
        &["moisturizer"],
        &["moisturizer"],
        &["moisturizing"],
    ],
    range: 2..=9,
};

static WORD_MOH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MOH_CHILDREN),
    value: None,
};

pub static WORD_MOH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ammedan"),
        dictgen::InsensitiveStr::Ascii("ammedans"),
    ],
    values: &[&["muslim"], &["muslims"]],
    range: 7..=8,
};

static WORD_MOF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MOF_CHILDREN),
    value: None,
};

pub static WORD_MOF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("dified"),
        dictgen::InsensitiveStr::Ascii("ification"),
        dictgen::InsensitiveStr::Ascii("ified"),
        dictgen::InsensitiveStr::Ascii("ifies"),
        dictgen::InsensitiveStr::Ascii("ify"),
    ],
    values: &[
        &["modified"],
        &["modification"],
        &["modified"],
        &["modifies"],
        &["modify"],
    ],
    range: 3..=9,
};

static WORD_MOE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MOE_CHILDREN),
    value: None,
};

pub static WORD_MOE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("lcules"),
        dictgen::InsensitiveStr::Ascii("nt"),
        dictgen::InsensitiveStr::Ascii("ny"),
        dictgen::InsensitiveStr::Ascii("r"),
        dictgen::InsensitiveStr::Ascii("w"),
    ],
    values: &[
        &["molecules"],
        &["moment"],
        &["money"],
        &["more"],
        &["meow", "more", "mow"],
    ],
    range: 1..=6,
};

static WORD_MOD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_MOD_CHILDREN),
    value: None,
};

static WORD_MOD_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    None,
    Some(&WORD_MODD_NODE),
    Some(&WORD_MODE_NODE),
    Some(&WORD_MODF_NODE),
    None,
    None,
    Some(&WORD_MODI_NODE),
    None,
    None,
    Some(&WORD_MODL_NODE),
    None,
    None,
    None,
    Some(&WORD_MODP_NODE),
    None,
    None,
    None,
    Some(&WORD_MODT_NODE),
    Some(&WORD_MODU_NODE),
    None,
    None,
    None,
    Some(&WORD_MODY_NODE),
    None,
];

static WORD_MODY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MODY_CHILDREN),
    value: None,
};

pub static WORD_MODY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("fy")],
    values: &[&["modify"]],
    range: 2..=2,
};

static WORD_MODU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MODU_CHILDREN),
    value: None,
};

pub static WORD_MODU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("alr"),
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("el"),
        dictgen::InsensitiveStr::Ascii("els"),
        dictgen::InsensitiveStr::Ascii("ile"),
        dictgen::InsensitiveStr::Ascii("kles"),
        dictgen::InsensitiveStr::Ascii("l"),
        dictgen::InsensitiveStr::Ascii("lair"),
        dictgen::InsensitiveStr::Ascii("less"),
        dictgen::InsensitiveStr::Ascii("lie"),
        dictgen::InsensitiveStr::Ascii("lu"),
        dictgen::InsensitiveStr::Ascii("lues"),
    ],
    values: &[
        &["modular"],
        &["module"],
        &["module"],
        &["modules"],
        &["module"],
        &["modules"],
        &["module"],
        &["modular"],
        &["modules"],
        &["module"],
        &["modulo"],
        &["modules"],
    ],
    range: 1..=4,
};

static WORD_MODT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MODT_CHILDREN),
    value: None,
};

pub static WORD_MODT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ified")],
    values: &[&["modified"]],
    range: 5..=5,
};

static WORD_MODP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MODP_CHILDREN),
    value: None,
};

pub static WORD_MODP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("robbing"),
        dictgen::InsensitiveStr::Ascii("robeing"),
    ],
    values: &[&["modprobing"], &["modprobing"]],
    range: 7..=7,
};

static WORD_MODL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MODL_CHILDREN),
    value: None,
};

pub static WORD_MODL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("ue"),
        dictgen::InsensitiveStr::Ascii("ues"),
    ],
    values: &[
        &["model", "module"],
        &["models", "modules"],
        &["module"],
        &["modules"],
    ],
    range: 1..=3,
};

static WORD_MODI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_MODI_CHILDREN),
    value: None,
};

static WORD_MODI_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    Some(&WORD_MODIC_NODE),
    Some(&WORD_MODID_NODE),
    None,
    Some(&WORD_MODIF_NODE),
    None,
    None,
    Some(&WORD_MODII_NODE),
    None,
    None,
    Some(&WORD_MODIL_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_MODIR_NODE),
    None,
    None,
    None,
    Some(&WORD_MODIV_NODE),
    None,
    None,
    None,
    None,
];

static WORD_MODIV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MODIV_CHILDREN),
    value: None,
};

pub static WORD_MODIV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ational")],
    values: &[&["motivational"]],
    range: 7..=7,
};

static WORD_MODIR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MODIR_CHILDREN),
    value: None,
};

pub static WORD_MODIR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ation")],
    values: &[&["moderation"]],
    range: 5..=5,
};

static WORD_MODIL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MODIL_CHILDREN),
    value: None,
};

pub static WORD_MODIL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("es"),
    ],
    values: &[&["mobile", "module"], &["mobiles", "modules"]],
    range: 1..=2,
};

static WORD_MODII_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MODII_CHILDREN),
    value: None,
};

pub static WORD_MODII_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("fier"),
        dictgen::InsensitiveStr::Ascii("fiers"),
    ],
    values: &[&["modifier"], &["modifiers"]],
    range: 4..=5,
};

static WORD_MODIF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MODIF_CHILDREN),
    value: None,
};

pub static WORD_MODIF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("able"),
        dictgen::InsensitiveStr::Ascii("action"),
        dictgen::InsensitiveStr::Ascii("actions"),
        dictgen::InsensitiveStr::Ascii("ation"),
        dictgen::InsensitiveStr::Ascii("ations"),
        dictgen::InsensitiveStr::Ascii("cation"),
        dictgen::InsensitiveStr::Ascii("cations"),
        dictgen::InsensitiveStr::Ascii("ciation"),
        dictgen::InsensitiveStr::Ascii("ciations"),
        dictgen::InsensitiveStr::Ascii("cication"),
        dictgen::InsensitiveStr::Ascii("cications"),
        dictgen::InsensitiveStr::Ascii("died"),
        dictgen::InsensitiveStr::Ascii("dy"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("er"),
        dictgen::InsensitiveStr::Ascii("ers"),
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("fer"),
        dictgen::InsensitiveStr::Ascii("fers"),
        dictgen::InsensitiveStr::Ascii("iation"),
        dictgen::InsensitiveStr::Ascii("iations"),
        dictgen::InsensitiveStr::Ascii("icacion"),
        dictgen::InsensitiveStr::Ascii("icaiton"),
        dictgen::InsensitiveStr::Ascii("icaitons"),
        dictgen::InsensitiveStr::Ascii("icatioon"),
        dictgen::InsensitiveStr::Ascii("icatioons"),
        dictgen::InsensitiveStr::Ascii("icato"),
        dictgen::InsensitiveStr::Ascii("icaton"),
        dictgen::InsensitiveStr::Ascii("icatons"),
        dictgen::InsensitiveStr::Ascii("id"),
        dictgen::InsensitiveStr::Ascii("ieras"),
        dictgen::InsensitiveStr::Ascii("ieres"),
        dictgen::InsensitiveStr::Ascii("ified"),
        dictgen::InsensitiveStr::Ascii("ify"),
        dictgen::InsensitiveStr::Ascii("ikation"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("ires"),
        dictgen::InsensitiveStr::Ascii("iy"),
        dictgen::InsensitiveStr::Ascii("iying"),
        dictgen::InsensitiveStr::Ascii("iyng"),
        dictgen::InsensitiveStr::Ascii("led"),
        dictgen::InsensitiveStr::Ascii("ler"),
        dictgen::InsensitiveStr::Ascii("lers"),
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("ty"),
        dictgen::InsensitiveStr::Ascii("u"),
        dictgen::InsensitiveStr::Ascii("uable"),
        dictgen::InsensitiveStr::Ascii("ued"),
        dictgen::InsensitiveStr::Ascii("x"),
        dictgen::InsensitiveStr::Ascii("yable"),
        dictgen::InsensitiveStr::Ascii("yed"),
        dictgen::InsensitiveStr::Ascii("yer"),
        dictgen::InsensitiveStr::Ascii("yers"),
        dictgen::InsensitiveStr::Ascii("yes"),
    ],
    values: &[
        &["modifiable"],
        &["modification"],
        &["modifications"],
        &["modification"],
        &["modifications"],
        &["modification"],
        &["modifications"],
        &["modification"],
        &["modifications"],
        &["modification"],
        &["modifications"],
        &["modified"],
        &["modify"],
        &["modified"],
        &["modifier"],
        &["modifiers"],
        &["modifies"],
        &["modifier"],
        &["modifiers"],
        &["modification"],
        &["modifications"],
        &["modification"],
        &["modification"],
        &["modifications"],
        &["modification"],
        &["modifications"],
        &["modification"],
        &["modification"],
        &["modifications"],
        &["modified"],
        &["modifiers"],
        &["modifiers"],
        &["modified"],
        &["modify"],
        &["modification"],
        &["modifying"],
        &["modifiers"],
        &["modify"],
        &["modifying"],
        &["modifying"],
        &["modified"],
        &["modifier"],
        &["modifiers"],
        &["modify"],
        &["modify"],
        &["modify"],
        &["modifiable"],
        &["modified"],
        &["modify"],
        &["modifiable"],
        &["modified"],
        &["modifier"],
        &["modifiers"],
        &["modifies"],
    ],
    range: 1..=9,
};

static WORD_MODID_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MODID_CHILDREN),
    value: None,
};

pub static WORD_MODID_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("fication"),
        dictgen::InsensitiveStr::Ascii("fications"),
        dictgen::InsensitiveStr::Ascii("fied"),
        dictgen::InsensitiveStr::Ascii("fier"),
        dictgen::InsensitiveStr::Ascii("fiers"),
        dictgen::InsensitiveStr::Ascii("fies"),
        dictgen::InsensitiveStr::Ascii("fy"),
        dictgen::InsensitiveStr::Ascii("fying"),
    ],
    values: &[
        &["modification"],
        &["modifications"],
        &["modified"],
        &["modifier"],
        &["modifiers"],
        &["modifies"],
        &["modify"],
        &["modifying"],
    ],
    range: 2..=9,
};

static WORD_MODIC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MODIC_CHILDREN),
    value: None,
};

pub static WORD_MODIC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ations")],
    values: &[&["modifications"]],
    range: 6..=6,
};

static WORD_MODF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MODF_CHILDREN),
    value: None,
};

pub static WORD_MODF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("el"),
        dictgen::InsensitiveStr::Ascii("iable"),
        dictgen::InsensitiveStr::Ascii("ication"),
        dictgen::InsensitiveStr::Ascii("ications"),
        dictgen::InsensitiveStr::Ascii("ide"),
        dictgen::InsensitiveStr::Ascii("ided"),
        dictgen::InsensitiveStr::Ascii("ider"),
        dictgen::InsensitiveStr::Ascii("iders"),
        dictgen::InsensitiveStr::Ascii("ides"),
        dictgen::InsensitiveStr::Ascii("ied"),
        dictgen::InsensitiveStr::Ascii("ieid"),
        dictgen::InsensitiveStr::Ascii("ieir"),
        dictgen::InsensitiveStr::Ascii("ieirs"),
        dictgen::InsensitiveStr::Ascii("ieis"),
        dictgen::InsensitiveStr::Ascii("ier"),
        dictgen::InsensitiveStr::Ascii("iers"),
        dictgen::InsensitiveStr::Ascii("ies"),
        dictgen::InsensitiveStr::Ascii("ifiable"),
        dictgen::InsensitiveStr::Ascii("ification"),
        dictgen::InsensitiveStr::Ascii("ifications"),
        dictgen::InsensitiveStr::Ascii("ified"),
        dictgen::InsensitiveStr::Ascii("ifier"),
        dictgen::InsensitiveStr::Ascii("ifiers"),
        dictgen::InsensitiveStr::Ascii("ifies"),
        dictgen::InsensitiveStr::Ascii("ify"),
        dictgen::InsensitiveStr::Ascii("ifying"),
        dictgen::InsensitiveStr::Ascii("iiable"),
        dictgen::InsensitiveStr::Ascii("iication"),
        dictgen::InsensitiveStr::Ascii("iications"),
        dictgen::InsensitiveStr::Ascii("itied"),
        dictgen::InsensitiveStr::Ascii("itier"),
        dictgen::InsensitiveStr::Ascii("itiers"),
        dictgen::InsensitiveStr::Ascii("ities"),
        dictgen::InsensitiveStr::Ascii("ity"),
        dictgen::InsensitiveStr::Ascii("itying"),
        dictgen::InsensitiveStr::Ascii("iy"),
        dictgen::InsensitiveStr::Ascii("iying"),
        dictgen::InsensitiveStr::Ascii("y"),
        dictgen::InsensitiveStr::Ascii("ying"),
    ],
    values: &[
        &["model"],
        &["modifiable"],
        &["modification"],
        &["modifications"],
        &["modified"],
        &["modified"],
        &["modifier"],
        &["modifiers"],
        &["modifies"],
        &["modified"],
        &["modified"],
        &["modifier"],
        &["modifiers"],
        &["modifies"],
        &["modifier"],
        &["modifiers"],
        &["modifies"],
        &["modifiable"],
        &["modification"],
        &["modifications"],
        &["modified"],
        &["modifier"],
        &["modifiers"],
        &["modifies"],
        &["modify"],
        &["modifying"],
        &["modifiable"],
        &["modification"],
        &["modifications"],
        &["modified"],
        &["modifier"],
        &["modifiers"],
        &["modifies"],
        &["modify"],
        &["modifying"],
        &["modify"],
        &["modifying"],
        &["modify"],
        &["modifying"],
    ],
    range: 1..=10,
};

static WORD_MODE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MODE_CHILDREN),
    value: None,
};

pub static WORD_MODE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("linng"),
        dictgen::InsensitiveStr::Ascii("ll"),
        dictgen::InsensitiveStr::Ascii("llinng"),
        dictgen::InsensitiveStr::Ascii("racion"),
        dictgen::InsensitiveStr::Ascii("ratedly"),
        dictgen::InsensitiveStr::Ascii("raters"),
        dictgen::InsensitiveStr::Ascii("rateurs"),
        dictgen::InsensitiveStr::Ascii("ratey"),
        dictgen::InsensitiveStr::Ascii("ratin"),
        dictgen::InsensitiveStr::Ascii("ratley"),
        dictgen::InsensitiveStr::Ascii("ratore"),
        dictgen::InsensitiveStr::Ascii("ratorin"),
        dictgen::InsensitiveStr::Ascii("ratorn"),
        dictgen::InsensitiveStr::Ascii("rats"),
        dictgen::InsensitiveStr::Ascii("rm"),
        dictgen::InsensitiveStr::Ascii("rnination"),
        dictgen::InsensitiveStr::Ascii("rninations"),
        dictgen::InsensitiveStr::Ascii("rninationz"),
        dictgen::InsensitiveStr::Ascii("rnizationz"),
        dictgen::InsensitiveStr::Ascii("settting"),
        dictgen::InsensitiveStr::Ascii("ul"),
        dictgen::InsensitiveStr::Ascii("uls"),
    ],
    values: &[
        &["mode"],
        &["modeling"],
        &["model"],
        &["modelling"],
        &["moderation"],
        &["moderately"],
        &["moderates"],
        &["moderates"],
        &["moderately"],
        &["moderation"],
        &["moderately"],
        &["moderate"],
        &["moderation"],
        &["moderation"],
        &["moderates"],
        &["modem", "modern"],
        &["modernization"],
        &["modernizations"],
        &["modernizations"],
        &["modernizations"],
        &["modesetting"],
        &["module"],
        &["modules"],
    ],
    range: 1..=10,
};

static WORD_MODD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MODD_CHILDREN),
    value: None,
};

pub static WORD_MODD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("el"),
        dictgen::InsensitiveStr::Ascii("eled"),
        dictgen::InsensitiveStr::Ascii("elled"),
        dictgen::InsensitiveStr::Ascii("els"),
    ],
    values: &[&["model"], &["modeled"], &["modelled"], &["models"]],
    range: 2..=5,
};

static WORD_MOC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MOC_CHILDREN),
    value: None,
};

pub static WORD_MOC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("rochip"),
        dictgen::InsensitiveStr::Ascii("rochips"),
        dictgen::InsensitiveStr::Ascii("rocode"),
        dictgen::InsensitiveStr::Ascii("rocodes"),
        dictgen::InsensitiveStr::Ascii("rocontroller"),
        dictgen::InsensitiveStr::Ascii("rocontrollers"),
        dictgen::InsensitiveStr::Ascii("rophone"),
        dictgen::InsensitiveStr::Ascii("rophones"),
        dictgen::InsensitiveStr::Ascii("roprocessor"),
        dictgen::InsensitiveStr::Ascii("roprocessors"),
        dictgen::InsensitiveStr::Ascii("rosecond"),
        dictgen::InsensitiveStr::Ascii("roseconds"),
        dictgen::InsensitiveStr::Ascii("rosoft"),
        dictgen::InsensitiveStr::Ascii("rotransactions"),
        dictgen::InsensitiveStr::Ascii("ule"),
        dictgen::InsensitiveStr::Ascii("ules"),
    ],
    values: &[
        &["microchip"],
        &["microchips"],
        &["microcode"],
        &["microcodes"],
        &["microcontroller"],
        &["microcontrollers"],
        &["microphone"],
        &["microphones"],
        &["microprocessor"],
        &["microprocessors"],
        &["microsecond"],
        &["microseconds"],
        &["microsoft"],
        &["microtransactions"],
        &["module"],
        &["modules"],
    ],
    range: 3..=14,
};

static WORD_MOB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MOB_CHILDREN),
    value: None,
};

pub static WORD_MOB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ify"),
        dictgen::InsensitiveStr::Ascii("ilitiy"),
        dictgen::InsensitiveStr::Ascii("iliy"),
        dictgen::InsensitiveStr::Ascii("iltiy"),
    ],
    values: &[&["modify"], &["mobility"], &["mobility"], &["mobility"]],
    range: 3..=6,
};

static WORD_MOA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MOA_CHILDREN),
    value: None,
};

pub static WORD_MOA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("st")],
    values: &[&["most", "moat"]],
    range: 2..=2,
};

static WORD_MN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MN_CHILDREN),
    value: None,
};

pub static WORD_MN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ay"),
        dictgen::InsensitiveStr::Ascii("emnonic"),
    ],
    values: &[&["many"], &["mnemonic"]],
    range: 2..=7,
};

static WORD_MM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MM_CHILDREN),
    value: None,
};

pub static WORD_MM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aped"),
        dictgen::InsensitiveStr::Ascii("atching"),
        dictgen::InsensitiveStr::Ascii("bers"),
        dictgen::InsensitiveStr::Ascii("nemonic"),
    ],
    values: &[&["mapped"], &["matching"], &["members"], &["mnemonic"]],
    range: 4..=7,
};

static WORD_MK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MK_CHILDREN),
    value: None,
};

pub static WORD_MK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ae"),
        dictgen::InsensitiveStr::Ascii("aes"),
        dictgen::InsensitiveStr::Ascii("aing"),
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("ea"),
    ],
    values: &[&["make"], &["makes"], &["making"], &["make"], &["make"]],
    range: 1..=4,
};

static WORD_MJ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MJ_CHILDREN),
    value: None,
};

pub static WORD_MJ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("or")],
    values: &[&["major"]],
    range: 2..=2,
};

static WORD_MI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_MI_CHILDREN),
    value: None,
};

static WORD_MI_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_MIA_NODE),
    None,
    Some(&WORD_MIC_NODE),
    Some(&WORD_MID_NODE),
    None,
    None,
    Some(&WORD_MIG_NODE),
    Some(&WORD_MIH_NODE),
    Some(&WORD_MII_NODE),
    None,
    Some(&WORD_MIK_NODE),
    Some(&WORD_MIL_NODE),
    Some(&WORD_MIM_NODE),
    Some(&WORD_MIN_NODE),
    None,
    Some(&WORD_MIP_NODE),
    None,
    Some(&WORD_MIR_NODE),
    Some(&WORD_MIS_NODE),
    Some(&WORD_MIT_NODE),
    None,
    None,
    None,
    Some(&WORD_MIX_NODE),
    None,
    None,
];

static WORD_MIX_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MIX_CHILDREN),
    value: None,
};

pub static WORD_MIX_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("imum"),
        dictgen::InsensitiveStr::Ascii("ted"),
        dictgen::InsensitiveStr::Ascii("ure"),
    ],
    values: &[&["maximum"], &["mixed"], &["mixture"]],
    range: 3..=4,
};

static WORD_MIT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MIT_CHILDREN),
    value: None,
};

pub static WORD_MIT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("icate"),
        dictgen::InsensitiveStr::Ascii("icated"),
        dictgen::InsensitiveStr::Ascii("icateing"),
        dictgen::InsensitiveStr::Ascii("icates"),
        dictgen::InsensitiveStr::Ascii("icating"),
        dictgen::InsensitiveStr::Ascii("icator"),
        dictgen::InsensitiveStr::Ascii("igaiton"),
        dictgen::InsensitiveStr::Ascii("tigate"),
    ],
    values: &[
        &["mitigate"],
        &["mitigated"],
        &["mitigating"],
        &["mitigates"],
        &["mitigating"],
        &["mitigator"],
        &["mitigation"],
        &["mitigate"],
    ],
    range: 5..=8,
};

static WORD_MIS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_MIS_CHILDREN),
    value: Some(&["miss", "mist"]),
};

static WORD_MIS_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_MISA_NODE),
    Some(&WORD_MISB_NODE),
    Some(&WORD_MISC_NODE),
    Some(&WORD_MISD_NODE),
    Some(&WORD_MISE_NODE),
    Some(&WORD_MISF_NODE),
    Some(&WORD_MISG_NODE),
    None,
    Some(&WORD_MISI_NODE),
    None,
    None,
    None,
    Some(&WORD_MISM_NODE),
    Some(&WORD_MISN_NODE),
    Some(&WORD_MISO_NODE),
    Some(&WORD_MISP_NODE),
    Some(&WORD_MISQ_NODE),
    Some(&WORD_MISR_NODE),
    Some(&WORD_MISS_NODE),
    Some(&WORD_MIST_NODE),
    Some(&WORD_MISU_NODE),
    None,
    None,
    None,
    Some(&WORD_MISY_NODE),
    None,
];

static WORD_MISY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MISY_CHILDREN),
    value: None,
};

pub static WORD_MISY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("gonist"),
        dictgen::InsensitiveStr::Ascii("gonistic"),
    ],
    values: &[&["misogynist"], &["misogynistic"]],
    range: 6..=8,
};

static WORD_MISU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MISU_CHILDREN),
    value: None,
};

pub static WORD_MISU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("bderstanding"),
        dictgen::InsensitiveStr::Ascii("dnerstanding"),
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("ndarstanding"),
        dictgen::InsensitiveStr::Ascii("nderatanding"),
        dictgen::InsensitiveStr::Ascii("nderdtanding"),
        dictgen::InsensitiveStr::Ascii("ndersatnding"),
        dictgen::InsensitiveStr::Ascii("ndersood"),
        dictgen::InsensitiveStr::Ascii("ndersranding"),
        dictgen::InsensitiveStr::Ascii("nderstading"),
        dictgen::InsensitiveStr::Ascii("nderstadings"),
        dictgen::InsensitiveStr::Ascii("nderstadning"),
        dictgen::InsensitiveStr::Ascii("nderstamding"),
        dictgen::InsensitiveStr::Ascii("nderstandig"),
        dictgen::InsensitiveStr::Ascii("nderstandigs"),
        dictgen::InsensitiveStr::Ascii("nderstandimg"),
        dictgen::InsensitiveStr::Ascii("nderstandind"),
        dictgen::InsensitiveStr::Ascii("nderstandingly"),
        dictgen::InsensitiveStr::Ascii("nderstandng"),
        dictgen::InsensitiveStr::Ascii("nderstanging"),
        dictgen::InsensitiveStr::Ascii("nderstanidng"),
        dictgen::InsensitiveStr::Ascii("nderstaning"),
        dictgen::InsensitiveStr::Ascii("nderstanings"),
        dictgen::InsensitiveStr::Ascii("nderstansing"),
        dictgen::InsensitiveStr::Ascii("nderstanting"),
        dictgen::InsensitiveStr::Ascii("nderstantings"),
        dictgen::InsensitiveStr::Ascii("nderstending"),
        dictgen::InsensitiveStr::Ascii("nderstnading"),
        dictgen::InsensitiveStr::Ascii("nderstod"),
        dictgen::InsensitiveStr::Ascii("nderstsnding"),
        dictgen::InsensitiveStr::Ascii("nderstunding"),
        dictgen::InsensitiveStr::Ascii("ndertsanding"),
        dictgen::InsensitiveStr::Ascii("ndrestanding"),
        dictgen::InsensitiveStr::Ascii("nterstanding"),
        dictgen::InsensitiveStr::Ascii("nterstood"),
    ],
    values: &[
        &["misunderstandings"],
        &["misunderstandings"],
        &["misuse"],
        &["misused"],
        &["misusing"],
        &["misunderstandings"],
        &["misunderstandings"],
        &["misunderstandings"],
        &["misunderstandings"],
        &["misunderstood"],
        &["misunderstandings"],
        &["misunderstanding"],
        &["misunderstandings"],
        &["misunderstandings"],
        &["misunderstandings"],
        &["misunderstandings"],
        &["misunderstandings"],
        &["misunderstandings"],
        &["misunderstandings"],
        &["misunderstandings"],
        &["misunderstandings"],
        &["misunderstandings"],
        &["misunderstandings"],
        &["misunderstanding"],
        &["misunderstandings"],
        &["misunderstandings"],
        &["misunderstandings"],
        &["misunderstandings"],
        &["misunderstandings"],
        &["misunderstandings"],
        &["misunderstood"],
        &["misunderstandings"],
        &["misunderstandings"],
        &["misunderstandings"],
        &["misunderstandings"],
        &["misunderstandings"],
        &["misunderstood"],
    ],
    range: 1..=14,
};

static WORD_MIST_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MIST_CHILDREN),
    value: None,
};

pub static WORD_MIST_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("akedly"),
        dictgen::InsensitiveStr::Ascii("akengly"),
        dictgen::InsensitiveStr::Ascii("akently"),
        dictgen::InsensitiveStr::Ascii("akey"),
        dictgen::InsensitiveStr::Ascii("akinly"),
        dictgen::InsensitiveStr::Ascii("ankely"),
        dictgen::InsensitiveStr::Ascii("atch"),
        dictgen::InsensitiveStr::Ascii("atchd"),
        dictgen::InsensitiveStr::Ascii("atched"),
        dictgen::InsensitiveStr::Ascii("atches"),
        dictgen::InsensitiveStr::Ascii("atching"),
        dictgen::InsensitiveStr::Ascii("eek"),
        dictgen::InsensitiveStr::Ascii("eeks"),
        dictgen::InsensitiveStr::Ascii("erious"),
        dictgen::InsensitiveStr::Ascii("eriously"),
        dictgen::InsensitiveStr::Ascii("ery"),
        dictgen::InsensitiveStr::Ascii("eryous"),
        dictgen::InsensitiveStr::Ascii("ic"),
        dictgen::InsensitiveStr::Ascii("ical"),
        dictgen::InsensitiveStr::Ascii("ics"),
        dictgen::InsensitiveStr::Ascii("match"),
        dictgen::InsensitiveStr::Ascii("matched"),
        dictgen::InsensitiveStr::Ascii("matches"),
        dictgen::InsensitiveStr::Ascii("matching"),
        dictgen::InsensitiveStr::Ascii("read"),
        dictgen::InsensitiveStr::Ascii("readed"),
        dictgen::InsensitiveStr::Ascii("ro"),
        dictgen::InsensitiveStr::Ascii("ros"),
        dictgen::InsensitiveStr::Ascii("row"),
        dictgen::InsensitiveStr::Ascii("rows"),
    ],
    values: &[
        &["mistakenly"],
        &["mistakenly"],
        &["mistakenly"],
        &["mistakenly"],
        &["mistakenly"],
        &["mistakenly"],
        &["mismatch"],
        &["mismatched"],
        &["mismatched"],
        &["mismatches"],
        &["mismatching"],
        &["mystique"],
        &["mystiques"],
        &["mysterious"],
        &["mysteriously"],
        &["mystery"],
        &["mysterious"],
        &["mystic"],
        &["mystical"],
        &["mystics"],
        &["mismatch"],
        &["mismatched"],
        &["mismatches"],
        &["mismatching"],
        &["mistreated"],
        &["mistreated"],
        &["maestro"],
        &["maestros"],
        &["maestro"],
        &["maestros"],
    ],
    range: 2..=8,
};

static WORD_MISS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MISS_CHILDREN),
    value: None,
};

pub static WORD_MISS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("able"),
        dictgen::InsensitiveStr::Ascii("configuration"),
        dictgen::InsensitiveStr::Ascii("configure"),
        dictgen::InsensitiveStr::Ascii("configured"),
        dictgen::InsensitiveStr::Ascii("configures"),
        dictgen::InsensitiveStr::Ascii("configuring"),
        dictgen::InsensitiveStr::Ascii("counted"),
        dictgen::InsensitiveStr::Ascii("en"),
        dictgen::InsensitiveStr::Ascii("ign"),
        dictgen::InsensitiveStr::Ascii("igno"),
        dictgen::InsensitiveStr::Ascii("ils"),
        dictgen::InsensitiveStr::Ascii("in"),
        dictgen::InsensitiveStr::Ascii("ingassignement"),
        dictgen::InsensitiveStr::Ascii("ings"),
        dictgen::InsensitiveStr::Ascii("ionaire"),
        dictgen::InsensitiveStr::Ascii("ionaires"),
        dictgen::InsensitiveStr::Ascii("ionairy"),
        dictgen::InsensitiveStr::Ascii("ionare"),
        dictgen::InsensitiveStr::Ascii("ionares"),
        dictgen::InsensitiveStr::Ascii("ionaris"),
        dictgen::InsensitiveStr::Ascii("ionarry"),
        dictgen::InsensitiveStr::Ascii("ionera"),
        dictgen::InsensitiveStr::Ascii("ionnary"),
        dictgen::InsensitiveStr::Ascii("iony"),
        dictgen::InsensitiveStr::Ascii("isipi"),
        dictgen::InsensitiveStr::Ascii("isippi"),
        dictgen::InsensitiveStr::Ascii("issipi"),
        dictgen::InsensitiveStr::Ascii("issipis"),
        dictgen::InsensitiveStr::Ascii("issipppi"),
        dictgen::InsensitiveStr::Ascii("issppi"),
        dictgen::InsensitiveStr::Ascii("le"),
        dictgen::InsensitiveStr::Ascii("leading"),
        dictgen::InsensitiveStr::Ascii("letow"),
        dictgen::InsensitiveStr::Ascii("lies"),
        dictgen::InsensitiveStr::Ascii("managed"),
        dictgen::InsensitiveStr::Ascii("match"),
        dictgen::InsensitiveStr::Ascii("matchd"),
        dictgen::InsensitiveStr::Ascii("matched"),
        dictgen::InsensitiveStr::Ascii("matches"),
        dictgen::InsensitiveStr::Ascii("matching"),
        dictgen::InsensitiveStr::Ascii("onary"),
        dictgen::InsensitiveStr::Ascii("orui"),
        dictgen::InsensitiveStr::Ascii("ourri"),
        dictgen::InsensitiveStr::Ascii("peeling"),
        dictgen::InsensitiveStr::Ascii("pel"),
        dictgen::InsensitiveStr::Ascii("peld"),
        dictgen::InsensitiveStr::Ascii("peling"),
        dictgen::InsensitiveStr::Ascii("pelld"),
        dictgen::InsensitiveStr::Ascii("pellled"),
        dictgen::InsensitiveStr::Ascii("pellling"),
        dictgen::InsensitiveStr::Ascii("pellng"),
        dictgen::InsensitiveStr::Ascii("sing"),
        dictgen::InsensitiveStr::Ascii("take"),
        dictgen::InsensitiveStr::Ascii("taken"),
        dictgen::InsensitiveStr::Ascii("takes"),
        dictgen::InsensitiveStr::Ascii("type"),
        dictgen::InsensitiveStr::Ascii("types"),
        dictgen::InsensitiveStr::Ascii("understood"),
        dictgen::InsensitiveStr::Ascii("use"),
        dictgen::InsensitiveStr::Ascii("used"),
        dictgen::InsensitiveStr::Ascii("using"),
    ],
    values: &[
        &["miscible"],
        &["misconfiguration"],
        &["misconfigure"],
        &["misconfigured"],
        &["misconfigures"],
        &["misconfiguring"],
        &["miscounted"],
        &["mizzen"],
        &["missing"],
        &["mission"],
        &["missiles"],
        &["mission", "missing"],
        &["missingassignment"],
        &["missing"],
        &["missionaries"],
        &["missionaries"],
        &["missionary"],
        &["missionaries"],
        &["missionaries"],
        &["missionaries"],
        &["missionary"],
        &["missionary"],
        &["missionary"],
        &["missionary"],
        &["mississippi"],
        &["mississippi"],
        &["mississippi"],
        &["mississippi"],
        &["mississippi"],
        &["mississippi"],
        &["missile"],
        &["misleading"],
        &["mistletoe"],
        &["missiles"],
        &["mismanaged"],
        &["mismatch"],
        &["mismatched"],
        &["mismatched"],
        &["mismatches"],
        &["mismatching"],
        &["missionary"],
        &["missouri"],
        &["missouri"],
        &["misspelling"],
        &["misspell"],
        &["misspelled"],
        &["misspelling"],
        &["misspelled"],
        &["misspelled"],
        &["misspelling"],
        &["misspelling"],
        &["missing"],
        &["mistake"],
        &["mistaken"],
        &["mistakes"],
        &["mistype"],
        &["mistypes"],
        &["misunderstood"],
        &["misuse"],
        &["misused"],
        &["misusing"],
    ],
    range: 2..=14,
};

static WORD_MISR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MISR_CHILDREN),
    value: None,
};

pub static WORD_MISR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eable"),
        dictgen::InsensitiveStr::Ascii("eably"),
        dictgen::InsensitiveStr::Ascii("epresantation"),
        dictgen::InsensitiveStr::Ascii("epresenation"),
        dictgen::InsensitiveStr::Ascii("epresentaion"),
        dictgen::InsensitiveStr::Ascii("epresentaiton"),
        dictgen::InsensitiveStr::Ascii("epresentated"),
        dictgen::InsensitiveStr::Ascii("epresentatie"),
        dictgen::InsensitiveStr::Ascii("epresentating"),
        dictgen::InsensitiveStr::Ascii("epresentativ"),
        dictgen::InsensitiveStr::Ascii("epresention"),
        dictgen::InsensitiveStr::Ascii("epreseted"),
    ],
    values: &[
        &["miserable"],
        &["miserably"],
        &["misrepresentation"],
        &["misrepresentation"],
        &["misrepresentation"],
        &["misrepresentation"],
        &["misrepresented"],
        &["misrepresentation"],
        &["misrepresenting"],
        &["misrepresentation"],
        &["misrepresenting"],
        &["misrepresented"],
    ],
    range: 5..=13,
};

static WORD_MISQ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MISQ_CHILDREN),
    value: None,
};

pub static WORD_MISQ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("uito"),
        dictgen::InsensitiveStr::Ascii("uitos"),
    ],
    values: &[&["mosquito"], &["mosquitos"]],
    range: 4..=5,
};

static WORD_MISP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MISP_CHILDREN),
    value: None,
};

pub static WORD_MISP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ell"),
        dictgen::InsensitiveStr::Ascii("elled"),
        dictgen::InsensitiveStr::Ascii("elling"),
        dictgen::InsensitiveStr::Ascii("ellings"),
        dictgen::InsensitiveStr::Ascii("elt"),
        dictgen::InsensitiveStr::Ascii("ronounciation"),
        dictgen::InsensitiveStr::Ascii("roportionate"),
    ],
    values: &[
        &["misspell"],
        &["misspelled"],
        &["misspelling"],
        &["misspellings"],
        &["misspelt"],
        &["mispronunciation"],
        &["disproportionate"],
    ],
    range: 3..=13,
};

static WORD_MISO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MISO_CHILDREN),
    value: None,
};

pub static WORD_MISO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ganist"),
        dictgen::InsensitiveStr::Ascii("ganistic"),
        dictgen::InsensitiveStr::Ascii("genist"),
        dictgen::InsensitiveStr::Ascii("genistic"),
        dictgen::InsensitiveStr::Ascii("ginist"),
        dictgen::InsensitiveStr::Ascii("ginyst"),
        dictgen::InsensitiveStr::Ascii("ginystic"),
        dictgen::InsensitiveStr::Ascii("ginysts"),
        dictgen::InsensitiveStr::Ascii("gnyist"),
        dictgen::InsensitiveStr::Ascii("gnyistic"),
        dictgen::InsensitiveStr::Ascii("gnyists"),
        dictgen::InsensitiveStr::Ascii("gonist"),
        dictgen::InsensitiveStr::Ascii("gonistic"),
        dictgen::InsensitiveStr::Ascii("gonyst"),
        dictgen::InsensitiveStr::Ascii("gyinst"),
        dictgen::InsensitiveStr::Ascii("gyinsts"),
        dictgen::InsensitiveStr::Ascii("gynisic"),
        dictgen::InsensitiveStr::Ascii("gynisitc"),
        dictgen::InsensitiveStr::Ascii("gynisitic"),
        dictgen::InsensitiveStr::Ascii("gynistc"),
        dictgen::InsensitiveStr::Ascii("gynsitic"),
        dictgen::InsensitiveStr::Ascii("gynstic"),
        dictgen::InsensitiveStr::Ascii("gynt"),
        dictgen::InsensitiveStr::Ascii("gynyst"),
        dictgen::InsensitiveStr::Ascii("gynystic"),
        dictgen::InsensitiveStr::Ascii("uri"),
        dictgen::InsensitiveStr::Ascii("ygnist"),
    ],
    values: &[
        &["misogynist"],
        &["misogynistic"],
        &["misogynist"],
        &["misogynistic"],
        &["misogynist"],
        &["misogynist"],
        &["misogynistic"],
        &["misogynist"],
        &["misogynist"],
        &["misogynistic"],
        &["misogynist"],
        &["misogynist"],
        &["misogynistic"],
        &["misogynist"],
        &["misogynist"],
        &["misogynist"],
        &["misogynistic"],
        &["misogynistic"],
        &["misogynistic"],
        &["misogynistic"],
        &["misogynistic"],
        &["misogynist"],
        &["misogynist"],
        &["misogynist"],
        &["misogynistic"],
        &["missouri"],
        &["misogynist"],
    ],
    range: 3..=9,
};

static WORD_MISN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MISN_CHILDREN),
    value: None,
};

pub static WORD_MISN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("adry")],
    values: &[&["misandry"]],
    range: 4..=4,
};

static WORD_MISM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MISM_CHILDREN),
    value: None,
};

pub static WORD_MISM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ach"),
        dictgen::InsensitiveStr::Ascii("ached"),
        dictgen::InsensitiveStr::Ascii("aches"),
        dictgen::InsensitiveStr::Ascii("aching"),
        dictgen::InsensitiveStr::Ascii("actch"),
        dictgen::InsensitiveStr::Ascii("atchd"),
        dictgen::InsensitiveStr::Ascii("atich"),
    ],
    values: &[
        &["mismatch"],
        &["mismatched"],
        &["mismatches"],
        &["mismatching"],
        &["mismatch"],
        &["mismatched"],
        &["mismatch"],
    ],
    range: 3..=6,
};

static WORD_MISI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MISI_CHILDREN),
    value: None,
};

pub static WORD_MISI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("le"),
        dictgen::InsensitiveStr::Ascii("mformed"),
        dictgen::InsensitiveStr::Ascii("nfomed"),
        dictgen::InsensitiveStr::Ascii("ng"),
        dictgen::InsensitiveStr::Ascii("ntepret"),
        dictgen::InsensitiveStr::Ascii("ntepreted"),
        dictgen::InsensitiveStr::Ascii("nterept"),
        dictgen::InsensitiveStr::Ascii("nterperet"),
        dictgen::InsensitiveStr::Ascii("nterpert"),
        dictgen::InsensitiveStr::Ascii("nterperted"),
        dictgen::InsensitiveStr::Ascii("nterperting"),
        dictgen::InsensitiveStr::Ascii("nterperts"),
        dictgen::InsensitiveStr::Ascii("nterpet"),
        dictgen::InsensitiveStr::Ascii("nterprate"),
        dictgen::InsensitiveStr::Ascii("nterprating"),
        dictgen::InsensitiveStr::Ascii("nterpred"),
        dictgen::InsensitiveStr::Ascii("nterprent"),
        dictgen::InsensitiveStr::Ascii("nterprented"),
        dictgen::InsensitiveStr::Ascii("nterprested"),
        dictgen::InsensitiveStr::Ascii("nterpretated"),
        dictgen::InsensitiveStr::Ascii("nterpretating"),
        dictgen::InsensitiveStr::Ascii("nterpretion"),
        dictgen::InsensitiveStr::Ascii("nterpretions"),
        dictgen::InsensitiveStr::Ascii("nterprett"),
        dictgen::InsensitiveStr::Ascii("nterpretted"),
        dictgen::InsensitiveStr::Ascii("nterpretting"),
        dictgen::InsensitiveStr::Ascii("nterprit"),
        dictgen::InsensitiveStr::Ascii("nterpriting"),
        dictgen::InsensitiveStr::Ascii("nterprted"),
        dictgen::InsensitiveStr::Ascii("nterpt"),
        dictgen::InsensitiveStr::Ascii("nterpted"),
        dictgen::InsensitiveStr::Ascii("ntrepret"),
        dictgen::InsensitiveStr::Ascii("ntrepreted"),
        dictgen::InsensitiveStr::Ascii("ntrepreting"),
        dictgen::InsensitiveStr::Ascii("sng"),
        dictgen::InsensitiveStr::Ascii("son"),
        dictgen::InsensitiveStr::Ascii("sonaries"),
        dictgen::InsensitiveStr::Ascii("sonary"),
    ],
    values: &[
        &["missile"],
        &["misinformed"],
        &["misinformed"],
        &["missing"],
        &["misinterpret"],
        &["misinterpreted"],
        &["misinterpret"],
        &["misinterpret"],
        &["misinterpret"],
        &["misinterpreted"],
        &["misinterpreting"],
        &["misinterprets"],
        &["misinterpret"],
        &["misinterpret"],
        &["misinterpreting"],
        &["misinterpreted"],
        &["misinterpret"],
        &["misinterpret"],
        &["misinterpret"],
        &["misinterpreted"],
        &["misinterpreting"],
        &["misinterpreting"],
        &["misinterpreting"],
        &["misinterpret"],
        &["misinterpreted"],
        &["misinterpreting"],
        &["misinterpreting"],
        &["misinterpreting"],
        &["misinterpret"],
        &["misinterpret"],
        &["misinterpret"],
        &["misinterpret"],
        &["misinterpreted"],
        &["misinterpreting"],
        &["missing"],
        &["mission"],
        &["missionaries"],
        &["missionary"],
    ],
    range: 2..=13,
};

static WORD_MISG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MISG_CHILDREN),
    value: None,
};

pub static WORD_MISG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("oynist"),
        dictgen::InsensitiveStr::Ascii("oynistic"),
    ],
    values: &[&["misogynist"], &["misogynistic"]],
    range: 6..=8,
};

static WORD_MISF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MISF_CHILDREN),
    value: None,
};

pub static WORD_MISF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ormed"),
        dictgen::InsensitiveStr::Ascii("ortunte"),
        dictgen::InsensitiveStr::Ascii("orture"),
        dictgen::InsensitiveStr::Ascii("ourtunes"),
    ],
    values: &[
        &["malformed"],
        &["misfortune"],
        &["misfortune"],
        &["misfortunes"],
    ],
    range: 5..=8,
};

static WORD_MISE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MISE_CHILDREN),
    value: None,
};

pub static WORD_MISE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("laneous"),
        dictgen::InsensitiveStr::Ascii("laneously"),
        dictgen::InsensitiveStr::Ascii("llaneous"),
        dictgen::InsensitiveStr::Ascii("llaneously"),
        dictgen::InsensitiveStr::Ascii("rabel"),
        dictgen::InsensitiveStr::Ascii("rablely"),
        dictgen::InsensitiveStr::Ascii("rabley"),
        dictgen::InsensitiveStr::Ascii("rablly"),
    ],
    values: &[
        &["miscellaneous"],
        &["miscellaneously"],
        &["miscellaneous"],
        &["miscellaneously"],
        &["miserable"],
        &["miserably"],
        &["miserably"],
        &["miserably"],
    ],
    range: 5..=10,
};

static WORD_MISD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MISD_CHILDREN),
    value: None,
};

pub static WORD_MISD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ameanor"),
        dictgen::InsensitiveStr::Ascii("ameanors"),
        dictgen::InsensitiveStr::Ascii("eamenor"),
        dictgen::InsensitiveStr::Ascii("eamenors"),
        dictgen::InsensitiveStr::Ascii("emeaner"),
        dictgen::InsensitiveStr::Ascii("emenaor"),
        dictgen::InsensitiveStr::Ascii("emenor"),
        dictgen::InsensitiveStr::Ascii("emenors"),
        dictgen::InsensitiveStr::Ascii("imeanor"),
        dictgen::InsensitiveStr::Ascii("omeanor"),
    ],
    values: &[
        &["misdemeanor"],
        &["misdemeanors"],
        &["misdemeanor"],
        &["misdemeanor"],
        &["misdemeanor"],
        &["misdemeanor"],
        &["misdemeanor"],
        &["misdemeanors"],
        &["misdemeanor"],
        &["misdemeanor"],
    ],
    range: 6..=8,
};

static WORD_MISC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MISC_CHILDREN),
    value: None,
};

pub static WORD_MISC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("airrage"),
        dictgen::InsensitiveStr::Ascii("allenaous"),
        dictgen::InsensitiveStr::Ascii("allenous"),
        dictgen::InsensitiveStr::Ascii("arrage"),
        dictgen::InsensitiveStr::Ascii("arraige"),
        dictgen::InsensitiveStr::Ascii("arraiges"),
        dictgen::InsensitiveStr::Ascii("arridge"),
        dictgen::InsensitiveStr::Ascii("arriege"),
        dictgen::InsensitiveStr::Ascii("arrige"),
        dictgen::InsensitiveStr::Ascii("atalogued"),
        dictgen::InsensitiveStr::Ascii("eancellous"),
        dictgen::InsensitiveStr::Ascii("elaneous"),
        dictgen::InsensitiveStr::Ascii("ellanious"),
        dictgen::InsensitiveStr::Ascii("ellanous"),
        dictgen::InsensitiveStr::Ascii("elleneous"),
        dictgen::InsensitiveStr::Ascii("heivous"),
        dictgen::InsensitiveStr::Ascii("hevious"),
        dictgen::InsensitiveStr::Ascii("hevus"),
        dictgen::InsensitiveStr::Ascii("hevusly"),
        dictgen::InsensitiveStr::Ascii("hieveous"),
        dictgen::InsensitiveStr::Ascii("hieveously"),
        dictgen::InsensitiveStr::Ascii("hievious"),
        dictgen::InsensitiveStr::Ascii("ommunciation"),
        dictgen::InsensitiveStr::Ascii("ommuniation"),
        dictgen::InsensitiveStr::Ascii("ommunicaiton"),
        dictgen::InsensitiveStr::Ascii("ommunicatie"),
        dictgen::InsensitiveStr::Ascii("ommuniction"),
        dictgen::InsensitiveStr::Ascii("omunnication"),
        dictgen::InsensitiveStr::Ascii("oncpetion"),
        dictgen::InsensitiveStr::Ascii("onecption"),
        dictgen::InsensitiveStr::Ascii("onfiged"),
        dictgen::InsensitiveStr::Ascii("onseptions"),
        dictgen::InsensitiveStr::Ascii("rosoft"),
        dictgen::InsensitiveStr::Ascii("ummunication"),
    ],
    values: &[
        &["miscarriage"],
        &["miscellaneous"],
        &["miscellaneous"],
        &["miscarriage"],
        &["miscarriage"],
        &["miscarriage"],
        &["miscarriage"],
        &["miscarriage"],
        &["miscarriage"],
        &["miscataloged"],
        &["miscellaneous"],
        &["miscellaneous"],
        &["miscellaneous"],
        &["miscellaneous"],
        &["miscellaneous"],
        &["mischievous"],
        &["mischievous"],
        &["mischievous"],
        &["mischievously"],
        &["mischievous"],
        &["mischievously"],
        &["mischievous"],
        &["miscommunication"],
        &["miscommunication"],
        &["miscommunication"],
        &["miscommunication"],
        &["miscommunication"],
        &["miscommunication"],
        &["misconceptions"],
        &["misconceptions"],
        &["misconfigured"],
        &["misconceptions"],
        &["microsoft"],
        &["miscommunication"],
    ],
    range: 5..=12,
};

static WORD_MISB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MISB_CHILDREN),
    value: None,
};

pub static WORD_MISB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ehaive")],
    values: &[&["misbehave"]],
    range: 6..=6,
};

static WORD_MISA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MISA_CHILDREN),
    value: None,
};

pub static WORD_MISA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ke"),
        dictgen::InsensitiveStr::Ascii("ken"),
        dictgen::InsensitiveStr::Ascii("kes"),
        dictgen::InsensitiveStr::Ascii("lignement"),
        dictgen::InsensitiveStr::Ascii("linged"),
        dictgen::InsensitiveStr::Ascii("lligned"),
        dictgen::InsensitiveStr::Ascii("nderstood"),
        dictgen::InsensitiveStr::Ascii("ndrony"),
        dictgen::InsensitiveStr::Ascii("ndy"),
    ],
    values: &[
        &["mistake"],
        &["mistaken"],
        &["mistakes"],
        &["misalignment"],
        &["misaligned"],
        &["misaligned"],
        &["misunderstood"],
        &["misandry"],
        &["misandry"],
    ],
    range: 2..=9,
};

static WORD_MIR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MIR_CHILDREN),
    value: None,
};

pub static WORD_MIR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("acalous"),
        dictgen::InsensitiveStr::Ascii("acilously"),
        dictgen::InsensitiveStr::Ascii("acluous"),
        dictgen::InsensitiveStr::Ascii("acoulus"),
        dictgen::InsensitiveStr::Ascii("aculaous"),
        dictgen::InsensitiveStr::Ascii("aculos"),
        dictgen::InsensitiveStr::Ascii("aculosly"),
        dictgen::InsensitiveStr::Ascii("aculousy"),
        dictgen::InsensitiveStr::Ascii("aculu"),
        dictgen::InsensitiveStr::Ascii("acurously"),
        dictgen::InsensitiveStr::Ascii("alces"),
        dictgen::InsensitiveStr::Ascii("cales"),
        dictgen::InsensitiveStr::Ascii("coatx"),
        dictgen::InsensitiveStr::Ascii("cocenter"),
        dictgen::InsensitiveStr::Ascii("conesia"),
        dictgen::InsensitiveStr::Ascii("cophone"),
        dictgen::InsensitiveStr::Ascii("cophones"),
        dictgen::InsensitiveStr::Ascii("coscope"),
        dictgen::InsensitiveStr::Ascii("coscopes"),
        dictgen::InsensitiveStr::Ascii("coscopic"),
        dictgen::InsensitiveStr::Ascii("coservice"),
        dictgen::InsensitiveStr::Ascii("coservices"),
        dictgen::InsensitiveStr::Ascii("cosoft"),
        dictgen::InsensitiveStr::Ascii("cotransaction"),
        dictgen::InsensitiveStr::Ascii("cotransactions"),
        dictgen::InsensitiveStr::Ascii("cowave"),
        dictgen::InsensitiveStr::Ascii("cowaves"),
        dictgen::InsensitiveStr::Ascii("gaine"),
        dictgen::InsensitiveStr::Ascii("gate"),
        dictgen::InsensitiveStr::Ascii("gated"),
        dictgen::InsensitiveStr::Ascii("gates"),
        dictgen::InsensitiveStr::Ascii("ometer"),
        dictgen::InsensitiveStr::Ascii("ometers"),
        dictgen::InsensitiveStr::Ascii("or"),
        dictgen::InsensitiveStr::Ascii("ored"),
        dictgen::InsensitiveStr::Ascii("oring"),
        dictgen::InsensitiveStr::Ascii("orr"),
        dictgen::InsensitiveStr::Ascii("orred"),
        dictgen::InsensitiveStr::Ascii("orring"),
        dictgen::InsensitiveStr::Ascii("orrs"),
        dictgen::InsensitiveStr::Ascii("ors"),
        dictgen::InsensitiveStr::Ascii("ro"),
        dictgen::InsensitiveStr::Ascii("roed"),
        dictgen::InsensitiveStr::Ascii("rord"),
        dictgen::InsensitiveStr::Ascii("rorn"),
        dictgen::InsensitiveStr::Ascii("rorred"),
    ],
    values: &[
        &["miraculous"],
        &["miraculously"],
        &["miraculous"],
        &["miraculous"],
        &["miraculous"],
        &["miraculous"],
        &["miraculously"],
        &["miraculously"],
        &["miraculous"],
        &["miraculous"],
        &["miracles"],
        &["miracles"],
        &["microatx"],
        &["microcenter"],
        &["micronesia"],
        &["microphone"],
        &["microphones"],
        &["microscope"],
        &["microscopes"],
        &["microscopic"],
        &["microservice"],
        &["microservices"],
        &["microsoft"],
        &["microtransactions"],
        &["microtransactions"],
        &["microwave"],
        &["microwaves"],
        &["migraine"],
        &["migrate"],
        &["migrated"],
        &["migrates"],
        &["micrometer"],
        &["micrometers"],
        &["mirror", "minor"],
        &["mirrored"],
        &["mirroring"],
        &["mirror"],
        &["mirrored"],
        &["mirroring"],
        &["mirrors"],
        &["mirrors", "minors"],
        &["mirror"],
        &["mirrored"],
        &["mirrored"],
        &["mirror"],
        &["mirrored"],
    ],
    range: 2..=14,
};

static WORD_MIP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MIP_CHILDREN),
    value: None,
};

pub static WORD_MIP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("lementation")],
    values: &[&["implementation"]],
    range: 11..=11,
};

static WORD_MIN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_MIN_CHILDREN),
    value: None,
};

static WORD_MIN_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_MINA_NODE),
    None,
    None,
    Some(&WORD_MIND_NODE),
    Some(&WORD_MINE_NODE),
    None,
    Some(&WORD_MING_NODE),
    None,
    Some(&WORD_MINI_NODE),
    None,
    None,
    None,
    Some(&WORD_MINM_NODE),
    Some(&WORD_MINN_NODE),
    Some(&WORD_MINO_NODE),
    None,
    None,
    None,
    Some(&WORD_MINS_NODE),
    Some(&WORD_MINT_NODE),
    Some(&WORD_MINU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_MINU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MINU_CHILDREN),
    value: None,
};

pub static WORD_MINU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("m"),
        dictgen::InsensitiveStr::Ascii("mum"),
        dictgen::InsensitiveStr::Ascii("mun"),
        dictgen::InsensitiveStr::Ascii("scle"),
        dictgen::InsensitiveStr::Ascii("sculy"),
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("ts"),
    ],
    values: &[
        &["menu", "minus", "minute"],
        &["menus", "minus", "minuses", "minutes"],
        &["minimum"],
        &["minimum"],
        &["minimum"],
        &["minuscule"],
        &["minusculely", "minuscule"],
        &["minute"],
        &["minutes"],
    ],
    range: 1..=5,
};

static WORD_MINT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MINT_CHILDREN),
    value: None,
};

pub static WORD_MINT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("or"),
        dictgen::InsensitiveStr::Ascii("ored"),
        dictgen::InsensitiveStr::Ascii("oring"),
        dictgen::InsensitiveStr::Ascii("ors"),
    ],
    values: &[
        &["mentor", "monitor", "minor"],
        &["mentored", "monitored"],
        &["mentoring", "monitoring"],
        &["mentors", "monitors"],
    ],
    range: 2..=5,
};

static WORD_MINS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MINS_CHILDREN),
    value: None,
};

pub static WORD_MINS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("icule"),
        dictgen::InsensitiveStr::Ascii("iter"),
        dictgen::InsensitiveStr::Ascii("iters"),
        dictgen::InsensitiveStr::Ascii("itry"),
        dictgen::InsensitiveStr::Ascii("tries"),
        dictgen::InsensitiveStr::Ascii("try"),
    ],
    values: &[
        &["miniscule"],
        &["minister"],
        &["ministers"],
        &["ministry"],
        &["ministries"],
        &["ministry"],
    ],
    range: 3..=5,
};

static WORD_MINO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MINO_CHILDREN),
    value: None,
};

pub static WORD_MINO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ins"),
        dictgen::InsensitiveStr::Ascii("osha"),
        dictgen::InsensitiveStr::Ascii("ritets"),
        dictgen::InsensitiveStr::Ascii("roties"),
    ],
    values: &[
        &["minions"],
        &["minutia", "minutiae"],
        &["minorities"],
        &["minorities"],
    ],
    range: 3..=6,
};

static WORD_MINN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MINN_CHILDREN),
    value: None,
};

pub static WORD_MINN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eaoplis"),
        dictgen::InsensitiveStr::Ascii("eaplis"),
        dictgen::InsensitiveStr::Ascii("eaplois"),
        dictgen::InsensitiveStr::Ascii("eapolites"),
        dictgen::InsensitiveStr::Ascii("eapols"),
        dictgen::InsensitiveStr::Ascii("eosta"),
        dictgen::InsensitiveStr::Ascii("esotta"),
        dictgen::InsensitiveStr::Ascii("estoa"),
        dictgen::InsensitiveStr::Ascii("iapolis"),
        dictgen::InsensitiveStr::Ascii("imum"),
        dictgen::InsensitiveStr::Ascii("imums"),
    ],
    values: &[
        &["minneapolis"],
        &["minneapolis"],
        &["minneapolis"],
        &["minneapolis"],
        &["minneapolis"],
        &["minnesota"],
        &["minnesota"],
        &["minnesota"],
        &["minneapolis"],
        &["minimum"],
        &["minimums"],
    ],
    range: 4..=9,
};

static WORD_MINM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MINM_CHILDREN),
    value: None,
};

pub static WORD_MINM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("al"),
        dictgen::InsensitiveStr::Ascii("ize"),
        dictgen::InsensitiveStr::Ascii("um"),
    ],
    values: &[&["minimal"], &["minimize"], &["minimum"]],
    range: 2..=3,
};

static WORD_MINI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MINI_CHILDREN),
    value: None,
};

pub static WORD_MINI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("al"),
        dictgen::InsensitiveStr::Ascii("mage"),
        dictgen::InsensitiveStr::Ascii("malisitc"),
        dictgen::InsensitiveStr::Ascii("malisity"),
        dictgen::InsensitiveStr::Ascii("mals"),
        dictgen::InsensitiveStr::Ascii("malstic"),
        dictgen::InsensitiveStr::Ascii("malt"),
        dictgen::InsensitiveStr::Ascii("mam"),
        dictgen::InsensitiveStr::Ascii("mazing"),
        dictgen::InsensitiveStr::Ascii("mial"),
        dictgen::InsensitiveStr::Ascii("milast"),
        dictgen::InsensitiveStr::Ascii("milist"),
        dictgen::InsensitiveStr::Ascii("mini"),
        dictgen::InsensitiveStr::Ascii("mium"),
        dictgen::InsensitiveStr::Ascii("msation"),
        dictgen::InsensitiveStr::Ascii("mse"),
        dictgen::InsensitiveStr::Ascii("msed"),
        dictgen::InsensitiveStr::Ascii("mses"),
        dictgen::InsensitiveStr::Ascii("msing"),
        dictgen::InsensitiveStr::Ascii("mumm"),
        dictgen::InsensitiveStr::Ascii("mumn"),
        dictgen::InsensitiveStr::Ascii("mun"),
        dictgen::InsensitiveStr::Ascii("mzation"),
        dictgen::InsensitiveStr::Ascii("mze"),
        dictgen::InsensitiveStr::Ascii("mzed"),
        dictgen::InsensitiveStr::Ascii("mzes"),
        dictgen::InsensitiveStr::Ascii("mzing"),
        dictgen::InsensitiveStr::Ascii("nal"),
        dictgen::InsensitiveStr::Ascii("nalist"),
        dictgen::InsensitiveStr::Ascii("nise"),
        dictgen::InsensitiveStr::Ascii("nised"),
        dictgen::InsensitiveStr::Ascii("nises"),
        dictgen::InsensitiveStr::Ascii("nising"),
        dictgen::InsensitiveStr::Ascii("nize"),
        dictgen::InsensitiveStr::Ascii("nized"),
        dictgen::InsensitiveStr::Ascii("nizes"),
        dictgen::InsensitiveStr::Ascii("nizing"),
        dictgen::InsensitiveStr::Ascii("nos"),
        dictgen::InsensitiveStr::Ascii("nterpret"),
        dictgen::InsensitiveStr::Ascii("nterpreting"),
        dictgen::InsensitiveStr::Ascii("num"),
        dictgen::InsensitiveStr::Ascii("pulating"),
        dictgen::InsensitiveStr::Ascii("pulation"),
        dictgen::InsensitiveStr::Ascii("pulative"),
        dictgen::InsensitiveStr::Ascii("sclue"),
        dictgen::InsensitiveStr::Ascii("scue"),
        dictgen::InsensitiveStr::Ascii("scuel"),
        dictgen::InsensitiveStr::Ascii("scully"),
        dictgen::InsensitiveStr::Ascii("sterens"),
        dictgen::InsensitiveStr::Ascii("steres"),
        dictgen::InsensitiveStr::Ascii("sterios"),
        dictgen::InsensitiveStr::Ascii("sterns"),
        dictgen::InsensitiveStr::Ascii("stery"),
        dictgen::InsensitiveStr::Ascii("str"),
        dictgen::InsensitiveStr::Ascii("sty"),
        dictgen::InsensitiveStr::Ascii("sucle"),
        dictgen::InsensitiveStr::Ascii("taure"),
        dictgen::InsensitiveStr::Ascii("tuare"),
        dictgen::InsensitiveStr::Ascii("ture"),
        dictgen::InsensitiveStr::Ascii("um"),
        dictgen::InsensitiveStr::Ascii("ums"),
        dictgen::InsensitiveStr::Ascii("umum"),
    ],
    values: &[
        &["minimal"],
        &["minigame"],
        &["minimalist"],
        &["minimalist"],
        &["minimalist"],
        &["minimalist"],
        &["minimalist"],
        &["minimum"],
        &["minimizing"],
        &["minimal"],
        &["minimalist"],
        &["minimalist"],
        &["minimizing"],
        &["minimum"],
        &["minimisation"],
        &["minimise"],
        &["minimised"],
        &["minimises"],
        &["minimising"],
        &["minimum"],
        &["minimum"],
        &["minimum"],
        &["minimization"],
        &["minimize"],
        &["minimized"],
        &["minimizes"],
        &["minimizing"],
        &["minimal"],
        &["minimalist"],
        &["minimise"],
        &["minimised"],
        &["minimises"],
        &["minimising"],
        &["minimize"],
        &["minimized"],
        &["minimizes"],
        &["minimizing"],
        &["minions"],
        &["misinterpret"],
        &["misinterpreting"],
        &["minimum"],
        &["manipulating"],
        &["manipulation"],
        &["manipulative"],
        &["miniscule"],
        &["miniscule"],
        &["miniscule"],
        &["minusculely"],
        &["ministers"],
        &["ministers"],
        &["ministers"],
        &["ministers"],
        &["ministry", "minister"],
        &["minister"],
        &["ministry"],
        &["miniscule"],
        &["miniature"],
        &["miniature"],
        &["miniature"],
        &["minimum"],
        &["minimums"],
        &["minimum"],
    ],
    range: 2..=11,
};

static WORD_MING_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MING_CHILDREN),
    value: None,
};

pub static WORD_MING_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("gw"),
        dictgen::InsensitiveStr::Ascii("iame"),
    ],
    values: &[&["mingw"], &["minigame"]],
    range: 2..=4,
};

static WORD_MINE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MINE_CHILDREN),
    value: None,
};

pub static WORD_MINE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("rales"),
        dictgen::InsensitiveStr::Ascii("ras"),
        dictgen::InsensitiveStr::Ascii("rial"),
    ],
    values: &[&["minerals"], &["minerals"], &["mineral"]],
    range: 3..=5,
};

static WORD_MIND_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MIND_CHILDREN),
    value: None,
};

pub static WORD_MIND_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("carck"),
        dictgen::InsensitiveStr::Ascii("crak"),
        dictgen::InsensitiveStr::Ascii("leslly"),
        dictgen::InsensitiveStr::Ascii("lessely"),
        dictgen::InsensitiveStr::Ascii("lessley"),
        dictgen::InsensitiveStr::Ascii("lessy"),
    ],
    values: &[
        &["mindcrack"],
        &["mindcrack"],
        &["mindlessly"],
        &["mindlessly"],
        &["mindlessly"],
        &["mindlessly"],
    ],
    range: 4..=7,
};

static WORD_MINA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MINA_CHILDREN),
    value: None,
};

pub static WORD_MINA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("milist"),
        dictgen::InsensitiveStr::Ascii("ture"),
    ],
    values: &[&["minimalist"], &["miniature"]],
    range: 4..=6,
};

static WORD_MIM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MIM_CHILDREN),
    value: None,
};

pub static WORD_MIM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ach"),
        dictgen::InsensitiveStr::Ascii("achd"),
        dictgen::InsensitiveStr::Ascii("ached"),
        dictgen::InsensitiveStr::Ascii("aches"),
        dictgen::InsensitiveStr::Ascii("aching"),
        dictgen::InsensitiveStr::Ascii("atch"),
        dictgen::InsensitiveStr::Ascii("atchd"),
        dictgen::InsensitiveStr::Ascii("atched"),
        dictgen::InsensitiveStr::Ascii("atches"),
        dictgen::InsensitiveStr::Ascii("atching"),
        dictgen::InsensitiveStr::Ascii("icing"),
        dictgen::InsensitiveStr::Ascii("ick"),
        dictgen::InsensitiveStr::Ascii("icks"),
        dictgen::InsensitiveStr::Ascii("imal"),
        dictgen::InsensitiveStr::Ascii("imise"),
        dictgen::InsensitiveStr::Ascii("imize"),
        dictgen::InsensitiveStr::Ascii("imum"),
        dictgen::InsensitiveStr::Ascii("imun"),
        dictgen::InsensitiveStr::Ascii("inal"),
        dictgen::InsensitiveStr::Ascii("inalist"),
        dictgen::InsensitiveStr::Ascii("inally"),
        dictgen::InsensitiveStr::Ascii("inaly"),
        dictgen::InsensitiveStr::Ascii("inise"),
        dictgen::InsensitiveStr::Ascii("inised"),
        dictgen::InsensitiveStr::Ascii("inises"),
        dictgen::InsensitiveStr::Ascii("inising"),
        dictgen::InsensitiveStr::Ascii("inize"),
        dictgen::InsensitiveStr::Ascii("inized"),
        dictgen::InsensitiveStr::Ascii("inizes"),
        dictgen::InsensitiveStr::Ascii("inizing"),
        dictgen::InsensitiveStr::Ascii("mick"),
        dictgen::InsensitiveStr::Ascii("micked"),
        dictgen::InsensitiveStr::Ascii("micking"),
        dictgen::InsensitiveStr::Ascii("mics"),
    ],
    values: &[
        &["mismatch"],
        &["mismatched"],
        &["mismatched"],
        &["mismatches"],
        &["mismatching"],
        &["mismatch"],
        &["mismatched"],
        &["mismatched"],
        &["mismatches"],
        &["mismatching"],
        &["mimicking"],
        &["mimic"],
        &["mimics"],
        &["minimal"],
        &["minimise"],
        &["minimize"],
        &["minimum"],
        &["minimum"],
        &["minimal"],
        &["minimalist"],
        &["minimally"],
        &["minimally"],
        &["minimise"],
        &["minimised"],
        &["minimises"],
        &["minimising"],
        &["minimize"],
        &["minimized"],
        &["minimizes"],
        &["minimizing"],
        &["mimic"],
        &["mimicked"],
        &["mimicking"],
        &["mimics"],
    ],
    range: 3..=7,
};

static WORD_MIL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_MIL_CHILDREN),
    value: None,
};

static WORD_MIL_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_MILA_NODE),
    None,
    None,
    None,
    Some(&WORD_MILE_NODE),
    None,
    None,
    None,
    Some(&WORD_MILI_NODE),
    None,
    Some(&WORD_MILK_NODE),
    Some(&WORD_MILL_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_MILT_NODE),
    Some(&WORD_MILU_NODE),
    None,
    Some(&WORD_MILW_NODE),
    None,
    Some(&WORD_MILY_NODE),
    None,
];

static WORD_MILY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MILY_CHILDREN),
    value: None,
};

pub static WORD_MILY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ew")],
    values: &[&["milieu"]],
    range: 2..=2,
};

static WORD_MILW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MILW_CHILDREN),
    value: None,
};

pub static WORD_MILW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("akuee"),
        dictgen::InsensitiveStr::Ascii("uakee"),
    ],
    values: &[&["milwaukee"], &["milwaukee"]],
    range: 5..=5,
};

static WORD_MILU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MILU_CHILDREN),
    value: None,
};

pub static WORD_MILU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("wakee")],
    values: &[&["milwaukee"]],
    range: 5..=5,
};

static WORD_MILT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MILT_CHILDREN),
    value: None,
};

pub static WORD_MILT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ary"),
        dictgen::InsensitiveStr::Ascii("iant"),
        dictgen::InsensitiveStr::Ascii("isite"),
    ],
    values: &[&["military"], &["militant"], &["multisite"]],
    range: 3..=5,
};

static WORD_MILL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MILL_CHILDREN),
    value: None,
};

pub static WORD_MILL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eneum"),
        dictgen::InsensitiveStr::Ascii("enia"),
        dictgen::InsensitiveStr::Ascii("enial"),
        dictgen::InsensitiveStr::Ascii("enialism"),
        dictgen::InsensitiveStr::Ascii("enials"),
        dictgen::InsensitiveStr::Ascii("enian"),
        dictgen::InsensitiveStr::Ascii("enium"),
        dictgen::InsensitiveStr::Ascii("enna"),
        dictgen::InsensitiveStr::Ascii("ienaire"),
        dictgen::InsensitiveStr::Ascii("iescond"),
        dictgen::InsensitiveStr::Ascii("iesconds"),
        dictgen::InsensitiveStr::Ascii("imiter"),
        dictgen::InsensitiveStr::Ascii("imiters"),
        dictgen::InsensitiveStr::Ascii("imitre"),
        dictgen::InsensitiveStr::Ascii("imitres"),
        dictgen::InsensitiveStr::Ascii("innium"),
        dictgen::InsensitiveStr::Ascii("ionairre"),
        dictgen::InsensitiveStr::Ascii("ionairres"),
        dictgen::InsensitiveStr::Ascii("ionairs"),
        dictgen::InsensitiveStr::Ascii("ionar"),
        dictgen::InsensitiveStr::Ascii("ionarie"),
        dictgen::InsensitiveStr::Ascii("ionaries"),
        dictgen::InsensitiveStr::Ascii("ioniare"),
        dictgen::InsensitiveStr::Ascii("ioniares"),
        dictgen::InsensitiveStr::Ascii("isencond"),
        dictgen::InsensitiveStr::Ascii("isenconds"),
        dictgen::InsensitiveStr::Ascii("iseond"),
        dictgen::InsensitiveStr::Ascii("iseonds"),
        dictgen::InsensitiveStr::Ascii("itant"),
        dictgen::InsensitiveStr::Ascii("itary"),
        dictgen::InsensitiveStr::Ascii("on"),
        dictgen::InsensitiveStr::Ascii("second"),
        dictgen::InsensitiveStr::Ascii("seconds"),
        dictgen::InsensitiveStr::Ascii("sencond"),
        dictgen::InsensitiveStr::Ascii("senconds"),
    ],
    values: &[
        &["millennium"],
        &["millennia"],
        &["millennial"],
        &["millennialism"],
        &["millennials"],
        &["millennia"],
        &["millennium"],
        &["millennia"],
        &["millionaire"],
        &["millisecond"],
        &["milliseconds"],
        &["millimeter"],
        &["millimeters"],
        &["millimetre"],
        &["millimetres"],
        &["millennium"],
        &["millionaire"],
        &["millionaire"],
        &["millionaires"],
        &["millionaire"],
        &["millionaire"],
        &["millionaires"],
        &["millionaire"],
        &["millionaires"],
        &["millisecond"],
        &["milliseconds"],
        &["millisecond"],
        &["milliseconds"],
        &["militant"],
        &["military"],
        &["million"],
        &["millisecond"],
        &["milliseconds"],
        &["millisecond"],
        &["milliseconds"],
    ],
    range: 2..=9,
};

static WORD_MILK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MILK_CHILDREN),
    value: None,
};

pub static WORD_MILK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("toast"),
        dictgen::InsensitiveStr::Ascii("toasts"),
    ],
    values: &[&["milquetoast"], &["milquetoasts"]],
    range: 5..=6,
};

static WORD_MILI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MILI_CHILDREN),
    value: None,
};

pub static WORD_MILI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ary"),
        dictgen::InsensitiveStr::Ascii("cious"),
        dictgen::InsensitiveStr::Ascii("ciousally"),
        dictgen::InsensitiveStr::Ascii("ciously"),
        dictgen::InsensitiveStr::Ascii("cous"),
        dictgen::InsensitiveStr::Ascii("cousally"),
        dictgen::InsensitiveStr::Ascii("cously"),
        dictgen::InsensitiveStr::Ascii("gram"),
        dictgen::InsensitiveStr::Ascii("itas"),
        dictgen::InsensitiveStr::Ascii("meter"),
        dictgen::InsensitiveStr::Ascii("meters"),
        dictgen::InsensitiveStr::Ascii("metre"),
        dictgen::InsensitiveStr::Ascii("metres"),
        dictgen::InsensitiveStr::Ascii("miters"),
        dictgen::InsensitiveStr::Ascii("on"),
        dictgen::InsensitiveStr::Ascii("raty"),
        dictgen::InsensitiveStr::Ascii("second"),
        dictgen::InsensitiveStr::Ascii("seconds"),
        dictgen::InsensitiveStr::Ascii("secons"),
        dictgen::InsensitiveStr::Ascii("tais"),
        dictgen::InsensitiveStr::Ascii("tat"),
        dictgen::InsensitiveStr::Ascii("tiades"),
        dictgen::InsensitiveStr::Ascii("tians"),
        dictgen::InsensitiveStr::Ascii("tiants"),
        dictgen::InsensitiveStr::Ascii("tis"),
        dictgen::InsensitiveStr::Ascii("volts"),
    ],
    values: &[
        &["military"],
        &["malicious"],
        &["maliciously"],
        &["maliciously"],
        &["malicious"],
        &["maliciously"],
        &["maliciously"],
        &["milligram"],
        &["militias"],
        &["millimeter"],
        &["millimeters"],
        &["millimetre"],
        &["millimetres"],
        &["millimeters"],
        &["million"],
        &["military"],
        &["millisecond"],
        &["milliseconds"],
        &["milliseconds"],
        &["militias"],
        &["militant"],
        &["militias"],
        &["militias"],
        &["militias"],
        &["militias"],
        &["millivolts"],
    ],
    range: 2..=9,
};

static WORD_MILE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MILE_CHILDREN),
    value: None,
};

pub static WORD_MILE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("au"),
        dictgen::InsensitiveStr::Ascii("nnia"),
        dictgen::InsensitiveStr::Ascii("nnium"),
        dictgen::InsensitiveStr::Ascii("stons"),
        dictgen::InsensitiveStr::Ascii("tsones"),
        dictgen::InsensitiveStr::Ascii("u"),
    ],
    values: &[
        &["milieu"],
        &["millennia"],
        &["millennium"],
        &["milestones"],
        &["milestones"],
        &["milieu"],
    ],
    range: 1..=6,
};

static WORD_MILA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MILA_CHILDREN),
    value: None,
};

pub static WORD_MILA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ge"),
        dictgen::InsensitiveStr::Ascii("ges"),
        dictgen::InsensitiveStr::Ascii("wukee"),
    ],
    values: &[&["mileage"], &["mileages"], &["milwaukee"]],
    range: 2..=5,
};

static WORD_MIK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MIK_CHILDREN),
    value: None,
};

pub static WORD_MIK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("rosecond"),
        dictgen::InsensitiveStr::Ascii("roseconds"),
    ],
    values: &[&["microsecond"], &["microseconds"]],
    range: 8..=9,
};

static WORD_MII_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MII_CHILDREN),
    value: None,
};

pub static WORD_MII_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("nimisation"),
        dictgen::InsensitiveStr::Ascii("nimise"),
        dictgen::InsensitiveStr::Ascii("nimised"),
        dictgen::InsensitiveStr::Ascii("nimises"),
        dictgen::InsensitiveStr::Ascii("nimising"),
        dictgen::InsensitiveStr::Ascii("nimization"),
        dictgen::InsensitiveStr::Ascii("nimize"),
        dictgen::InsensitiveStr::Ascii("nimized"),
        dictgen::InsensitiveStr::Ascii("nimizes"),
        dictgen::InsensitiveStr::Ascii("nimizing"),
        dictgen::InsensitiveStr::Ascii("nimum"),
    ],
    values: &[
        &["minimisation"],
        &["minimise"],
        &["minimised"],
        &["minimises"],
        &["minimising"],
        &["minimization"],
        &["minimize"],
        &["minimized"],
        &["minimizes"],
        &["minimizing"],
        &["minimum"],
    ],
    range: 5..=10,
};

static WORD_MIH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MIH_CHILDREN),
    value: None,
};

pub static WORD_MIH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("t")],
    values: &[&["might"]],
    range: 1..=1,
};

static WORD_MIG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MIG_CHILDREN),
    value: None,
};

pub static WORD_MIG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("h"),
        dictgen::InsensitiveStr::Ascii("itate"),
        dictgen::InsensitiveStr::Ascii("itation"),
        dictgen::InsensitiveStr::Ascii("rainers"),
        dictgen::InsensitiveStr::Ascii("rains"),
        dictgen::InsensitiveStr::Ascii("rans"),
        dictgen::InsensitiveStr::Ascii("rantes"),
        dictgen::InsensitiveStr::Ascii("rateable"),
        dictgen::InsensitiveStr::Ascii("riane"),
        dictgen::InsensitiveStr::Ascii("rianes"),
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("th"),
    ],
    values: &[
        &["midge"],
        &["midges"],
        &["might"],
        &["mitigate"],
        &["mitigation"],
        &["migraines"],
        &["migraines"],
        &["migrants"],
        &["migrants"],
        &["migratable"],
        &["migraine"],
        &["migraines"],
        &["might", "midget"],
        &["might"],
    ],
    range: 1..=8,
};

static WORD_MID_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MID_CHILDREN),
    value: None,
};

pub static WORD_MID_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("del"),
        dictgen::InsensitiveStr::Ascii("dlware"),
        dictgen::InsensitiveStr::Ascii("evil"),
        dictgen::InsensitiveStr::Ascii("feild"),
        dictgen::InsensitiveStr::Ascii("feilder"),
        dictgen::InsensitiveStr::Ascii("feilders"),
        dictgen::InsensitiveStr::Ascii("fied"),
        dictgen::InsensitiveStr::Ascii("fiedler"),
        dictgen::InsensitiveStr::Ascii("fiedlers"),
        dictgen::InsensitiveStr::Ascii("fieldes"),
        dictgen::InsensitiveStr::Ascii("fieldiers"),
        dictgen::InsensitiveStr::Ascii("fielers"),
        dictgen::InsensitiveStr::Ascii("filed"),
        dictgen::InsensitiveStr::Ascii("fileder"),
        dictgen::InsensitiveStr::Ascii("fileders"),
        dictgen::InsensitiveStr::Ascii("ifeld"),
        dictgen::InsensitiveStr::Ascii("ifelder"),
        dictgen::InsensitiveStr::Ascii("ifelders"),
        dictgen::InsensitiveStr::Ascii("ified"),
        dictgen::InsensitiveStr::Ascii("nlessly"),
        dictgen::InsensitiveStr::Ascii("otwn"),
        dictgen::InsensitiveStr::Ascii("pints"),
        dictgen::InsensitiveStr::Ascii("piont"),
        dictgen::InsensitiveStr::Ascii("pionts"),
        dictgen::InsensitiveStr::Ascii("pont"),
        dictgen::InsensitiveStr::Ascii("ponts"),
        dictgen::InsensitiveStr::Ascii("twon"),
    ],
    values: &[
        &["middle"],
        &["middleware"],
        &["medieval"],
        &["midfield"],
        &["midfielder"],
        &["midfielders"],
        &["midfield"],
        &["midfielder"],
        &["midfielders"],
        &["midfielders"],
        &["midfielders"],
        &["midfielders"],
        &["midfield"],
        &["midfielder"],
        &["midfielders"],
        &["midfield"],
        &["midfielder"],
        &["midfielders"],
        &["modified"],
        &["mindlessly"],
        &["midtown"],
        &["midpoints"],
        &["midpoint"],
        &["midpoints"],
        &["midpoint"],
        &["midpoints"],
        &["midtown"],
    ],
    range: 3..=9,
};

static WORD_MIC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_MIC_CHILDREN),
    value: None,
};

static WORD_MIC_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    None,
    None,
    Some(&WORD_MICE_NODE),
    None,
    None,
    Some(&WORD_MICH_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_MICO_NODE),
    None,
    None,
    Some(&WORD_MICR_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_MICR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MICR_CHILDREN),
    value: None,
};

pub static WORD_MICR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("controller"),
        dictgen::InsensitiveStr::Ascii("controllers"),
        dictgen::InsensitiveStr::Ascii("ocender"),
        dictgen::InsensitiveStr::Ascii("ocentre"),
        dictgen::InsensitiveStr::Ascii("ocentres"),
        dictgen::InsensitiveStr::Ascii("ocentro"),
        dictgen::InsensitiveStr::Ascii("ocontroler"),
        dictgen::InsensitiveStr::Ascii("ocontrolers"),
        dictgen::InsensitiveStr::Ascii("ofost"),
        dictgen::InsensitiveStr::Ascii("ohpone"),
        dictgen::InsensitiveStr::Ascii("ohpones"),
        dictgen::InsensitiveStr::Ascii("ontroller"),
        dictgen::InsensitiveStr::Ascii("ontrollers"),
        dictgen::InsensitiveStr::Ascii("ooseconds"),
        dictgen::InsensitiveStr::Ascii("ophen"),
        dictgen::InsensitiveStr::Ascii("ophonies"),
        dictgen::InsensitiveStr::Ascii("opone"),
        dictgen::InsensitiveStr::Ascii("opones"),
        dictgen::InsensitiveStr::Ascii("oprocesspr"),
        dictgen::InsensitiveStr::Ascii("oprocessprs"),
        dictgen::InsensitiveStr::Ascii("oscoop"),
        dictgen::InsensitiveStr::Ascii("oscophic"),
        dictgen::InsensitiveStr::Ascii("oscopice"),
        dictgen::InsensitiveStr::Ascii("oscoptic"),
        dictgen::InsensitiveStr::Ascii("oscrope"),
        dictgen::InsensitiveStr::Ascii("oseond"),
        dictgen::InsensitiveStr::Ascii("oseonds"),
        dictgen::InsensitiveStr::Ascii("osfoft"),
        dictgen::InsensitiveStr::Ascii("osft"),
        dictgen::InsensitiveStr::Ascii("oship"),
        dictgen::InsensitiveStr::Ascii("oships"),
        dictgen::InsensitiveStr::Ascii("osof"),
        dictgen::InsensitiveStr::Ascii("osofot"),
        dictgen::InsensitiveStr::Ascii("ostansactions"),
        dictgen::InsensitiveStr::Ascii("otax"),
        dictgen::InsensitiveStr::Ascii("otramsactions"),
        dictgen::InsensitiveStr::Ascii("otranasctions"),
        dictgen::InsensitiveStr::Ascii("otransacations"),
        dictgen::InsensitiveStr::Ascii("otransacciones"),
        dictgen::InsensitiveStr::Ascii("otransacions"),
        dictgen::InsensitiveStr::Ascii("otransacitons"),
        dictgen::InsensitiveStr::Ascii("otransacrions"),
        dictgen::InsensitiveStr::Ascii("otransacting"),
        dictgen::InsensitiveStr::Ascii("otransactioms"),
        dictgen::InsensitiveStr::Ascii("otransactional"),
        dictgen::InsensitiveStr::Ascii("otransactioned"),
        dictgen::InsensitiveStr::Ascii("otransactios"),
        dictgen::InsensitiveStr::Ascii("otransactiosn"),
        dictgen::InsensitiveStr::Ascii("otransacton"),
        dictgen::InsensitiveStr::Ascii("otransactons"),
        dictgen::InsensitiveStr::Ascii("otransations"),
        dictgen::InsensitiveStr::Ascii("otranscation"),
        dictgen::InsensitiveStr::Ascii("otranscations"),
        dictgen::InsensitiveStr::Ascii("otrasnactions"),
        dictgen::InsensitiveStr::Ascii("ovaves"),
        dictgen::InsensitiveStr::Ascii("ovaxes"),
        dictgen::InsensitiveStr::Ascii("owae"),
        dictgen::InsensitiveStr::Ascii("owavees"),
        dictgen::InsensitiveStr::Ascii("owavers"),
        dictgen::InsensitiveStr::Ascii("pohone"),
        dictgen::InsensitiveStr::Ascii("sft"),
        dictgen::InsensitiveStr::Ascii("soft"),
    ],
    values: &[
        &["microcontroller"],
        &["microcontrollers"],
        &["microcenter"],
        &["microcenter"],
        &["microcenter"],
        &["microcenter"],
        &["microcontroller"],
        &["microcontrollers"],
        &["microsoft"],
        &["microphone"],
        &["microphones"],
        &["microcontroller"],
        &["microcontrollers"],
        &["microseconds"],
        &["microphone"],
        &["microphones"],
        &["microphone"],
        &["microphones"],
        &["microprocessor"],
        &["microprocessors"],
        &["microscope"],
        &["microscopic"],
        &["microscope"],
        &["microscopic"],
        &["microscope"],
        &["microsecond"],
        &["microseconds"],
        &["microsoft"],
        &["microsoft"],
        &["microchip"],
        &["microchips"],
        &["microsoft"],
        &["microsoft"],
        &["microtransactions"],
        &["microatx"],
        &["microtransactions"],
        &["microtransactions"],
        &["microtransactions"],
        &["microtransactions"],
        &["microtransactions"],
        &["microtransactions"],
        &["microtransactions"],
        &["microtransactions"],
        &["microtransactions"],
        &["microtransactions"],
        &["microtransactions"],
        &["microtransactions"],
        &["microtransactions"],
        &["microtransactions"],
        &["microtransactions"],
        &["microtransactions"],
        &["microtransactions"],
        &["microtransactions"],
        &["microtransactions"],
        &["microwaves"],
        &["microwaves"],
        &["microwaves"],
        &["microwaves"],
        &["microwaves"],
        &["microphones"],
        &["microsoft"],
        &["microsoft"],
    ],
    range: 3..=14,
};

static WORD_MICO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MICO_CHILDREN),
    value: None,
};

pub static WORD_MICO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("rcenter"),
        dictgen::InsensitiveStr::Ascii("rcode"),
        dictgen::InsensitiveStr::Ascii("rcodes"),
        dictgen::InsensitiveStr::Ascii("rphones"),
        dictgen::InsensitiveStr::Ascii("rsoft"),
        dictgen::InsensitiveStr::Ascii("rtransactions"),
        dictgen::InsensitiveStr::Ascii("rwave"),
        dictgen::InsensitiveStr::Ascii("rwaves"),
        dictgen::InsensitiveStr::Ascii("scope"),
        dictgen::InsensitiveStr::Ascii("scopes"),
        dictgen::InsensitiveStr::Ascii("scopic"),
        dictgen::InsensitiveStr::Ascii("scopies"),
        dictgen::InsensitiveStr::Ascii("scopy"),
        dictgen::InsensitiveStr::Ascii("soft"),
    ],
    values: &[
        &["microcenter"],
        &["microcode"],
        &["microcodes"],
        &["microphones"],
        &["microsoft"],
        &["microtransactions"],
        &["microwave"],
        &["microwaves"],
        &["microscope"],
        &["microscopes"],
        &["microscopic"],
        &["microscopies"],
        &["microscopy"],
        &["microsoft"],
    ],
    range: 4..=13,
};

static WORD_MICH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MICH_CHILDREN),
    value: None,
};

pub static WORD_MICH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("agan"),
        dictgen::InsensitiveStr::Ascii("elline"),
        dictgen::InsensitiveStr::Ascii("ellle"),
        dictgen::InsensitiveStr::Ascii("gian"),
        dictgen::InsensitiveStr::Ascii("ina"),
    ],
    values: &[
        &["michigan"],
        &["michelle"],
        &["michelle"],
        &["michigan"],
        &["michigan"],
    ],
    range: 3..=6,
};

static WORD_MICE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MICE_CHILDREN),
    value: None,
};

pub static WORD_MICE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("s")],
    values: &[&["mice"]],
    range: 1..=1,
};

static WORD_MIA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MIA_CHILDREN),
    value: None,
};

pub static WORD_MIA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("gic"),
        dictgen::InsensitiveStr::Ascii("gical"),
        dictgen::InsensitiveStr::Ascii("l"),
    ],
    values: &[&["magic"], &["magical"], &["mail"]],
    range: 1..=5,
};

static WORD_MH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MH_CHILDREN),
    value: None,
};

pub static WORD_MH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ytical")],
    values: &[&["mythical"]],
    range: 6..=6,
};

static WORD_ME_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_ME_CHILDREN),
    value: None,
};

static WORD_ME_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_MEA_NODE),
    Some(&WORD_MEB_NODE),
    Some(&WORD_MEC_NODE),
    Some(&WORD_MED_NODE),
    Some(&WORD_MEE_NODE),
    None,
    Some(&WORD_MEG_NODE),
    Some(&WORD_MEH_NODE),
    Some(&WORD_MEI_NODE),
    None,
    None,
    Some(&WORD_MEL_NODE),
    Some(&WORD_MEM_NODE),
    Some(&WORD_MEN_NODE),
    Some(&WORD_MEO_NODE),
    None,
    None,
    Some(&WORD_MER_NODE),
    Some(&WORD_MES_NODE),
    Some(&WORD_MET_NODE),
    None,
    None,
    None,
    Some(&WORD_MEX_NODE),
    Some(&WORD_MEY_NODE),
    Some(&WORD_MEZ_NODE),
];

static WORD_MEZ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MEZ_CHILDREN),
    value: None,
};

pub static WORD_MEZ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("morise"),
        dictgen::InsensitiveStr::Ascii("morised"),
        dictgen::InsensitiveStr::Ascii("moriser"),
        dictgen::InsensitiveStr::Ascii("morises"),
        dictgen::InsensitiveStr::Ascii("morising"),
        dictgen::InsensitiveStr::Ascii("morize"),
        dictgen::InsensitiveStr::Ascii("morized"),
        dictgen::InsensitiveStr::Ascii("morizer"),
        dictgen::InsensitiveStr::Ascii("morizes"),
        dictgen::InsensitiveStr::Ascii("morizing"),
    ],
    values: &[
        &["mesmerise"],
        &["mesmerised"],
        &["mesmeriser"],
        &["mesmerises"],
        &["mesmerising"],
        &["mesmerize"],
        &["mesmerized"],
        &["mesmerizer"],
        &["mesmerizes"],
        &["mesmerizing"],
    ],
    range: 6..=8,
};

static WORD_MEY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MEY_CHILDREN),
    value: Some(&["may"]),
};

pub static WORD_MEY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("be")],
    values: &[&["maybe"]],
    range: 2..=2,
};

static WORD_MEX_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MEX_CHILDREN),
    value: None,
};

pub static WORD_MEX_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cian"),
        dictgen::InsensitiveStr::Ascii("cians"),
        dictgen::InsensitiveStr::Ascii("icain"),
        dictgen::InsensitiveStr::Ascii("icanas"),
        dictgen::InsensitiveStr::Ascii("icanese"),
        dictgen::InsensitiveStr::Ascii("icaness"),
        dictgen::InsensitiveStr::Ascii("icants"),
        dictgen::InsensitiveStr::Ascii("icanus"),
    ],
    values: &[
        &["mexican"],
        &["mexicans"],
        &["mexican"],
        &["mexicans"],
        &["mexicans"],
        &["mexicans"],
        &["mexicans"],
        &["mexicans"],
    ],
    range: 4..=7,
};

static WORD_MET_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_MET_CHILDREN),
    value: None,
};

static WORD_MET_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_META_NODE),
    None,
    None,
    Some(&WORD_METD_NODE),
    Some(&WORD_METE_NODE),
    None,
    None,
    Some(&WORD_METH_NODE),
    Some(&WORD_METI_NODE),
    None,
    None,
    Some(&WORD_METL_NODE),
    None,
    None,
    Some(&WORD_METO_NODE),
    None,
    None,
    Some(&WORD_METR_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_METR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_METR_CHILDREN),
    value: None,
};

pub static WORD_METR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("apolis"),
        dictgen::InsensitiveStr::Ascii("icas"),
        dictgen::InsensitiveStr::Ascii("ices"),
        dictgen::InsensitiveStr::Ascii("ig"),
        dictgen::InsensitiveStr::Ascii("igal"),
        dictgen::InsensitiveStr::Ascii("igs"),
        dictgen::InsensitiveStr::Ascii("ololitan"),
        dictgen::InsensitiveStr::Ascii("olopis"),
        dictgen::InsensitiveStr::Ascii("opilis"),
        dictgen::InsensitiveStr::Ascii("opilitan"),
        dictgen::InsensitiveStr::Ascii("oplois"),
        dictgen::InsensitiveStr::Ascii("oploitan"),
        dictgen::InsensitiveStr::Ascii("opolian"),
        dictgen::InsensitiveStr::Ascii("opolians"),
        dictgen::InsensitiveStr::Ascii("opolies"),
        dictgen::InsensitiveStr::Ascii("opolin"),
        dictgen::InsensitiveStr::Ascii("opolitain"),
        dictgen::InsensitiveStr::Ascii("opolitaine"),
        dictgen::InsensitiveStr::Ascii("opolitcan"),
        dictgen::InsensitiveStr::Ascii("opoliten"),
        dictgen::InsensitiveStr::Ascii("opolitian"),
        dictgen::InsensitiveStr::Ascii("opolitin"),
        dictgen::InsensitiveStr::Ascii("opoliton"),
        dictgen::InsensitiveStr::Ascii("opollis"),
        dictgen::InsensitiveStr::Ascii("opolois"),
        dictgen::InsensitiveStr::Ascii("opolos"),
        dictgen::InsensitiveStr::Ascii("opols"),
        dictgen::InsensitiveStr::Ascii("opolys"),
        dictgen::InsensitiveStr::Ascii("opos"),
    ],
    values: &[
        &["metropolis"],
        &["metrics"],
        &["metrics"],
        &["metric"],
        &["metrical"],
        &["metrics"],
        &["metropolitan"],
        &["metropolis"],
        &["metropolis"],
        &["metropolitan"],
        &["metropolis"],
        &["metropolitan"],
        &["metropolitan"],
        &["metropolis"],
        &["metropolis"],
        &["metropolitan"],
        &["metropolitan"],
        &["metropolitan"],
        &["metropolitan"],
        &["metropolitan"],
        &["metropolitan"],
        &["metropolitan"],
        &["metropolitan"],
        &["metropolis"],
        &["metropolis"],
        &["metropolis"],
        &["metropolis"],
        &["metropolis"],
        &["metropolis"],
    ],
    range: 2..=10,
};

static WORD_METO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_METO_CHILDREN),
    value: None,
};

pub static WORD_METO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("d"),
        dictgen::InsensitiveStr::Ascii("dologies"),
        dictgen::InsensitiveStr::Ascii("dology"),
        dictgen::InsensitiveStr::Ascii("ds"),
        dictgen::InsensitiveStr::Ascii("phorical"),
        dictgen::InsensitiveStr::Ascii("phorically"),
        dictgen::InsensitiveStr::Ascii("rpolitan"),
    ],
    values: &[
        &["method"],
        &["methodologies"],
        &["methodology"],
        &["methods"],
        &["metaphorical"],
        &["metaphorically"],
        &["metropolitan"],
    ],
    range: 1..=10,
};

static WORD_METL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_METL_CHILDREN),
    value: None,
};

pub static WORD_METL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("down")],
    values: &[&["meltdown"]],
    range: 4..=4,
};

static WORD_METI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_METI_CHILDREN),
    value: None,
};

pub static WORD_METI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cs"),
        dictgen::InsensitiveStr::Ascii("for"),
        dictgen::InsensitiveStr::Ascii("fors"),
        dictgen::InsensitiveStr::Ascii("on"),
        dictgen::InsensitiveStr::Ascii("oned"),
        dictgen::InsensitiveStr::Ascii("phor"),
        dictgen::InsensitiveStr::Ascii("phorical"),
        dictgen::InsensitiveStr::Ascii("phorically"),
        dictgen::InsensitiveStr::Ascii("phors"),
    ],
    values: &[
        &["metrics"],
        &["metaphor"],
        &["metaphors"],
        &["mention"],
        &["mentioned"],
        &["metaphor"],
        &["metaphorical"],
        &["metaphorically"],
        &["metaphors"],
    ],
    range: 2..=10,
};

static WORD_METH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_METH_CHILDREN),
    value: None,
};

pub static WORD_METH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("amatician"),
        dictgen::InsensitiveStr::Ascii("aphor"),
        dictgen::InsensitiveStr::Ascii("aphors"),
        dictgen::InsensitiveStr::Ascii("apor"),
        dictgen::InsensitiveStr::Ascii("aporical"),
        dictgen::InsensitiveStr::Ascii("aporically"),
        dictgen::InsensitiveStr::Ascii("apors"),
        dictgen::InsensitiveStr::Ascii("d"),
        dictgen::InsensitiveStr::Ascii("do"),
        dictgen::InsensitiveStr::Ascii("dod"),
        dictgen::InsensitiveStr::Ascii("dos"),
        dictgen::InsensitiveStr::Ascii("ds"),
        dictgen::InsensitiveStr::Ascii("ematical"),
        dictgen::InsensitiveStr::Ascii("ematician"),
        dictgen::InsensitiveStr::Ascii("id"),
        dictgen::InsensitiveStr::Ascii("ids"),
        dictgen::InsensitiveStr::Ascii("jod"),
        dictgen::InsensitiveStr::Ascii("odd"),
        dictgen::InsensitiveStr::Ascii("ode"),
        dictgen::InsensitiveStr::Ascii("oden"),
        dictgen::InsensitiveStr::Ascii("odolgy"),
        dictgen::InsensitiveStr::Ascii("odoligy"),
        dictgen::InsensitiveStr::Ascii("odoloy"),
        dictgen::InsensitiveStr::Ascii("odoly"),
        dictgen::InsensitiveStr::Ascii("odss"),
        dictgen::InsensitiveStr::Ascii("olodogy"),
        dictgen::InsensitiveStr::Ascii("on"),
        dictgen::InsensitiveStr::Ascii("ons"),
        dictgen::InsensitiveStr::Ascii("os"),
        dictgen::InsensitiveStr::Ascii("ot"),
        dictgen::InsensitiveStr::Ascii("ots"),
        dictgen::InsensitiveStr::Ascii("pd"),
        dictgen::InsensitiveStr::Ascii("pds"),
    ],
    values: &[
        &["mathematician"],
        &["metaphor"],
        &["metaphors"],
        &["metaphor"],
        &["metaphorical"],
        &["metaphorically"],
        &["metaphors"],
        &["method"],
        &["method"],
        &["method", "methods"],
        &["methods"],
        &["methods"],
        &["mathematical"],
        &["mathematician"],
        &["method"],
        &["methods"],
        &["method"],
        &["method"],
        &["method"],
        &["methods"],
        &["methodology"],
        &["methodology"],
        &["methodology"],
        &["methodology"],
        &["methods"],
        &["methodology"],
        &["method"],
        &["methods"],
        &["methods", "method"],
        &["method"],
        &["methods"],
        &["method"],
        &["methods"],
    ],
    range: 1..=10,
};

static WORD_METE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_METE_CHILDREN),
    value: None,
};

pub static WORD_METE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("phorical"),
        dictgen::InsensitiveStr::Ascii("phorically"),
        dictgen::InsensitiveStr::Ascii("physical"),
        dictgen::InsensitiveStr::Ascii("rial"),
        dictgen::InsensitiveStr::Ascii("rials"),
        dictgen::InsensitiveStr::Ascii("rologist"),
        dictgen::InsensitiveStr::Ascii("rology"),
        dictgen::InsensitiveStr::Ascii("rosexual"),
    ],
    values: &[
        &["metaphorical"],
        &["metaphorically"],
        &["metaphysical"],
        &["material"],
        &["materials"],
        &["meteorologist"],
        &["meteorology"],
        &["heterosexual"],
    ],
    range: 4..=10,
};

static WORD_METD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_METD_CHILDREN),
    value: None,
};

pub static WORD_METD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ata")],
    values: &[&["metadata"]],
    range: 3..=3,
};

static WORD_META_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_META_CHILDREN),
    value: None,
};

pub static WORD_META_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("balism"),
        dictgen::InsensitiveStr::Ascii("bilism"),
        dictgen::InsensitiveStr::Ascii("bloic"),
        dictgen::InsensitiveStr::Ascii("bloism"),
        dictgen::InsensitiveStr::Ascii("blosim"),
        dictgen::InsensitiveStr::Ascii("bolics"),
        dictgen::InsensitiveStr::Ascii("bolisim"),
        dictgen::InsensitiveStr::Ascii("bolitic"),
        dictgen::InsensitiveStr::Ascii("bolizm"),
        dictgen::InsensitiveStr::Ascii("bolsim"),
        dictgen::InsensitiveStr::Ascii("charater"),
        dictgen::InsensitiveStr::Ascii("charaters"),
        dictgen::InsensitiveStr::Ascii("da"),
        dictgen::InsensitiveStr::Ascii("dta"),
        dictgen::InsensitiveStr::Ascii("gaem"),
        dictgen::InsensitiveStr::Ascii("gem"),
        dictgen::InsensitiveStr::Ascii("hpor"),
        dictgen::InsensitiveStr::Ascii("lic"),
        dictgen::InsensitiveStr::Ascii("lurgic"),
        dictgen::InsensitiveStr::Ascii("lurgical"),
        dictgen::InsensitiveStr::Ascii("lurgy"),
        dictgen::InsensitiveStr::Ascii("mage"),
        dictgen::InsensitiveStr::Ascii("morphysis"),
        dictgen::InsensitiveStr::Ascii("packge"),
        dictgen::InsensitiveStr::Ascii("packges"),
        dictgen::InsensitiveStr::Ascii("phisical"),
        dictgen::InsensitiveStr::Ascii("phisics"),
        dictgen::InsensitiveStr::Ascii("phoras"),
        dictgen::InsensitiveStr::Ascii("phore"),
        dictgen::InsensitiveStr::Ascii("phores"),
        dictgen::InsensitiveStr::Ascii("phorial"),
        dictgen::InsensitiveStr::Ascii("phoricaly"),
        dictgen::InsensitiveStr::Ascii("phoricial"),
        dictgen::InsensitiveStr::Ascii("phoricly"),
        dictgen::InsensitiveStr::Ascii("phorics"),
        dictgen::InsensitiveStr::Ascii("photically"),
        dictgen::InsensitiveStr::Ascii("phsyical"),
        dictgen::InsensitiveStr::Ascii("phsyics"),
        dictgen::InsensitiveStr::Ascii("phyics"),
        dictgen::InsensitiveStr::Ascii("phyiscal"),
        dictgen::InsensitiveStr::Ascii("phyiscs"),
        dictgen::InsensitiveStr::Ascii("physcial"),
        dictgen::InsensitiveStr::Ascii("physicals"),
        dictgen::InsensitiveStr::Ascii("physicans"),
        dictgen::InsensitiveStr::Ascii("physisch"),
        dictgen::InsensitiveStr::Ascii("progamming"),
        dictgen::InsensitiveStr::Ascii("tada"),
        dictgen::InsensitiveStr::Ascii("tadata"),
        dictgen::InsensitiveStr::Ascii("tata"),
        dictgen::InsensitiveStr::Ascii("tdata"),
    ],
    values: &[
        &["metabolism"],
        &["metabolism"],
        &["metabolic"],
        &["metabolism"],
        &["metabolism"],
        &["metabolism"],
        &["metabolism"],
        &["metabolic"],
        &["metabolism"],
        &["metabolism"],
        &["metacharacter"],
        &["metacharacters"],
        &["metadata"],
        &["metadata"],
        &["metagame"],
        &["metagame"],
        &["metaphor"],
        &["metallic"],
        &["metallurgic"],
        &["metallurgical"],
        &["metallurgy"],
        &["metagame"],
        &["metamorphosis"],
        &["metapackage"],
        &["metapackages"],
        &["metaphysical"],
        &["metaphysics"],
        &["metaphors"],
        &["metaphor"],
        &["metaphors"],
        &["metaphorical"],
        &["metaphorically"],
        &["metaphorical"],
        &["metaphorical"],
        &["metaphors"],
        &["metaphorically"],
        &["metaphysical"],
        &["metaphysics"],
        &["metaphysics"],
        &["metaphysical"],
        &["metaphysics"],
        &["metaphysical"],
        &["metaphysics"],
        &["metaphysics"],
        &["metaphysics"],
        &["metaprogramming"],
        &["metadata"],
        &["metadata"],
        &["metadata"],
        &["metadata"],
    ],
    range: 2..=10,
};

static WORD_MES_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MES_CHILDREN),
    value: None,
};

pub static WORD_MES_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("age"),
        dictgen::InsensitiveStr::Ascii("ages"),
        dictgen::InsensitiveStr::Ascii("aureed"),
        dictgen::InsensitiveStr::Ascii("he"),
        dictgen::InsensitiveStr::Ascii("keeto"),
        dictgen::InsensitiveStr::Ascii("keetos"),
        dictgen::InsensitiveStr::Ascii("oneen"),
        dictgen::InsensitiveStr::Ascii("oneens"),
        dictgen::InsensitiveStr::Ascii("sae"),
        dictgen::InsensitiveStr::Ascii("saes"),
        dictgen::InsensitiveStr::Ascii("sag"),
        dictgen::InsensitiveStr::Ascii("sagd"),
        dictgen::InsensitiveStr::Ascii("sagease"),
        dictgen::InsensitiveStr::Ascii("sagepad"),
        dictgen::InsensitiveStr::Ascii("sagers"),
        dictgen::InsensitiveStr::Ascii("sagetqueue"),
        dictgen::InsensitiveStr::Ascii("sagin"),
        dictgen::InsensitiveStr::Ascii("sagoe"),
        dictgen::InsensitiveStr::Ascii("sags"),
        dictgen::InsensitiveStr::Ascii("sagses"),
        dictgen::InsensitiveStr::Ascii("saih"),
        dictgen::InsensitiveStr::Ascii("sanger"),
        dictgen::InsensitiveStr::Ascii("sangers"),
        dictgen::InsensitiveStr::Ascii("save"),
        dictgen::InsensitiveStr::Ascii("seges"),
        dictgen::InsensitiveStr::Ascii("senging"),
        dictgen::InsensitiveStr::Ascii("sgae"),
        dictgen::InsensitiveStr::Ascii("sgaed"),
        dictgen::InsensitiveStr::Ascii("sgaes"),
        dictgen::InsensitiveStr::Ascii("sge"),
        dictgen::InsensitiveStr::Ascii("sges"),
        dictgen::InsensitiveStr::Ascii("siach"),
        dictgen::InsensitiveStr::Ascii("sqage"),
        dictgen::InsensitiveStr::Ascii("ssage"),
        dictgen::InsensitiveStr::Ascii("ssages"),
        dictgen::InsensitiveStr::Ascii("sure"),
        dictgen::InsensitiveStr::Ascii("sured"),
        dictgen::InsensitiveStr::Ascii("surement"),
        dictgen::InsensitiveStr::Ascii("sures"),
        dictgen::InsensitiveStr::Ascii("suring"),
        dictgen::InsensitiveStr::Ascii("surment"),
        dictgen::InsensitiveStr::Ascii("ure"),
        dictgen::InsensitiveStr::Ascii("ured"),
        dictgen::InsensitiveStr::Ascii("urement"),
        dictgen::InsensitiveStr::Ascii("urements"),
        dictgen::InsensitiveStr::Ascii("ures"),
        dictgen::InsensitiveStr::Ascii("uring"),
        dictgen::InsensitiveStr::Ascii("urment"),
    ],
    values: &[
        &["message"],
        &["messages"],
        &["measured"],
        &["mesh", "meshed", "meshes"],
        &["mosquito"],
        &["mosquitoes"],
        &["mezzanine"],
        &["mezzanines"],
        &["message", "messy"],
        &["messages"],
        &["message"],
        &["messaged"],
        &["messages"],
        &["messaged"],
        &["messages"],
        &["messagequeue"],
        &["messaging"],
        &["message"],
        &["messages"],
        &["messages"],
        &["messiah"],
        &["messenger"],
        &["messengers"],
        &["message"],
        &["messages"],
        &["messaging"],
        &["message"],
        &["messaged"],
        &["messages"],
        &["message"],
        &["messages"],
        &["messiah"],
        &["message"],
        &["message"],
        &["messages"],
        &["measure"],
        &["measured"],
        &["measurement"],
        &["measures"],
        &["measuring"],
        &["measurement"],
        &["measure"],
        &["measured"],
        &["measurement"],
        &["measurements"],
        &["measures"],
        &["measuring"],
        &["measurement"],
    ],
    range: 2..=10,
};

static WORD_MER_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MER_CHILDREN),
    value: None,
};

pub static WORD_MER_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aj"),
        dictgen::InsensitiveStr::Ascii("ajes"),
        dictgen::InsensitiveStr::Ascii("anda"),
        dictgen::InsensitiveStr::Ascii("ang"),
        dictgen::InsensitiveStr::Ascii("cahnt"),
        dictgen::InsensitiveStr::Ascii("canaries"),
        dictgen::InsensitiveStr::Ascii("caneries"),
        dictgen::InsensitiveStr::Ascii("canery"),
        dictgen::InsensitiveStr::Ascii("cenaire"),
        dictgen::InsensitiveStr::Ascii("cenaires"),
        dictgen::InsensitiveStr::Ascii("cenares"),
        dictgen::InsensitiveStr::Ascii("cenarias"),
        dictgen::InsensitiveStr::Ascii("cenarios"),
        dictgen::InsensitiveStr::Ascii("ceneries"),
        dictgen::InsensitiveStr::Ascii("centile"),
        dictgen::InsensitiveStr::Ascii("chandice"),
        dictgen::InsensitiveStr::Ascii("chandies"),
        dictgen::InsensitiveStr::Ascii("chanidse"),
        dictgen::InsensitiveStr::Ascii("chanise"),
        dictgen::InsensitiveStr::Ascii("chans"),
        dictgen::InsensitiveStr::Ascii("chanters"),
        dictgen::InsensitiveStr::Ascii("chantibility"),
        dictgen::InsensitiveStr::Ascii("chantos"),
        dictgen::InsensitiveStr::Ascii("chat"),
        dictgen::InsensitiveStr::Ascii("chendise"),
        dictgen::InsensitiveStr::Ascii("chindise"),
        dictgen::InsensitiveStr::Ascii("cinaries"),
        dictgen::InsensitiveStr::Ascii("cineries"),
        dictgen::InsensitiveStr::Ascii("curcy"),
        dictgen::InsensitiveStr::Ascii("curey"),
        dictgen::InsensitiveStr::Ascii("ecat"),
        dictgen::InsensitiveStr::Ascii("ecats"),
        dictgen::InsensitiveStr::Ascii("ficul"),
        dictgen::InsensitiveStr::Ascii("gable"),
        dictgen::InsensitiveStr::Ascii("get"),
        dictgen::InsensitiveStr::Ascii("gge"),
        dictgen::InsensitiveStr::Ascii("gged"),
        dictgen::InsensitiveStr::Ascii("gging"),
        dictgen::InsensitiveStr::Ascii("hcant"),
        dictgen::InsensitiveStr::Ascii("hcants"),
        dictgen::InsensitiveStr::Ascii("icful"),
        dictgen::InsensitiveStr::Ascii("ly"),
        dictgen::InsensitiveStr::Ascii("mory"),
        dictgen::InsensitiveStr::Ascii("ory"),
        dictgen::InsensitiveStr::Ascii("rors"),
        dictgen::InsensitiveStr::Ascii("ucry"),
    ],
    values: &[
        &["mirage"],
        &["mirages"],
        &["veranda", "miranda"],
        &["meringue"],
        &["merchant"],
        &["mercenaries"],
        &["mercenaries"],
        &["mercenary"],
        &["mercenaries"],
        &["mercenaries"],
        &["mercenaries"],
        &["mercenaries"],
        &["mercenaries"],
        &["mercenaries"],
        &["mercantile"],
        &["merchandise"],
        &["merchandise"],
        &["merchandise"],
        &["merchandise"],
        &["merchants"],
        &["merchants"],
        &["merchantability"],
        &["merchants"],
        &["merchant"],
        &["merchandise"],
        &["merchandise"],
        &["mercenaries"],
        &["mercenaries"],
        &["mercury"],
        &["mercury"],
        &["meerkat"],
        &["meerkats"],
        &["merciful"],
        &["mergeable"],
        &["merge"],
        &["merge"],
        &["merged"],
        &["merging"],
        &["merchant"],
        &["merchants"],
        &["merciful"],
        &["merely", "formerly"],
        &["memory"],
        &["memory"],
        &["mirrors"],
        &["mercury"],
    ],
    range: 2..=12,
};

static WORD_MEO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MEO_CHILDREN),
    value: None,
};

pub static WORD_MEO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ldic"),
        dictgen::InsensitiveStr::Ascii("ldies"),
        dictgen::InsensitiveStr::Ascii("ry"),
    ],
    values: &[&["melodic"], &["melodies"], &["maori", "memory"]],
    range: 2..=5,
};

static WORD_MEN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MEN_CHILDREN),
    value: None,
};

pub static WORD_MEN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ally"),
        dictgen::InsensitiveStr::Ascii("as"),
        dictgen::InsensitiveStr::Ascii("ber"),
        dictgen::InsensitiveStr::Ascii("caing"),
        dictgen::InsensitiveStr::Ascii("etion"),
        dictgen::InsensitiveStr::Ascii("etioned"),
        dictgen::InsensitiveStr::Ascii("etioning"),
        dictgen::InsensitiveStr::Ascii("etions"),
        dictgen::InsensitiveStr::Ascii("i"),
        dictgen::InsensitiveStr::Ascii("ion"),
        dictgen::InsensitiveStr::Ascii("ioned"),
        dictgen::InsensitiveStr::Ascii("ions"),
        dictgen::InsensitiveStr::Ascii("sion"),
        dictgen::InsensitiveStr::Ascii("sioned"),
        dictgen::InsensitiveStr::Ascii("sioning"),
        dictgen::InsensitiveStr::Ascii("sions"),
        dictgen::InsensitiveStr::Ascii("straul"),
        dictgen::InsensitiveStr::Ascii("strul"),
        dictgen::InsensitiveStr::Ascii("stural"),
        dictgen::InsensitiveStr::Ascii("sutral"),
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("tallity"),
        dictgen::InsensitiveStr::Ascii("taly"),
        dictgen::InsensitiveStr::Ascii("thods"),
        dictgen::InsensitiveStr::Ascii("tiond"),
        dictgen::InsensitiveStr::Ascii("tione"),
        dictgen::InsensitiveStr::Ascii("tiones"),
        dictgen::InsensitiveStr::Ascii("tiong"),
        dictgen::InsensitiveStr::Ascii("tionned"),
        dictgen::InsensitiveStr::Ascii("tionnes"),
        dictgen::InsensitiveStr::Ascii("tionning"),
        dictgen::InsensitiveStr::Ascii("tionnned"),
        dictgen::InsensitiveStr::Ascii("ual"),
        dictgen::InsensitiveStr::Ascii("ue"),
        dictgen::InsensitiveStr::Ascii("ues"),
        dictgen::InsensitiveStr::Ascii("utitems"),
        dictgen::InsensitiveStr::Ascii("y"),
    ],
    values: &[
        &["mentally"],
        &["means"],
        &["member"],
        &["menacing"],
        &["mention"],
        &["mentioned"],
        &["mentioning"],
        &["mentions"],
        &["menu"],
        &["mention", "minion"],
        &["mentioned"],
        &["mentions", "minions"],
        &["mansion", "mention"],
        &["mentioned"],
        &["mentioning"],
        &["mansions", "mentions"],
        &["menstrual"],
        &["menstrual"],
        &["menstrual"],
        &["menstrual"],
        &["meant"],
        &["mentally"],
        &["mentally"],
        &["methods"],
        &["mentioned"],
        &["mentioned"],
        &["mentions"],
        &["mentioning"],
        &["mentioned"],
        &["mentions"],
        &["mentioning"],
        &["mentioned"],
        &["manual"],
        &["menu"],
        &["menus"],
        &["menuitems"],
        &["menu", "many"],
    ],
    range: 1..=8,
};

static WORD_MEM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MEM_CHILDREN),
    value: None,
};

pub static WORD_MEM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("bershup"),
        dictgen::InsensitiveStr::Ascii("bersip"),
        dictgen::InsensitiveStr::Ascii("bran"),
        dictgen::InsensitiveStr::Ascii("branaphone"),
        dictgen::InsensitiveStr::Ascii("brance"),
        dictgen::InsensitiveStr::Ascii("brances"),
        dictgen::InsensitiveStr::Ascii("brans"),
        dictgen::InsensitiveStr::Ascii("cahe"),
        dictgen::InsensitiveStr::Ascii("cahed"),
        dictgen::InsensitiveStr::Ascii("easurement"),
        dictgen::InsensitiveStr::Ascii("eber"),
        dictgen::InsensitiveStr::Ascii("ebered"),
        dictgen::InsensitiveStr::Ascii("ebers"),
        dictgen::InsensitiveStr::Ascii("ebership"),
        dictgen::InsensitiveStr::Ascii("eberships"),
        dictgen::InsensitiveStr::Ascii("ebr"),
        dictgen::InsensitiveStr::Ascii("ebrof"),
        dictgen::InsensitiveStr::Ascii("ebrs"),
        dictgen::InsensitiveStr::Ascii("ember"),
        dictgen::InsensitiveStr::Ascii("embers"),
        dictgen::InsensitiveStr::Ascii("emory"),
        dictgen::InsensitiveStr::Ascii("emto"),
        dictgen::InsensitiveStr::Ascii("eory"),
        dictgen::InsensitiveStr::Ascii("er"),
        dictgen::InsensitiveStr::Ascii("erization"),
        dictgen::InsensitiveStr::Ascii("ership"),
        dictgen::InsensitiveStr::Ascii("erships"),
        dictgen::InsensitiveStr::Ascii("ery"),
        dictgen::InsensitiveStr::Ascii("ick"),
        dictgen::InsensitiveStr::Ascii("icked"),
        dictgen::InsensitiveStr::Ascii("icking"),
        dictgen::InsensitiveStr::Ascii("ics"),
        dictgen::InsensitiveStr::Ascii("mber"),
        dictgen::InsensitiveStr::Ascii("mick"),
        dictgen::InsensitiveStr::Ascii("micked"),
        dictgen::InsensitiveStr::Ascii("micking"),
        dictgen::InsensitiveStr::Ascii("mics"),
        dictgen::InsensitiveStr::Ascii("mory"),
        dictgen::InsensitiveStr::Ascii("ner"),
        dictgen::InsensitiveStr::Ascii("oery"),
        dictgen::InsensitiveStr::Ascii("omry"),
        dictgen::InsensitiveStr::Ascii("or"),
        dictgen::InsensitiveStr::Ascii("orie"),
        dictgen::InsensitiveStr::Ascii("oriez"),
        dictgen::InsensitiveStr::Ascii("orizacion"),
        dictgen::InsensitiveStr::Ascii("orozation"),
        dictgen::InsensitiveStr::Ascii("oty"),
        dictgen::InsensitiveStr::Ascii("ove"),
        dictgen::InsensitiveStr::Ascii("pry"),
        dictgen::InsensitiveStr::Ascii("roy"),
        dictgen::InsensitiveStr::Ascii("war"),
        dictgen::InsensitiveStr::Ascii("wars"),
        dictgen::InsensitiveStr::Ascii("woir"),
        dictgen::InsensitiveStr::Ascii("woirs"),
    ],
    values: &[
        &["membership"],
        &["membership"],
        &["membrane"],
        &["membranophone"],
        &["membrane"],
        &["membrane"],
        &["membranes"],
        &["memcache"],
        &["memcached"],
        &["measurement"],
        &["member"],
        &["remembered"],
        &["members"],
        &["membership"],
        &["memberships"],
        &["member"],
        &["memberof"],
        &["members"],
        &["member", "remember"],
        &["members", "remembers"],
        &["memory"],
        &["memento"],
        &["memory"],
        &["member"],
        &["memorization"],
        &["membership"],
        &["memberships"],
        &["memory"],
        &["mimic"],
        &["mimicked"],
        &["mimicking"],
        &["mimics"],
        &["member"],
        &["mimic"],
        &["mimicked"],
        &["mimicking"],
        &["mimics"],
        &["memory"],
        &["member"],
        &["memory"],
        &["memory"],
        &["memory"],
        &["memory"],
        &["memorize"],
        &["memorization"],
        &["memorization"],
        &["memory"],
        &["memmove"],
        &["memory"],
        &["memory"],
        &["memoir"],
        &["memoirs"],
        &["memoir"],
        &["memoirs"],
    ],
    range: 2..=10,
};

static WORD_MEL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MEL_CHILDREN),
    value: None,
};

pub static WORD_MEL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ancoly"),
        dictgen::InsensitiveStr::Ascii("anotin"),
        dictgen::InsensitiveStr::Ascii("atonian"),
        dictgen::InsensitiveStr::Ascii("atonion"),
        dictgen::InsensitiveStr::Ascii("borune"),
        dictgen::InsensitiveStr::Ascii("bounre"),
        dictgen::InsensitiveStr::Ascii("boure"),
        dictgen::InsensitiveStr::Ascii("doic"),
        dictgen::InsensitiveStr::Ascii("ieux"),
        dictgen::InsensitiveStr::Ascii("ineum"),
        dictgen::InsensitiveStr::Ascii("ineumm"),
        dictgen::InsensitiveStr::Ascii("ineumms"),
        dictgen::InsensitiveStr::Ascii("ineums"),
        dictgen::InsensitiveStr::Ascii("inneum"),
        dictgen::InsensitiveStr::Ascii("inneums"),
        dictgen::InsensitiveStr::Ascii("lineum"),
        dictgen::InsensitiveStr::Ascii("lineums"),
        dictgen::InsensitiveStr::Ascii("linneum"),
        dictgen::InsensitiveStr::Ascii("linneums"),
        dictgen::InsensitiveStr::Ascii("linnium"),
        dictgen::InsensitiveStr::Ascii("odieuse"),
        dictgen::InsensitiveStr::Ascii("odis"),
        dictgen::InsensitiveStr::Ascii("todwn"),
    ],
    values: &[
        &["melancholy"],
        &["melatonin"],
        &["melatonin"],
        &["melatonin"],
        &["melbourne"],
        &["melbourne"],
        &["melbourne"],
        &["melodic"],
        &["milieux"],
        &["millennium"],
        &["millennia", "millennium"],
        &["millennia"],
        &["millennia"],
        &["millennium"],
        &["millennia"],
        &["millennium"],
        &["millennia"],
        &["millennium"],
        &["millennia"],
        &["millennium"],
        &["melodies"],
        &["melodies"],
        &["meltdown"],
    ],
    range: 4..=8,
};

static WORD_MEI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MEI_CHILDREN),
    value: None,
};

pub static WORD_MEI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("da"),
        dictgen::InsensitiveStr::Ascii("dcare"),
        dictgen::InsensitiveStr::Ascii("ght"),
        dictgen::InsensitiveStr::Ascii("xcan"),
        dictgen::InsensitiveStr::Ascii("xcans"),
    ],
    values: &[
        &["media"],
        &["medicare"],
        &["might"],
        &["mexican"],
        &["mexicans"],
    ],
    range: 2..=5,
};

static WORD_MEH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MEH_CHILDREN),
    value: None,
};

pub static WORD_MEH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("canic"),
        dictgen::InsensitiveStr::Ascii("canical"),
        dictgen::InsensitiveStr::Ascii("canically"),
        dictgen::InsensitiveStr::Ascii("canics"),
        dictgen::InsensitiveStr::Ascii("od"),
        dictgen::InsensitiveStr::Ascii("odical"),
        dictgen::InsensitiveStr::Ascii("odically"),
        dictgen::InsensitiveStr::Ascii("ods"),
        dictgen::InsensitiveStr::Ascii("tod"),
        dictgen::InsensitiveStr::Ascii("todical"),
        dictgen::InsensitiveStr::Ascii("todically"),
        dictgen::InsensitiveStr::Ascii("tods"),
    ],
    values: &[
        &["mechanic"],
        &["mechanical"],
        &["mechanically"],
        &["mechanics"],
        &["method"],
        &["methodical"],
        &["methodically"],
        &["methods"],
        &["method"],
        &["methodical"],
        &["methodically"],
        &["methods"],
    ],
    range: 2..=9,
};

static WORD_MEG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MEG_CHILDREN),
    value: None,
};

pub static WORD_MEG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("anism"),
        dictgen::InsensitiveStr::Ascii("athred"),
        dictgen::InsensitiveStr::Ascii("atorn"),
        dictgen::InsensitiveStr::Ascii("e"),
    ],
    values: &[&["mechanism"], &["megathread"], &["megatron"], &["merge"]],
    range: 1..=6,
};

static WORD_MEE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MEE_CHILDREN),
    value: None,
};

pub static WORD_MEE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ds"),
        dictgen::InsensitiveStr::Ascii("ns"),
        dictgen::InsensitiveStr::Ascii("rkrat"),
        dictgen::InsensitiveStr::Ascii("rly"),
        dictgen::InsensitiveStr::Ascii("thod"),
        dictgen::InsensitiveStr::Ascii("thodology"),
        dictgen::InsensitiveStr::Ascii("thods"),
        dictgen::InsensitiveStr::Ascii("tign"),
    ],
    values: &[
        &["needs"],
        &["means"],
        &["meerkat"],
        &["merely"],
        &["method"],
        &["methodology"],
        &["methods"],
        &["meeting"],
    ],
    range: 2..=9,
};

static WORD_MED_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_MED_CHILDREN),
    value: None,
};

static WORD_MED_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_MEDA_NODE),
    None,
    None,
    Some(&WORD_MEDD_NODE),
    Some(&WORD_MEDE_NODE),
    None,
    None,
    Some(&WORD_MEDH_NODE),
    Some(&WORD_MEDI_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_MEDO_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_MEDO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MEDO_CHILDREN),
    value: None,
};

pub static WORD_MEDO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("icre"),
        dictgen::InsensitiveStr::Ascii("w"),
        dictgen::InsensitiveStr::Ascii("ws"),
    ],
    values: &[&["mediocre"], &["meadow"], &["meadows"]],
    range: 1..=4,
};

static WORD_MEDI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MEDI_CHILDREN),
    value: None,
};

pub static WORD_MEDI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("action"),
        dictgen::InsensitiveStr::Ascii("avel"),
        dictgen::InsensitiveStr::Ascii("cacion"),
        dictgen::InsensitiveStr::Ascii("cad"),
        dictgen::InsensitiveStr::Ascii("cae"),
        dictgen::InsensitiveStr::Ascii("caiton"),
        dictgen::InsensitiveStr::Ascii("caitons"),
        dictgen::InsensitiveStr::Ascii("calert"),
        dictgen::InsensitiveStr::Ascii("callly"),
        dictgen::InsensitiveStr::Ascii("caly"),
        dictgen::InsensitiveStr::Ascii("catons"),
        dictgen::InsensitiveStr::Ascii("ciad"),
        dictgen::InsensitiveStr::Ascii("cince"),
        dictgen::InsensitiveStr::Ascii("cinens"),
        dictgen::InsensitiveStr::Ascii("cineras"),
        dictgen::InsensitiveStr::Ascii("ciney"),
        dictgen::InsensitiveStr::Ascii("cins"),
        dictgen::InsensitiveStr::Ascii("cinske"),
        dictgen::InsensitiveStr::Ascii("core"),
        dictgen::InsensitiveStr::Ascii("cority"),
        dictgen::InsensitiveStr::Ascii("dating"),
        dictgen::InsensitiveStr::Ascii("evel"),
        dictgen::InsensitiveStr::Ascii("for"),
        dictgen::InsensitiveStr::Ascii("fors"),
        dictgen::InsensitiveStr::Ascii("oce"),
        dictgen::InsensitiveStr::Ascii("ocer"),
        dictgen::InsensitiveStr::Ascii("ocirty"),
        dictgen::InsensitiveStr::Ascii("ocraty"),
        dictgen::InsensitiveStr::Ascii("ocrety"),
        dictgen::InsensitiveStr::Ascii("ocricy"),
        dictgen::InsensitiveStr::Ascii("ocrily"),
        dictgen::InsensitiveStr::Ascii("ocrisy"),
        dictgen::InsensitiveStr::Ascii("ocry"),
        dictgen::InsensitiveStr::Ascii("oker"),
        dictgen::InsensitiveStr::Ascii("orce"),
        dictgen::InsensitiveStr::Ascii("phor"),
        dictgen::InsensitiveStr::Ascii("phors"),
        dictgen::InsensitiveStr::Ascii("sinal"),
        dictgen::InsensitiveStr::Ascii("tacion"),
        dictgen::InsensitiveStr::Ascii("taciones"),
        dictgen::InsensitiveStr::Ascii("taiton"),
        dictgen::InsensitiveStr::Ascii("tarrenean"),
        dictgen::InsensitiveStr::Ascii("tatie"),
        dictgen::InsensitiveStr::Ascii("tatiing"),
        dictgen::InsensitiveStr::Ascii("tatin"),
        dictgen::InsensitiveStr::Ascii("tationg"),
        dictgen::InsensitiveStr::Ascii("tato"),
        dictgen::InsensitiveStr::Ascii("terainnean"),
        dictgen::InsensitiveStr::Ascii("teranean"),
        dictgen::InsensitiveStr::Ascii("tereanean"),
        dictgen::InsensitiveStr::Ascii("terraean"),
        dictgen::InsensitiveStr::Ascii("terranen"),
        dictgen::InsensitiveStr::Ascii("terrannean"),
        dictgen::InsensitiveStr::Ascii("veal"),
    ],
    values: &[
        &["medications"],
        &["medieval"],
        &["medication"],
        &["medicaid"],
        &["medicare"],
        &["medication"],
        &["medications"],
        &["medicare"],
        &["medically"],
        &["medically"],
        &["medications"],
        &["medicaid"],
        &["medicine"],
        &["medicines"],
        &["medicines"],
        &["mediciny", "medicine", "medicinal"],
        &["medicines"],
        &["medicine"],
        &["mediocre"],
        &["mediocrity"],
        &["meditating"],
        &["medieval"],
        &["metaphor"],
        &["metaphors"],
        &["mediocre"],
        &["mediocre"],
        &["mediocrity"],
        &["mediocrity"],
        &["mediocrity"],
        &["mediocrity"],
        &["mediocrity"],
        &["mediocrity"],
        &["mediocrity"],
        &["mediocre"],
        &["mediocre"],
        &["metaphor"],
        &["metaphors"],
        &["medicinal"],
        &["medications"],
        &["medications"],
        &["meditation"],
        &["mediterranean"],
        &["meditate"],
        &["meditating"],
        &["meditation"],
        &["meditating"],
        &["meditation"],
        &["mediterranean"],
        &["mediterranean"],
        &["mediterranean"],
        &["mediterranean"],
        &["mediterranean"],
        &["mediterranean"],
        &["medieval"],
    ],
    range: 3..=10,
};

static WORD_MEDH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MEDH_CHILDREN),
    value: None,
};

pub static WORD_MEDH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("od"),
        dictgen::InsensitiveStr::Ascii("ods"),
    ],
    values: &[&["method"], &["methods"]],
    range: 2..=3,
};

static WORD_MEDE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MEDE_CHILDREN),
    value: None,
};

pub static WORD_MEDE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ival"),
        dictgen::InsensitiveStr::Ascii("terranean"),
        dictgen::InsensitiveStr::Ascii("vial"),
    ],
    values: &[&["medieval"], &["mediterranean"], &["medieval"]],
    range: 4..=9,
};

static WORD_MEDD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MEDD_CHILDREN),
    value: None,
};

pub static WORD_MEDD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("o"),
        dictgen::InsensitiveStr::Ascii("os"),
    ],
    values: &[&["meadow"], &["meadows"]],
    range: 1..=2,
};

static WORD_MEDA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MEDA_CHILDREN),
    value: Some(&["medal", "media", "meta"]),
};

pub static WORD_MEDA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cine"),
        dictgen::InsensitiveStr::Ascii("i"),
        dictgen::InsensitiveStr::Ascii("tite"),
    ],
    values: &[&["medicine"], &["media"], &["meditate"]],
    range: 1..=4,
};

static WORD_MEC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MEC_CHILDREN),
    value: None,
};

pub static WORD_MEC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ahinsm"),
        dictgen::InsensitiveStr::Ascii("ahinsms"),
        dictgen::InsensitiveStr::Ascii("ahnic"),
        dictgen::InsensitiveStr::Ascii("ahnical"),
        dictgen::InsensitiveStr::Ascii("ahnically"),
        dictgen::InsensitiveStr::Ascii("ahnics"),
        dictgen::InsensitiveStr::Ascii("ahnism"),
        dictgen::InsensitiveStr::Ascii("ahnisms"),
        dictgen::InsensitiveStr::Ascii("anical"),
        dictgen::InsensitiveStr::Ascii("anism"),
        dictgen::InsensitiveStr::Ascii("anisms"),
        dictgen::InsensitiveStr::Ascii("cob"),
        dictgen::InsensitiveStr::Ascii("ernaries"),
        dictgen::InsensitiveStr::Ascii("ernary"),
        dictgen::InsensitiveStr::Ascii("hamism"),
        dictgen::InsensitiveStr::Ascii("hamisms"),
        dictgen::InsensitiveStr::Ascii("hananism"),
        dictgen::InsensitiveStr::Ascii("hancial"),
        dictgen::InsensitiveStr::Ascii("hancially"),
        dictgen::InsensitiveStr::Ascii("hancis"),
        dictgen::InsensitiveStr::Ascii("handise"),
        dictgen::InsensitiveStr::Ascii("hanicallly"),
        dictgen::InsensitiveStr::Ascii("hanicaly"),
        dictgen::InsensitiveStr::Ascii("hanichal"),
        dictgen::InsensitiveStr::Ascii("hanichs"),
        dictgen::InsensitiveStr::Ascii("hanicle"),
        dictgen::InsensitiveStr::Ascii("haniclly"),
        dictgen::InsensitiveStr::Ascii("hanicly"),
        dictgen::InsensitiveStr::Ascii("hanicsms"),
        dictgen::InsensitiveStr::Ascii("hanicus"),
        dictgen::InsensitiveStr::Ascii("hanim"),
        dictgen::InsensitiveStr::Ascii("hanims"),
        dictgen::InsensitiveStr::Ascii("haninc"),
        dictgen::InsensitiveStr::Ascii("hanincs"),
        dictgen::InsensitiveStr::Ascii("hanis"),
        dictgen::InsensitiveStr::Ascii("hanisim"),
        dictgen::InsensitiveStr::Ascii("hanisims"),
        dictgen::InsensitiveStr::Ascii("hanismn"),
        dictgen::InsensitiveStr::Ascii("hanismus"),
        dictgen::InsensitiveStr::Ascii("hansim"),
        dictgen::InsensitiveStr::Ascii("hansims"),
        dictgen::InsensitiveStr::Ascii("hine"),
        dictgen::InsensitiveStr::Ascii("hines"),
        dictgen::InsensitiveStr::Ascii("hinical"),
        dictgen::InsensitiveStr::Ascii("hinism"),
        dictgen::InsensitiveStr::Ascii("hinisms"),
        dictgen::InsensitiveStr::Ascii("hnanism"),
        dictgen::InsensitiveStr::Ascii("hnism"),
        dictgen::InsensitiveStr::Ascii("hnisms"),
    ],
    values: &[
        &["mechanism"],
        &["mechanisms"],
        &["mechanic"],
        &["mechanical"],
        &["mechanically"],
        &["mechanics"],
        &["mechanism"],
        &["mechanisms"],
        &["mechanical"],
        &["mechanism"],
        &["mechanisms"],
        &["macabre"],
        &["mercenaries"],
        &["mercenary"],
        &["mechanism"],
        &["mechanisms"],
        &["mechanism"],
        &["mechanical"],
        &["mechanically"],
        &["mechanics"],
        &["merchandise"],
        &["mechanically"],
        &["mechanically"],
        &["mechanical"],
        &["mechanics"],
        &["mechanical"],
        &["mechanically"],
        &["mechanical"],
        &["mechanisms"],
        &["mechanics"],
        &["mechanism"],
        &["mechanism", "mechanisms"],
        &["mechanic"],
        &["mechanic"],
        &["mechanics", "mechanism"],
        &["mechanism"],
        &["mechanism"],
        &["mechanism"],
        &["mechanisms"],
        &["mechanism"],
        &["mechanisms"],
        &["machine"],
        &["machines"],
        &["mechanical"],
        &["mechanism"],
        &["mechanisms"],
        &["mechanism"],
        &["mechanism"],
        &["mechanisms"],
    ],
    range: 3..=10,
};

static WORD_MEB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MEB_CHILDREN),
    value: None,
};

pub static WORD_MEB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("er"),
        dictgen::InsensitiveStr::Ascii("mer"),
        dictgen::InsensitiveStr::Ascii("rain"),
        dictgen::InsensitiveStr::Ascii("rains"),
        dictgen::InsensitiveStr::Ascii("ran"),
        dictgen::InsensitiveStr::Ascii("rans"),
    ],
    values: &[
        &["member"],
        &["member"],
        &["membrane"],
        &["membranes"],
        &["membrane"],
        &["membranes"],
    ],
    range: 2..=5,
};

static WORD_MEA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_MEA_CHILDREN),
    value: None,
};

static WORD_MEA_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_MEAA_NODE),
    None,
    Some(&WORD_MEAC_NODE),
    Some(&WORD_MEAD_NODE),
    None,
    None,
    Some(&WORD_MEAG_NODE),
    None,
    Some(&WORD_MEAI_NODE),
    None,
    None,
    Some(&WORD_MEAL_NODE),
    None,
    Some(&WORD_MEAN_NODE),
    None,
    None,
    None,
    Some(&WORD_MEAR_NODE),
    Some(&WORD_MEAS_NODE),
    Some(&WORD_MEAT_NODE),
    Some(&WORD_MEAU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_MEAU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MEAU_CHILDREN),
    value: None,
};

pub static WORD_MEAU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("re"),
        dictgen::InsensitiveStr::Ascii("red"),
        dictgen::InsensitiveStr::Ascii("rement"),
        dictgen::InsensitiveStr::Ascii("rements"),
        dictgen::InsensitiveStr::Ascii("rer"),
        dictgen::InsensitiveStr::Ascii("rers"),
        dictgen::InsensitiveStr::Ascii("res"),
        dictgen::InsensitiveStr::Ascii("ring"),
        dictgen::InsensitiveStr::Ascii("sure"),
        dictgen::InsensitiveStr::Ascii("sures"),
    ],
    values: &[
        &["measure"],
        &["measured"],
        &["measurement"],
        &["measurements"],
        &["measurer"],
        &["measurers"],
        &["measures"],
        &["measuring"],
        &["measure"],
        &["measures"],
    ],
    range: 2..=7,
};

static WORD_MEAT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MEAT_CHILDREN),
    value: None,
};

pub static WORD_MEAT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("adata"),
        dictgen::InsensitiveStr::Ascii("ballers"),
        dictgen::InsensitiveStr::Ascii("ballls"),
        dictgen::InsensitiveStr::Ascii("bals"),
        dictgen::InsensitiveStr::Ascii("file"),
        dictgen::InsensitiveStr::Ascii("hod"),
    ],
    values: &[
        &["metadata"],
        &["meatballs"],
        &["meatballs"],
        &["meatballs"],
        &["metafile"],
        &["method"],
    ],
    range: 3..=7,
};

static WORD_MEAS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MEAS_CHILDREN),
    value: None,
};

pub static WORD_MEAS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("surable"),
        dictgen::InsensitiveStr::Ascii("surably"),
        dictgen::InsensitiveStr::Ascii("sure"),
        dictgen::InsensitiveStr::Ascii("sured"),
        dictgen::InsensitiveStr::Ascii("surement"),
        dictgen::InsensitiveStr::Ascii("surements"),
        dictgen::InsensitiveStr::Ascii("sures"),
        dictgen::InsensitiveStr::Ascii("suring"),
        dictgen::InsensitiveStr::Ascii("ue"),
        dictgen::InsensitiveStr::Ascii("ued"),
        dictgen::InsensitiveStr::Ascii("uement"),
        dictgen::InsensitiveStr::Ascii("uements"),
        dictgen::InsensitiveStr::Ascii("uer"),
        dictgen::InsensitiveStr::Ascii("ues"),
        dictgen::InsensitiveStr::Ascii("uing"),
        dictgen::InsensitiveStr::Ascii("urd"),
        dictgen::InsensitiveStr::Ascii("uremenet"),
        dictgen::InsensitiveStr::Ascii("uremenets"),
        dictgen::InsensitiveStr::Ascii("urmenet"),
        dictgen::InsensitiveStr::Ascii("urmenets"),
        dictgen::InsensitiveStr::Ascii("urment"),
        dictgen::InsensitiveStr::Ascii("urments"),
    ],
    values: &[
        &["measurable"],
        &["measurably"],
        &["measure"],
        &["measured"],
        &["measurement"],
        &["measurements"],
        &["measures"],
        &["measuring"],
        &["measure"],
        &["measured"],
        &["measurement"],
        &["measurements"],
        &["measure", "measurer"],
        &["measures"],
        &["measuring"],
        &["measured", "measure"],
        &["measurement"],
        &["measurements"],
        &["measurement"],
        &["measurements"],
        &["measurement"],
        &["measurements"],
    ],
    range: 2..=9,
};

static WORD_MEAR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MEAR_CHILDREN),
    value: Some(&["wear", "mere", "mare"]),
};

pub static WORD_MEAR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ly")],
    values: &[&["merely", "nearly"]],
    range: 2..=2,
};

static WORD_MEAN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MEAN_CHILDREN),
    value: None,
};

pub static WORD_MEAN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cing"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("igfull"),
        dictgen::InsensitiveStr::Ascii("ign"),
        dictgen::InsensitiveStr::Ascii("in"),
        dictgen::InsensitiveStr::Ascii("inful"),
        dictgen::InsensitiveStr::Ascii("ingess"),
        dictgen::InsensitiveStr::Ascii("ingfull"),
        dictgen::InsensitiveStr::Ascii("ingles"),
        dictgen::InsensitiveStr::Ascii("ining"),
        dictgen::InsensitiveStr::Ascii("inless"),
        dictgen::InsensitiveStr::Ascii("inng"),
        dictgen::InsensitiveStr::Ascii("ins"),
        dictgen::InsensitiveStr::Ascii("ting"),
    ],
    values: &[
        &["menacing"],
        &["meant"],
        &["meaningful"],
        &["meaning"],
        &["meaning"],
        &["meaningful"],
        &["meanings"],
        &["meaningful"],
        &["meanings"],
        &["meaning"],
        &["meaningless"],
        &["meaning"],
        &["meanings"],
        &["meaning"],
    ],
    range: 2..=7,
};

static WORD_MEAL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MEAL_CHILDREN),
    value: None,
};

pub static WORD_MEAL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("flur")],
    values: &[&["millefleur"]],
    range: 4..=4,
};

static WORD_MEAI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MEAI_CHILDREN),
    value: None,
};

pub static WORD_MEAI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ng")],
    values: &[&["meaning"]],
    range: 2..=2,
};

static WORD_MEAG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MEAG_CHILDREN),
    value: None,
};

pub static WORD_MEAG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("thread"),
        dictgen::InsensitiveStr::Ascii("tron"),
    ],
    values: &[&["megathread"], &["megatron"]],
    range: 4..=6,
};

static WORD_MEAD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MEAD_CHILDREN),
    value: None,
};

pub static WORD_MEAD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ing")],
    values: &[&["meaning"]],
    range: 3..=3,
};

static WORD_MEAC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MEAC_CHILDREN),
    value: None,
};

pub static WORD_MEAC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("hanism"),
        dictgen::InsensitiveStr::Ascii("hanisms"),
        dictgen::InsensitiveStr::Ascii("hinism"),
        dictgen::InsensitiveStr::Ascii("hinisms"),
        dictgen::InsensitiveStr::Ascii("hnism"),
        dictgen::InsensitiveStr::Ascii("hnisms"),
    ],
    values: &[
        &["mechanism"],
        &["mechanisms"],
        &["mechanism"],
        &["mechanisms"],
        &["mechanism"],
        &["mechanisms"],
    ],
    range: 5..=7,
};

static WORD_MEAA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MEAA_CHILDREN),
    value: None,
};

pub static WORD_MEAA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("sure"),
        dictgen::InsensitiveStr::Ascii("sured"),
        dictgen::InsensitiveStr::Ascii("sures"),
    ],
    values: &[&["measure"], &["measured"], &["measures"]],
    range: 4..=5,
};

static WORD_MD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MD_CHILDREN),
    value: None,
};

pub static WORD_MD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ification"),
        dictgen::InsensitiveStr::Ascii("ifications"),
        dictgen::InsensitiveStr::Ascii("ified"),
        dictgen::InsensitiveStr::Ascii("ifielder"),
        dictgen::InsensitiveStr::Ascii("ifielders"),
        dictgen::InsensitiveStr::Ascii("ifier"),
        dictgen::InsensitiveStr::Ascii("ifiers"),
        dictgen::InsensitiveStr::Ascii("ifies"),
        dictgen::InsensitiveStr::Ascii("ify"),
        dictgen::InsensitiveStr::Ascii("ifying"),
        dictgen::InsensitiveStr::Ascii("oe"),
        dictgen::InsensitiveStr::Ascii("oel"),
        dictgen::InsensitiveStr::Ascii("oeled"),
        dictgen::InsensitiveStr::Ascii("oeling"),
        dictgen::InsensitiveStr::Ascii("oelled"),
        dictgen::InsensitiveStr::Ascii("oelling"),
        dictgen::InsensitiveStr::Ascii("oels"),
        dictgen::InsensitiveStr::Ascii("oes"),
    ],
    values: &[
        &["modification"],
        &["modifications"],
        &["modified"],
        &["midfielder"],
        &["midfielders"],
        &["modifier"],
        &["modifiers"],
        &["modifies"],
        &["modify"],
        &["modifying"],
        &["doe", "mode"],
        &["model"],
        &["modeled"],
        &["modeling"],
        &["modelled"],
        &["modelling"],
        &["models"],
        &["does", "modes"],
    ],
    range: 2..=10,
};

static WORD_MC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MC_CHILDREN),
    value: None,
};

pub static WORD_MC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("alren"),
        dictgen::InsensitiveStr::Ascii("carhty"),
        dictgen::InsensitiveStr::Ascii("carthey"),
        dictgen::InsensitiveStr::Ascii("carthyst"),
        dictgen::InsensitiveStr::Ascii("gergor"),
        dictgen::InsensitiveStr::Ascii("hanic"),
        dictgen::InsensitiveStr::Ascii("hanical"),
        dictgen::InsensitiveStr::Ascii("hanically"),
        dictgen::InsensitiveStr::Ascii("hanicals"),
        dictgen::InsensitiveStr::Ascii("hanics"),
        dictgen::InsensitiveStr::Ascii("hanism"),
        dictgen::InsensitiveStr::Ascii("hanisms"),
        dictgen::InsensitiveStr::Ascii("larean"),
        dictgen::InsensitiveStr::Ascii("reggor"),
        dictgen::InsensitiveStr::Ascii("roscope"),
        dictgen::InsensitiveStr::Ascii("roscopes"),
        dictgen::InsensitiveStr::Ascii("roscopic"),
        dictgen::InsensitiveStr::Ascii("roscopies"),
        dictgen::InsensitiveStr::Ascii("roscopy"),
    ],
    values: &[
        &["mclaren"],
        &["mccarthy"],
        &["mccarthy"],
        &["mccarthyist"],
        &["mcgregor"],
        &["mechanic"],
        &["mechanical"],
        &["mechanically"],
        &["mechanicals"],
        &["mechanics"],
        &["mechanism"],
        &["mechanisms"],
        &["mclaren"],
        &["mcgregor"],
        &["microscope"],
        &["microscopes"],
        &["microscopic"],
        &["microscopies"],
        &["microscopy"],
    ],
    range: 5..=9,
};

static WORD_MA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_MA_CHILDREN),
    value: None,
};

static WORD_MA_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_MAA_NODE),
    Some(&WORD_MAB_NODE),
    Some(&WORD_MAC_NODE),
    Some(&WORD_MAD_NODE),
    Some(&WORD_MAE_NODE),
    None,
    Some(&WORD_MAG_NODE),
    Some(&WORD_MAH_NODE),
    Some(&WORD_MAI_NODE),
    Some(&WORD_MAJ_NODE),
    Some(&WORD_MAK_NODE),
    Some(&WORD_MAL_NODE),
    Some(&WORD_MAM_NODE),
    Some(&WORD_MAN_NODE),
    None,
    Some(&WORD_MAP_NODE),
    None,
    Some(&WORD_MAR_NODE),
    Some(&WORD_MAS_NODE),
    Some(&WORD_MAT_NODE),
    Some(&WORD_MAU_NODE),
    Some(&WORD_MAV_NODE),
    Some(&WORD_MAW_NODE),
    Some(&WORD_MAX_NODE),
    Some(&WORD_MAY_NODE),
    Some(&WORD_MAZ_NODE),
];

static WORD_MAZ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MAZ_CHILDREN),
    value: None,
};

pub static WORD_MAZ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("illa")],
    values: &[&["mozilla"]],
    range: 4..=4,
};

static WORD_MAY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MAY_CHILDREN),
    value: None,
};

pub static WORD_MAY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("alsia"),
        dictgen::InsensitiveStr::Ascii("alsian"),
        dictgen::InsensitiveStr::Ascii("balline"),
        dictgen::InsensitiveStr::Ascii("bed"),
        dictgen::InsensitiveStr::Ascii("bee"),
        dictgen::InsensitiveStr::Ascii("belle"),
        dictgen::InsensitiveStr::Ascii("belleine"),
        dictgen::InsensitiveStr::Ascii("bellene"),
        dictgen::InsensitiveStr::Ascii("bellibe"),
        dictgen::InsensitiveStr::Ascii("belliene"),
        dictgen::InsensitiveStr::Ascii("bellinne"),
        dictgen::InsensitiveStr::Ascii("bellline"),
        dictgen::InsensitiveStr::Ascii("billine"),
        dictgen::InsensitiveStr::Ascii("lasia"),
        dictgen::InsensitiveStr::Ascii("lasian"),
        dictgen::InsensitiveStr::Ascii("onase"),
        dictgen::InsensitiveStr::Ascii("ority"),
        dictgen::InsensitiveStr::Ascii("u"),
        dictgen::InsensitiveStr::Ascii("ybe"),
    ],
    values: &[
        &["malaysia"],
        &["malaysian"],
        &["maybelline"],
        &["maybe"],
        &["maybe"],
        &["maybelline"],
        &["maybelline"],
        &["maybelline"],
        &["maybelline"],
        &["maybelline"],
        &["maybelline"],
        &["maybelline"],
        &["maybelline"],
        &["malaysia"],
        &["malaysian"],
        &["mayonnaise"],
        &["majority"],
        &["may"],
        &["maybe"],
    ],
    range: 1..=8,
};

static WORD_MAX_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MAX_CHILDREN),
    value: None,
};

pub static WORD_MAX_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("imazing"),
        dictgen::InsensitiveStr::Ascii("imice"),
        dictgen::InsensitiveStr::Ascii("imim"),
        dictgen::InsensitiveStr::Ascii("imimum"),
        dictgen::InsensitiveStr::Ascii("imini"),
        dictgen::InsensitiveStr::Ascii("imium"),
        dictgen::InsensitiveStr::Ascii("imixing"),
        dictgen::InsensitiveStr::Ascii("imnum"),
        dictgen::InsensitiveStr::Ascii("imnums"),
        dictgen::InsensitiveStr::Ascii("imun"),
        dictgen::InsensitiveStr::Ascii("inum"),
        dictgen::InsensitiveStr::Ascii("ium"),
        dictgen::InsensitiveStr::Ascii("iumum"),
        dictgen::InsensitiveStr::Ascii("mimum"),
        dictgen::InsensitiveStr::Ascii("mium"),
        dictgen::InsensitiveStr::Ascii("miums"),
        dictgen::InsensitiveStr::Ascii("osx"),
        dictgen::InsensitiveStr::Ascii("umum"),
    ],
    values: &[
        &["maximizing"],
        &["maximize"],
        &["maximum"],
        &["maximum"],
        &["maximizing"],
        &["maximum"],
        &["maximizing"],
        &["maximum"],
        &["maximums"],
        &["maximum"],
        &["maximum"],
        &["maximum"],
        &["maximum"],
        &["maximum"],
        &["maximum"],
        &["maximums"],
        &["macosx"],
        &["maximum"],
    ],
    range: 3..=7,
};

static WORD_MAW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MAW_CHILDREN),
    value: None,
};

pub static WORD_MAW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("soleum")],
    values: &[&["mausoleum"]],
    range: 6..=6,
};

static WORD_MAV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MAV_CHILDREN),
    value: None,
};

pub static WORD_MAV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("rick")],
    values: &[&["maverick"]],
    range: 4..=4,
};

static WORD_MAU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MAU_CHILDREN),
    value: None,
};

pub static WORD_MAU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("arder"),
        dictgen::InsensitiveStr::Ascii("be"),
        dictgen::InsensitiveStr::Ascii("nals"),
    ],
    values: &[&["marauder"], &["maybe", "mauve"], &["manuals"]],
    range: 2..=5,
};

static WORD_MAT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_MAT_CHILDREN),
    value: None,
};

static WORD_MAT_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_MATA_NODE),
    None,
    Some(&WORD_MATC_NODE),
    None,
    Some(&WORD_MATE_NODE),
    None,
    None,
    Some(&WORD_MATH_NODE),
    Some(&WORD_MATI_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_MATR_NODE),
    Some(&WORD_MATS_NODE),
    Some(&WORD_MATT_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_MATZ_NODE),
];

static WORD_MATZ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MATZ_CHILDREN),
    value: None,
};

pub static WORD_MATZ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ch")],
    values: &[&["match"]],
    range: 2..=2,
};

static WORD_MATT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MATT_CHILDREN),
    value: None,
};

pub static WORD_MATT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ern"),
        dictgen::InsensitiveStr::Ascii("erns"),
        dictgen::InsensitiveStr::Ascii("erss"),
        dictgen::InsensitiveStr::Ascii("reses"),
    ],
    values: &[
        &["matter", "pattern"],
        &["matters", "patterns"],
        &["mattress"],
        &["mattress"],
    ],
    range: 3..=5,
};

static WORD_MATS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MATS_CHILDREN),
    value: None,
};

pub static WORD_MATS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("er")],
    values: &[&["master"]],
    range: 2..=2,
};

static WORD_MATR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MATR_CHILDREN),
    value: None,
};

pub static WORD_MATR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eial"),
        dictgen::InsensitiveStr::Ascii("eials"),
        dictgen::InsensitiveStr::Ascii("esses"),
        dictgen::InsensitiveStr::Ascii("ial"),
        dictgen::InsensitiveStr::Ascii("ials"),
        dictgen::InsensitiveStr::Ascii("icess"),
        dictgen::InsensitiveStr::Ascii("ie"),
        dictgen::InsensitiveStr::Ascii("is"),
    ],
    values: &[
        &["material"],
        &["materials"],
        &["mattresses"],
        &["martial", "material"],
        &["materials"],
        &["matrices", "mattresses"],
        &["matrix"],
        &["matrix"],
    ],
    range: 2..=5,
};

static WORD_MATI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MATI_CHILDREN),
    value: None,
};

pub static WORD_MATI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eral"),
        dictgen::InsensitiveStr::Ascii("eralism"),
        dictgen::InsensitiveStr::Ascii("erals"),
        dictgen::InsensitiveStr::Ascii("nay"),
        dictgen::InsensitiveStr::Ascii("rx"),
        dictgen::InsensitiveStr::Ascii("x"),
    ],
    values: &[
        &["material"],
        &["materialism"],
        &["materials"],
        &["matinee"],
        &["matrix"],
        &["matrix"],
    ],
    range: 1..=7,
};

static WORD_MATH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MATH_CHILDREN),
    value: None,
};

pub static WORD_MATH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("amatician"),
        dictgen::InsensitiveStr::Ascii("amatics"),
        dictgen::InsensitiveStr::Ascii("ametician"),
        dictgen::InsensitiveStr::Ascii("ameticians"),
        dictgen::InsensitiveStr::Ascii("c"),
        dictgen::InsensitiveStr::Ascii("ced"),
        dictgen::InsensitiveStr::Ascii("cer"),
        dictgen::InsensitiveStr::Ascii("cers"),
        dictgen::InsensitiveStr::Ascii("ces"),
        dictgen::InsensitiveStr::Ascii("ch"),
        dictgen::InsensitiveStr::Ascii("ched"),
        dictgen::InsensitiveStr::Ascii("ches"),
        dictgen::InsensitiveStr::Ascii("ching"),
        dictgen::InsensitiveStr::Ascii("cing"),
        dictgen::InsensitiveStr::Ascii("cmaking"),
        dictgen::InsensitiveStr::Ascii("cup"),
        dictgen::InsensitiveStr::Ascii("cups"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("emagically"),
        dictgen::InsensitiveStr::Ascii("emagics"),
        dictgen::InsensitiveStr::Ascii("emathics"),
        dictgen::InsensitiveStr::Ascii("ematicals"),
        dictgen::InsensitiveStr::Ascii("ematicaly"),
        dictgen::InsensitiveStr::Ascii("ematican"),
        dictgen::InsensitiveStr::Ascii("ematicans"),
        dictgen::InsensitiveStr::Ascii("ematicas"),
        dictgen::InsensitiveStr::Ascii("ematicion"),
        dictgen::InsensitiveStr::Ascii("ematicks"),
        dictgen::InsensitiveStr::Ascii("ematicly"),
        dictgen::InsensitiveStr::Ascii("ematisch"),
        dictgen::InsensitiveStr::Ascii("ematitian"),
        dictgen::InsensitiveStr::Ascii("ematitians"),
        dictgen::InsensitiveStr::Ascii("emetical"),
        dictgen::InsensitiveStr::Ascii("emetically"),
        dictgen::InsensitiveStr::Ascii("emetician"),
        dictgen::InsensitiveStr::Ascii("emeticians"),
        dictgen::InsensitiveStr::Ascii("emetics"),
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("etician"),
        dictgen::InsensitiveStr::Ascii("eticians"),
        dictgen::InsensitiveStr::Ascii("ewes"),
        dictgen::InsensitiveStr::Ascii("imatic"),
        dictgen::InsensitiveStr::Ascii("imatical"),
        dictgen::InsensitiveStr::Ascii("imatically"),
        dictgen::InsensitiveStr::Ascii("imatician"),
        dictgen::InsensitiveStr::Ascii("imaticians"),
        dictgen::InsensitiveStr::Ascii("imatics"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("matical"),
        dictgen::InsensitiveStr::Ascii("matically"),
        dictgen::InsensitiveStr::Ascii("matician"),
        dictgen::InsensitiveStr::Ascii("maticians"),
        dictgen::InsensitiveStr::Ascii("od"),
        dictgen::InsensitiveStr::Ascii("ods"),
        dictgen::InsensitiveStr::Ascii("wes"),
    ],
    values: &[
        &["mathematician"],
        &["mathematics"],
        &["mathematician"],
        &["mathematicians"],
        &["match"],
        &["matched"],
        &["matcher"],
        &["matchers"],
        &["matches"],
        &["match"],
        &["matched"],
        &["matches"],
        &["matching"],
        &["matching"],
        &["matchmaking"],
        &["matchup"],
        &["matchups"],
        &["matched"],
        &["mathematically"],
        &["mathematics"],
        &["mathematics"],
        &["mathematics"],
        &["mathematically"],
        &["mathematician"],
        &["mathematics"],
        &["mathematics"],
        &["mathematician"],
        &["mathematics"],
        &["mathematical"],
        &["mathematics"],
        &["mathematician"],
        &["mathematicians"],
        &["mathematical"],
        &["mathematically"],
        &["mathematician"],
        &["mathematicians"],
        &["mathematics"],
        &["matches"],
        &["mathematician"],
        &["mathematicians"],
        &["mathews"],
        &["mathematic"],
        &["mathematical"],
        &["mathematically"],
        &["mathematician"],
        &["mathematicians"],
        &["mathematics"],
        &["matching"],
        &["mathematical"],
        &["mathematically"],
        &["mathematician"],
        &["mathematicians"],
        &["method"],
        &["methods"],
        &["mathews"],
    ],
    range: 1..=10,
};

static WORD_MATE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MATE_CHILDREN),
    value: None,
};

pub static WORD_MATE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ial"),
        dictgen::InsensitiveStr::Ascii("ials"),
        dictgen::InsensitiveStr::Ascii("iral"),
        dictgen::InsensitiveStr::Ascii("irals"),
        dictgen::InsensitiveStr::Ascii("mathical"),
        dictgen::InsensitiveStr::Ascii("raial"),
        dictgen::InsensitiveStr::Ascii("raials"),
        dictgen::InsensitiveStr::Ascii("rail"),
        dictgen::InsensitiveStr::Ascii("rails"),
        dictgen::InsensitiveStr::Ascii("ralists"),
        dictgen::InsensitiveStr::Ascii("riaal"),
        dictgen::InsensitiveStr::Ascii("riales"),
        dictgen::InsensitiveStr::Ascii("rialisimo"),
        dictgen::InsensitiveStr::Ascii("rialsim"),
        dictgen::InsensitiveStr::Ascii("rialsm"),
        dictgen::InsensitiveStr::Ascii("rias"),
        dictgen::InsensitiveStr::Ascii("riasl"),
        dictgen::InsensitiveStr::Ascii("ril"),
        dictgen::InsensitiveStr::Ascii("rilism"),
        dictgen::InsensitiveStr::Ascii("rilize"),
        dictgen::InsensitiveStr::Ascii("rils"),
        dictgen::InsensitiveStr::Ascii("rla"),
        dictgen::InsensitiveStr::Ascii("rlas"),
    ],
    values: &[
        &["material", "metal"],
        &["materials", "metals"],
        &["material"],
        &["materials"],
        &["mathematical"],
        &["material"],
        &["materials"],
        &["material"],
        &["materials"],
        &["materialist"],
        &["material"],
        &["materials"],
        &["materialism"],
        &["materialism"],
        &["materialism"],
        &["materials"],
        &["materials", "material"],
        &["material"],
        &["materialism"],
        &["materialize"],
        &["materials"],
        &["material"],
        &["materials"],
    ],
    range: 3..=9,
};

static WORD_MATC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MATC_CHILDREN),
    value: Some(&["match"]),
};

pub static WORD_MATC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("hamking"),
        dictgen::InsensitiveStr::Ascii("hies"),
        dictgen::InsensitiveStr::Ascii("hign"),
        dictgen::InsensitiveStr::Ascii("hin"),
        dictgen::InsensitiveStr::Ascii("hine"),
        dictgen::InsensitiveStr::Ascii("hmakeing"),
        dictgen::InsensitiveStr::Ascii("hs"),
        dictgen::InsensitiveStr::Ascii("hter"),
        dictgen::InsensitiveStr::Ascii("ing"),
    ],
    values: &[
        &["matchmaking"],
        &["matches"],
        &["matching"],
        &["matching"],
        &["machine", "matching"],
        &["matchmaking"],
        &["matches"],
        &["matcher"],
        &["matching"],
    ],
    range: 2..=8,
};

static WORD_MATA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MATA_CHILDREN),
    value: Some(&["meta", "mater"]),
};

pub static WORD_MATA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("data"),
        dictgen::InsensitiveStr::Ascii("iner"),
        dictgen::InsensitiveStr::Ascii("iners"),
        dictgen::InsensitiveStr::Ascii("phorical"),
        dictgen::InsensitiveStr::Ascii("phorically"),
        dictgen::InsensitiveStr::Ascii("physical"),
        dictgen::InsensitiveStr::Ascii("table"),
    ],
    values: &[
        &["metadata"],
        &["maintainer"],
        &["maintainers"],
        &["metaphorical"],
        &["metaphorically"],
        &["metaphysical"],
        &["metatable"],
    ],
    range: 4..=10,
};

static WORD_MAS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_MAS_CHILDREN),
    value: None,
};

static WORD_MAS_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_MASA_NODE),
    None,
    Some(&WORD_MASC_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_MASH_NODE),
    Some(&WORD_MASI_NODE),
    None,
    Some(&WORD_MASK_NODE),
    None,
    None,
    None,
    Some(&WORD_MASO_NODE),
    None,
    Some(&WORD_MASQ_NODE),
    Some(&WORD_MASR_NODE),
    Some(&WORD_MASS_NODE),
    Some(&WORD_MAST_NODE),
    Some(&WORD_MASU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_MASU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MASU_CHILDREN),
    value: None,
};

pub static WORD_MASU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("clinity")],
    values: &[&["masculinity"]],
    range: 7..=7,
};

static WORD_MAST_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MAST_CHILDREN),
    value: None,
};

pub static WORD_MAST_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eer"),
        dictgen::InsensitiveStr::Ascii("eires"),
        dictgen::InsensitiveStr::Ascii("erbation"),
        dictgen::InsensitiveStr::Ascii("ereis"),
        dictgen::InsensitiveStr::Ascii("eriers"),
        dictgen::InsensitiveStr::Ascii("eris"),
        dictgen::InsensitiveStr::Ascii("erise"),
        dictgen::InsensitiveStr::Ascii("ermid"),
        dictgen::InsensitiveStr::Ascii("ermined"),
        dictgen::InsensitiveStr::Ascii("ernind"),
        dictgen::InsensitiveStr::Ascii("erpeace"),
        dictgen::InsensitiveStr::Ascii("erpeice"),
        dictgen::InsensitiveStr::Ascii("erpeices"),
        dictgen::InsensitiveStr::Ascii("erpice"),
        dictgen::InsensitiveStr::Ascii("ieres"),
        dictgen::InsensitiveStr::Ascii("querade"),
        dictgen::InsensitiveStr::Ascii("rubate"),
        dictgen::InsensitiveStr::Ascii("rubated"),
        dictgen::InsensitiveStr::Ascii("rubates"),
        dictgen::InsensitiveStr::Ascii("rubating"),
        dictgen::InsensitiveStr::Ascii("rubation"),
        dictgen::InsensitiveStr::Ascii("ubrate"),
        dictgen::InsensitiveStr::Ascii("ubration"),
        dictgen::InsensitiveStr::Ascii("urabte"),
        dictgen::InsensitiveStr::Ascii("urabted"),
        dictgen::InsensitiveStr::Ascii("urabting"),
        dictgen::InsensitiveStr::Ascii("urabtion"),
        dictgen::InsensitiveStr::Ascii("urbacion"),
        dictgen::InsensitiveStr::Ascii("urbae"),
        dictgen::InsensitiveStr::Ascii("urbaing"),
        dictgen::InsensitiveStr::Ascii("urbait"),
        dictgen::InsensitiveStr::Ascii("urbaited"),
        dictgen::InsensitiveStr::Ascii("urbare"),
        dictgen::InsensitiveStr::Ascii("urbarte"),
        dictgen::InsensitiveStr::Ascii("urbateing"),
        dictgen::InsensitiveStr::Ascii("urbathe"),
        dictgen::InsensitiveStr::Ascii("urbathon"),
        dictgen::InsensitiveStr::Ascii("urbatie"),
        dictgen::InsensitiveStr::Ascii("urbatin"),
        dictgen::InsensitiveStr::Ascii("urbaton"),
        dictgen::InsensitiveStr::Ascii("urbe"),
        dictgen::InsensitiveStr::Ascii("urbeta"),
        dictgen::InsensitiveStr::Ascii("urbsted"),
        dictgen::InsensitiveStr::Ascii("urbsting"),
        dictgen::InsensitiveStr::Ascii("urdate"),
        dictgen::InsensitiveStr::Ascii("urdating"),
        dictgen::InsensitiveStr::Ascii("urpiece"),
        dictgen::InsensitiveStr::Ascii("utbation"),
    ],
    values: &[
        &["master"],
        &["masteries"],
        &["masturbation"],
        &["masteries"],
        &["masteries"],
        &["masteries"],
        &["masteries"],
        &["mastermind"],
        &["mastermind"],
        &["mastermind"],
        &["masterpiece"],
        &["masterpiece"],
        &["masterpiece"],
        &["masterpiece"],
        &["masteries"],
        &["masquerade"],
        &["masturbate"],
        &["masturbated"],
        &["masturbate"],
        &["masturbating"],
        &["masturbation"],
        &["masturbated"],
        &["masturbation"],
        &["masturbate"],
        &["masturbated"],
        &["masturbating"],
        &["masturbation"],
        &["masturbation"],
        &["masturbated"],
        &["masturbating"],
        &["masturbate"],
        &["masturbated"],
        &["masturbate"],
        &["masturbate"],
        &["masturbating"],
        &["masturbated"],
        &["masturbation"],
        &["masturbated"],
        &["masturbation"],
        &["masturbation"],
        &["masturbate"],
        &["masturbated"],
        &["masturbated"],
        &["masturbating"],
        &["masturbate"],
        &["masturbating"],
        &["masterpiece"],
        &["masturbation"],
    ],
    range: 3..=9,
};

static WORD_MASS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MASS_CHILDREN),
    value: None,
};

pub static WORD_MASS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ace"),
        dictgen::InsensitiveStr::Ascii("acer"),
        dictgen::InsensitiveStr::Ascii("achsuetts"),
        dictgen::InsensitiveStr::Ascii("achucetts"),
        dictgen::InsensitiveStr::Ascii("achuestts"),
        dictgen::InsensitiveStr::Ascii("achusents"),
        dictgen::InsensitiveStr::Ascii("achusets"),
        dictgen::InsensitiveStr::Ascii("achusettes"),
        dictgen::InsensitiveStr::Ascii("achusettians"),
        dictgen::InsensitiveStr::Ascii("achusites"),
        dictgen::InsensitiveStr::Ascii("achussets"),
        dictgen::InsensitiveStr::Ascii("achussetts"),
        dictgen::InsensitiveStr::Ascii("achustts"),
        dictgen::InsensitiveStr::Ascii("acrare"),
        dictgen::InsensitiveStr::Ascii("agebox"),
        dictgen::InsensitiveStr::Ascii("agens"),
        dictgen::InsensitiveStr::Ascii("arce"),
        dictgen::InsensitiveStr::Ascii("asge"),
        dictgen::InsensitiveStr::Ascii("care"),
        dictgen::InsensitiveStr::Ascii("echusetts"),
        dictgen::InsensitiveStr::Ascii("ectomy"),
        dictgen::InsensitiveStr::Ascii("ewer"),
        dictgen::InsensitiveStr::Ascii("ivelly"),
        dictgen::InsensitiveStr::Ascii("ivley"),
        dictgen::InsensitiveStr::Ascii("oose"),
        dictgen::InsensitiveStr::Ascii("ter"),
    ],
    values: &[
        &["massacre"],
        &["massacre"],
        &["massachusetts"],
        &["massachusetts"],
        &["massachusetts"],
        &["massachusetts"],
        &["massachusetts"],
        &["massachusetts"],
        &["massachusetts"],
        &["massachusetts"],
        &["massachusetts"],
        &["massachusetts"],
        &["massachusetts"],
        &["massacre"],
        &["messagebox"],
        &["massages"],
        &["massacre"],
        &["massages"],
        &["massacre"],
        &["massachusetts"],
        &["mastectomy"],
        &["masseur"],
        &["massively"],
        &["massively"],
        &["masseuse"],
        &["master"],
    ],
    range: 3..=12,
};

static WORD_MASR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MASR_CHILDREN),
    value: None,
};

pub static WORD_MASR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("hmallow")],
    values: &[&["marshmallow"]],
    range: 7..=7,
};

static WORD_MASQ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MASQ_CHILDREN),
    value: None,
};

pub static WORD_MASQ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("uarade"),
        dictgen::InsensitiveStr::Ascii("urade"),
    ],
    values: &[&["masquerade"], &["masquerade"]],
    range: 5..=6,
};

static WORD_MASO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MASO_CHILDREN),
    value: None,
};

pub static WORD_MASO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ginistic"),
        dictgen::InsensitiveStr::Ascii("gynistic"),
        dictgen::InsensitiveStr::Ascii("s"),
    ],
    values: &[&["misogynistic"], &["misogynistic"], &["macos"]],
    range: 1..=8,
};

static WORD_MASK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MASK_CHILDREN),
    value: None,
};

pub static WORD_MASK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("erading"),
        dictgen::InsensitiveStr::Ascii("eraid"),
    ],
    values: &[&["masquerading"], &["masquerade"]],
    range: 5..=7,
};

static WORD_MASI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MASI_CHILDREN),
    value: None,
};

pub static WORD_MASI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("a"),
        dictgen::InsensitiveStr::Ascii("cer"),
        dictgen::InsensitiveStr::Ascii("ff"),
    ],
    values: &[&["messiah"], &["massacre"], &["massif"]],
    range: 1..=3,
};

static WORD_MASH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MASH_CHILDREN),
    value: None,
};

pub static WORD_MASH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("etty"),
        dictgen::InsensitiveStr::Ascii("ine"),
        dictgen::InsensitiveStr::Ascii("ined"),
        dictgen::InsensitiveStr::Ascii("ines"),
    ],
    values: &[&["machete"], &["machine"], &["machined"], &["machines"]],
    range: 3..=4,
};

static WORD_MASC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MASC_CHILDREN),
    value: None,
};

pub static WORD_MASC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("arra"),
        dictgen::InsensitiveStr::Ascii("ulanity"),
        dictgen::InsensitiveStr::Ascii("ulenity"),
        dictgen::InsensitiveStr::Ascii("ulinty"),
    ],
    values: &[
        &["mascara"],
        &["masculinity"],
        &["masculinity"],
        &["masculinity"],
    ],
    range: 4..=7,
};

static WORD_MASA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MASA_CHILDREN),
    value: None,
};

pub static WORD_MASA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cra"),
        dictgen::InsensitiveStr::Ascii("kist"),
    ],
    values: &[&["mascara"], &["masochist"]],
    range: 3..=4,
};

static WORD_MAR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_MAR_CHILDREN),
    value: None,
};

static WORD_MAR_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_MARA_NODE),
    Some(&WORD_MARB_NODE),
    Some(&WORD_MARC_NODE),
    None,
    Some(&WORD_MARE_NODE),
    None,
    Some(&WORD_MARG_NODE),
    Some(&WORD_MARH_NODE),
    Some(&WORD_MARI_NODE),
    Some(&WORD_MARJ_NODE),
    Some(&WORD_MARK_NODE),
    Some(&WORD_MARL_NODE),
    Some(&WORD_MARM_NODE),
    Some(&WORD_MARN_NODE),
    None,
    None,
    None,
    Some(&WORD_MARR_NODE),
    Some(&WORD_MARS_NODE),
    Some(&WORD_MART_NODE),
    Some(&WORD_MARU_NODE),
    Some(&WORD_MARV_NODE),
    None,
    Some(&WORD_MARX_NODE),
    None,
    Some(&WORD_MARZ_NODE),
];

static WORD_MARZ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MARZ_CHILDREN),
    value: Some(&["march", "mars"]),
};

pub static WORD_MARZ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[],
    values: &[],
    range: 0..=0,
};

static WORD_MARX_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MARX_CHILDREN),
    value: None,
};

pub static WORD_MARX_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("isim"),
        dictgen::InsensitiveStr::Ascii("isit"),
        dictgen::InsensitiveStr::Ascii("isits"),
    ],
    values: &[&["marxism"], &["marxist"], &["marxists"]],
    range: 4..=5,
};

static WORD_MARV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MARV_CHILDREN),
    value: None,
};

pub static WORD_MARV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("elos")],
    values: &[&["marvelous"]],
    range: 4..=4,
};

static WORD_MARU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MARU_CHILDREN),
    value: None,
};

pub static WORD_MARU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ader")],
    values: &[&["marauder"]],
    range: 4..=4,
};

static WORD_MART_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MART_CHILDREN),
    value: None,
};

pub static WORD_MART_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ail"),
        dictgen::InsensitiveStr::Ascii("ain"),
        dictgen::InsensitiveStr::Ascii("er"),
    ],
    values: &[&["martial"], &["martian"], &["martyr"]],
    range: 2..=3,
};

static WORD_MARS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MARS_CHILDREN),
    value: None,
};

pub static WORD_MARS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("hamllow"),
        dictgen::InsensitiveStr::Ascii("hamllows"),
        dictgen::InsensitiveStr::Ascii("hmalllows"),
        dictgen::InsensitiveStr::Ascii("hmallons"),
        dictgen::InsensitiveStr::Ascii("hmallowiest"),
        dictgen::InsensitiveStr::Ascii("hmallowness"),
        dictgen::InsensitiveStr::Ascii("hmalow"),
        dictgen::InsensitiveStr::Ascii("hmalows"),
        dictgen::InsensitiveStr::Ascii("hmellow"),
        dictgen::InsensitiveStr::Ascii("hmellows"),
        dictgen::InsensitiveStr::Ascii("kman"),
    ],
    values: &[
        &["marshmallow"],
        &["marshmallows"],
        &["marshmallows"],
        &["marshmallows"],
        &["marshmallows"],
        &["marshmallows"],
        &["marshmallow"],
        &["marshmallows"],
        &["marshmallow"],
        &["marshmallows"],
        &["marksman"],
    ],
    range: 4..=11,
};

static WORD_MARR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MARR_CHILDREN),
    value: None,
};

pub static WORD_MARR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("age"),
        dictgen::InsensitiveStr::Ascii("aige"),
        dictgen::InsensitiveStr::Ascii("tyred"),
        dictgen::InsensitiveStr::Ascii("yied"),
    ],
    values: &[&["marriage"], &["marriage"], &["martyred"], &["married"]],
    range: 3..=5,
};

static WORD_MARN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MARN_CHILDREN),
    value: None,
};

pub static WORD_MARN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("iers"),
        dictgen::InsensitiveStr::Ascii("ies"),
    ],
    values: &[&["mariners"], &["marines"]],
    range: 3..=4,
};

static WORD_MARM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MARM_CHILDREN),
    value: None,
};

pub static WORD_MARM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("elade")],
    values: &[&["marmalade"]],
    range: 5..=5,
};

static WORD_MARL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MARL_CHILDREN),
    value: None,
};

pub static WORD_MARL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("bes"),
        dictgen::InsensitiveStr::Ascii("iyn"),
    ],
    values: &[&["marbles"], &["marilyn"]],
    range: 3..=3,
};

static WORD_MARK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MARK_CHILDREN),
    value: None,
};

pub static WORD_MARK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aup"),
        dictgen::InsensitiveStr::Ascii("ede"),
        dictgen::InsensitiveStr::Ascii("edet"),
        dictgen::InsensitiveStr::Ascii("eras"),
        dictgen::InsensitiveStr::Ascii("erplace"),
        dictgen::InsensitiveStr::Ascii("erts"),
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("etpalce"),
        dictgen::InsensitiveStr::Ascii("etting"),
        dictgen::InsensitiveStr::Ascii("ey"),
        dictgen::InsensitiveStr::Ascii("eys"),
        dictgen::InsensitiveStr::Ascii("ter"),
        dictgen::InsensitiveStr::Ascii("ters"),
    ],
    values: &[
        &["markup"],
        &["marketed"],
        &["marketed"],
        &["markers"],
        &["marketplace"],
        &["markers"],
        &["marks", "marked", "markers"],
        &["marketplace"],
        &["marketing"],
        &["marquee"],
        &["marquees"],
        &["marker"],
        &["markers"],
    ],
    range: 2..=7,
};

static WORD_MARJ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MARJ_CHILDREN),
    value: None,
};

pub static WORD_MARJ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("iuana"),
        dictgen::InsensitiveStr::Ascii("ority"),
    ],
    values: &[&["marijuana"], &["majority"]],
    range: 5..=5,
};

static WORD_MARI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MARI_CHILDREN),
    value: None,
};

pub static WORD_MARI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("abd"),
        dictgen::InsensitiveStr::Ascii("age"),
        dictgen::InsensitiveStr::Ascii("ens"),
        dictgen::InsensitiveStr::Ascii("gnal"),
        dictgen::InsensitiveStr::Ascii("gnally"),
        dictgen::InsensitiveStr::Ascii("jauna"),
        dictgen::InsensitiveStr::Ascii("juanna"),
        dictgen::InsensitiveStr::Ascii("juannas"),
        dictgen::InsensitiveStr::Ascii("lyin"),
        dictgen::InsensitiveStr::Ascii("nens"),
        dictgen::InsensitiveStr::Ascii("neras"),
        dictgen::InsensitiveStr::Ascii("neris"),
        dictgen::InsensitiveStr::Ascii("neros"),
        dictgen::InsensitiveStr::Ascii("tan"),
        dictgen::InsensitiveStr::Ascii("xsm"),
        dictgen::InsensitiveStr::Ascii("xst"),
        dictgen::InsensitiveStr::Ascii("xsts"),
        dictgen::InsensitiveStr::Ascii("yln"),
    ],
    values: &[
        &["mariadb"],
        &["marriage"],
        &["marines"],
        &["marginal"],
        &["marginally"],
        &["marijuana"],
        &["marijuana"],
        &["marijuana"],
        &["marilyn"],
        &["marines"],
        &["mariners"],
        &["mariners"],
        &["mariners"],
        &["martian"],
        &["marxism"],
        &["marxist"],
        &["marxists"],
        &["marilyn"],
    ],
    range: 3..=7,
};

static WORD_MARH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MARH_CHILDREN),
    value: None,
};

pub static WORD_MARH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("smallow"),
        dictgen::InsensitiveStr::Ascii("smallows"),
    ],
    values: &[&["marshmallow"], &["marshmallows"]],
    range: 7..=8,
};

static WORD_MARG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MARG_CHILDREN),
    value: None,
};

pub static WORD_MARG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("anilize"),
        dictgen::InsensitiveStr::Ascii("anilized"),
        dictgen::InsensitiveStr::Ascii("arent"),
        dictgen::InsensitiveStr::Ascii("aritte"),
        dictgen::InsensitiveStr::Ascii("art"),
        dictgen::InsensitiveStr::Ascii("enalized"),
        dictgen::InsensitiveStr::Ascii("er"),
        dictgen::InsensitiveStr::Ascii("erat"),
        dictgen::InsensitiveStr::Ascii("ers"),
        dictgen::InsensitiveStr::Ascii("ianlly"),
        dictgen::InsensitiveStr::Ascii("inaal"),
        dictgen::InsensitiveStr::Ascii("inaali"),
        dictgen::InsensitiveStr::Ascii("inable"),
        dictgen::InsensitiveStr::Ascii("inaly"),
        dictgen::InsensitiveStr::Ascii("ines"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("ings"),
        dictgen::InsensitiveStr::Ascii("inilized"),
        dictgen::InsensitiveStr::Ascii("inis"),
    ],
    values: &[
        &["marginalized"],
        &["marginalized"],
        &["margaret"],
        &["margaret"],
        &["margaret"],
        &["marginalized"],
        &["merger", "marker"],
        &["margaret"],
        &["mergers", "markers"],
        &["marginally"],
        &["marginal"],
        &["marginal"],
        &["marginal"],
        &["marginally"],
        &["margins"],
        &["margin", "merging"],
        &["margins"],
        &["marginalized"],
        &["margins"],
    ],
    range: 2..=8,
};

static WORD_MARE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MARE_CHILDREN),
    value: None,
};

pub static WORD_MARE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("vlous")],
    values: &[&["marvelous"]],
    range: 5..=5,
};

static WORD_MARC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MARC_CHILDREN),
    value: None,
};

pub static WORD_MARC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("hmallows"),
        dictgen::InsensitiveStr::Ascii("ros"),
    ],
    values: &[&["marshmallows"], &["macros"]],
    range: 3..=8,
};

static WORD_MARB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MARB_CHILDREN),
    value: None,
};

pub static WORD_MARB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("els"),
        dictgen::InsensitiveStr::Ascii("leds"),
    ],
    values: &[&["marbles"], &["marbles"]],
    range: 3..=4,
};

static WORD_MARA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MARA_CHILDREN),
    value: None,
};

pub static WORD_MARA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("coni"),
        dictgen::InsensitiveStr::Ascii("deur"),
        dictgen::InsensitiveStr::Ascii("duer"),
        dictgen::InsensitiveStr::Ascii("gret"),
        dictgen::InsensitiveStr::Ascii("udeur"),
        dictgen::InsensitiveStr::Ascii("udeurs"),
    ],
    values: &[
        &["macaroni"],
        &["marauder"],
        &["marauder"],
        &["margaret"],
        &["marauder"],
        &["marauder"],
    ],
    range: 4..=6,
};

static WORD_MAP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MAP_CHILDREN),
    value: None,
};

pub static WORD_MAP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("able"),
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("ings"),
        dictgen::InsensitiveStr::Ascii("p"),
        dictgen::InsensitiveStr::Ascii("pble"),
        dictgen::InsensitiveStr::Ascii("peds"),
        dictgen::InsensitiveStr::Ascii("peed"),
        dictgen::InsensitiveStr::Ascii("pping"),
        dictgen::InsensitiveStr::Ascii("ppings"),
    ],
    values: &[
        &["mappable"],
        &["map"],
        &["mapped"],
        &["mapping"],
        &["mappings"],
        &["map"],
        &["mappable"],
        &["mapped"],
        &["mapped"],
        &["mapping"],
        &["mappings"],
    ],
    range: 1..=6,
};

static WORD_MAN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_MAN_CHILDREN),
    value: None,
};

static WORD_MAN_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_MANA_NODE),
    None,
    None,
    Some(&WORD_MAND_NODE),
    Some(&WORD_MANE_NODE),
    Some(&WORD_MANF_NODE),
    Some(&WORD_MANG_NODE),
    None,
    Some(&WORD_MANI_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_MANN_NODE),
    Some(&WORD_MANO_NODE),
    None,
    None,
    None,
    Some(&WORD_MANS_NODE),
    Some(&WORD_MANT_NODE),
    Some(&WORD_MANU_NODE),
    None,
    None,
    None,
    Some(&WORD_MANY_NODE),
    None,
];

static WORD_MANY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MANY_CHILDREN),
    value: None,
};

pub static WORD_MANY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("al"),
        dictgen::InsensitiveStr::Ascii("ally"),
        dictgen::InsensitiveStr::Ascii("als"),
    ],
    values: &[&["manual"], &["manually"], &["manuals"]],
    range: 2..=4,
};

static WORD_MANU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_MANU_CHILDREN),
    value: None,
};

static WORD_MANU_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_MANUA_NODE),
    None,
    None,
    None,
    Some(&WORD_MANUE_NODE),
    Some(&WORD_MANUF_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_MANUL_NODE),
    None,
    None,
    None,
    Some(&WORD_MANUP_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_MANUV_NODE),
    None,
    None,
    None,
    None,
];

static WORD_MANUV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MANUV_CHILDREN),
    value: None,
};

pub static WORD_MANUV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("er")],
    values: &[&["maneuver"]],
    range: 2..=2,
};

static WORD_MANUP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MANUP_CHILDREN),
    value: None,
};

pub static WORD_MANUP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ilated"),
        dictgen::InsensitiveStr::Ascii("ilating"),
        dictgen::InsensitiveStr::Ascii("ilations"),
        dictgen::InsensitiveStr::Ascii("ulate"),
        dictgen::InsensitiveStr::Ascii("ulated"),
        dictgen::InsensitiveStr::Ascii("ulates"),
        dictgen::InsensitiveStr::Ascii("ulating"),
        dictgen::InsensitiveStr::Ascii("ulation"),
        dictgen::InsensitiveStr::Ascii("ulations"),
        dictgen::InsensitiveStr::Ascii("ulative"),
    ],
    values: &[
        &["manipulated"],
        &["manipulating"],
        &["manipulations"],
        &["manipulate"],
        &["manipulated"],
        &["manipulates"],
        &["manipulating"],
        &["manipulation"],
        &["manipulations"],
        &["manipulative"],
    ],
    range: 5..=8,
};

static WORD_MANUL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MANUL_CHILDREN),
    value: None,
};

pub static WORD_MANUL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ally"),
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("ey"),
        dictgen::InsensitiveStr::Ascii("ly"),
        dictgen::InsensitiveStr::Ascii("y"),
    ],
    values: &[
        &["manually"],
        &["manual"],
        &["manually"],
        &["manually"],
        &["manually"],
    ],
    range: 1..=4,
};

static WORD_MANUF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MANUF_CHILDREN),
    value: None,
};

pub static WORD_MANUF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("acter"),
        dictgen::InsensitiveStr::Ascii("actered"),
        dictgen::InsensitiveStr::Ascii("acterer"),
        dictgen::InsensitiveStr::Ascii("acterers"),
        dictgen::InsensitiveStr::Ascii("acteres"),
        dictgen::InsensitiveStr::Ascii("actering"),
        dictgen::InsensitiveStr::Ascii("acters"),
        dictgen::InsensitiveStr::Ascii("acterurs"),
        dictgen::InsensitiveStr::Ascii("acteur"),
        dictgen::InsensitiveStr::Ascii("acteurs"),
        dictgen::InsensitiveStr::Ascii("actored"),
        dictgen::InsensitiveStr::Ascii("actorer"),
        dictgen::InsensitiveStr::Ascii("actorers"),
        dictgen::InsensitiveStr::Ascii("actores"),
        dictgen::InsensitiveStr::Ascii("actoring"),
        dictgen::InsensitiveStr::Ascii("actued"),
        dictgen::InsensitiveStr::Ascii("actuer"),
        dictgen::InsensitiveStr::Ascii("actuerd"),
        dictgen::InsensitiveStr::Ascii("actuered"),
        dictgen::InsensitiveStr::Ascii("actuerer"),
        dictgen::InsensitiveStr::Ascii("actueres"),
        dictgen::InsensitiveStr::Ascii("actuers"),
        dictgen::InsensitiveStr::Ascii("actuing"),
        dictgen::InsensitiveStr::Ascii("acturas"),
        dictgen::InsensitiveStr::Ascii("acturedd"),
        dictgen::InsensitiveStr::Ascii("actureds"),
        dictgen::InsensitiveStr::Ascii("actureers"),
        dictgen::InsensitiveStr::Ascii("actureras"),
        dictgen::InsensitiveStr::Ascii("acturerd"),
        dictgen::InsensitiveStr::Ascii("acturered"),
        dictgen::InsensitiveStr::Ascii("acturerers"),
        dictgen::InsensitiveStr::Ascii("actureres"),
        dictgen::InsensitiveStr::Ascii("actureros"),
        dictgen::InsensitiveStr::Ascii("acturier"),
        dictgen::InsensitiveStr::Ascii("acturor"),
        dictgen::InsensitiveStr::Ascii("acturors"),
        dictgen::InsensitiveStr::Ascii("acturs"),
        dictgen::InsensitiveStr::Ascii("actuter"),
        dictgen::InsensitiveStr::Ascii("actuters"),
        dictgen::InsensitiveStr::Ascii("acure"),
        dictgen::InsensitiveStr::Ascii("acuter"),
        dictgen::InsensitiveStr::Ascii("acuters"),
        dictgen::InsensitiveStr::Ascii("acutre"),
        dictgen::InsensitiveStr::Ascii("acutred"),
        dictgen::InsensitiveStr::Ascii("acutrers"),
        dictgen::InsensitiveStr::Ascii("acutres"),
        dictgen::InsensitiveStr::Ascii("ature"),
        dictgen::InsensitiveStr::Ascii("atured"),
        dictgen::InsensitiveStr::Ascii("aturing"),
        dictgen::InsensitiveStr::Ascii("aucturing"),
        dictgen::InsensitiveStr::Ascii("caturers"),
    ],
    values: &[
        &["manufacture"],
        &["manufactured"],
        &["manufacturer"],
        &["manufacturers"],
        &["manufactures"],
        &["manufacturing"],
        &["manufactures"],
        &["manufactures"],
        &["manufactures"],
        &["manufactures"],
        &["manufactured"],
        &["manufacturer"],
        &["manufacturers"],
        &["manufactures"],
        &["manufacturing"],
        &["manufactured"],
        &["manufacture", "manufacturer"],
        &["manufactured"],
        &["manufactured"],
        &["manufacturer"],
        &["manufactures"],
        &["manufacturers", "manufactures"],
        &["manufacturing"],
        &["manufactures"],
        &["manufactured"],
        &["manufactures"],
        &["manufactures"],
        &["manufactures"],
        &["manufactured"],
        &["manufactured"],
        &["manufacturers"],
        &["manufacturers"],
        &["manufactures"],
        &["manufacturer"],
        &["manufacturer"],
        &["manufacturers"],
        &["manufactures"],
        &["manufacture"],
        &["manufactures"],
        &["manufacture"],
        &["manufacture"],
        &["manufactures"],
        &["manufactures"],
        &["manufacture"],
        &["manufactures"],
        &["manufactures"],
        &["manufacture"],
        &["manufactured"],
        &["manufacturing"],
        &["manufacturing"],
        &["manufactures"],
    ],
    range: 5..=10,
};

static WORD_MANUE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MANUE_CHILDREN),
    value: None,
};

pub static WORD_MANUE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ll"),
        dictgen::InsensitiveStr::Ascii("lly"),
        dictgen::InsensitiveStr::Ascii("s"),
        dictgen::InsensitiveStr::Ascii("ver"),
        dictgen::InsensitiveStr::Ascii("vers"),
    ],
    values: &[
        &["manual"],
        &["manually"],
        &["menus"],
        &["maneuver"],
        &["maneuvers"],
    ],
    range: 1..=4,
};

static WORD_MANUA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MANUA_CHILDREN),
    value: None,
};

pub static WORD_MANUA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("les"),
        dictgen::InsensitiveStr::Ascii("ly"),
        dictgen::InsensitiveStr::Ascii("lyl"),
        dictgen::InsensitiveStr::Ascii("lyy"),
    ],
    values: &[&["manuals"], &["manually"], &["manually"], &["manually"]],
    range: 2..=3,
};

static WORD_MANT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MANT_CHILDREN),
    value: None,
};

pub static WORD_MANT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ain"),
        dictgen::InsensitiveStr::Ascii("ainable"),
        dictgen::InsensitiveStr::Ascii("ained"),
        dictgen::InsensitiveStr::Ascii("ainer"),
        dictgen::InsensitiveStr::Ascii("ainers"),
        dictgen::InsensitiveStr::Ascii("aining"),
        dictgen::InsensitiveStr::Ascii("ains"),
        dictgen::InsensitiveStr::Ascii("anine"),
        dictgen::InsensitiveStr::Ascii("anined"),
        dictgen::InsensitiveStr::Ascii("atory"),
        dictgen::InsensitiveStr::Ascii("enance"),
    ],
    values: &[
        &["maintain"],
        &["maintainable"],
        &["maintained"],
        &["maintainer"],
        &["maintainers"],
        &["maintaining"],
        &["maintains"],
        &["maintain"],
        &["maintained"],
        &["mandatory"],
        &["maintenance"],
    ],
    range: 3..=7,
};

static WORD_MANS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MANS_CHILDREN),
    value: None,
};

pub static WORD_MANS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("alughter"),
        dictgen::InsensitiveStr::Ascii("laugher"),
        dictgen::InsensitiveStr::Ascii("laugter"),
        dictgen::InsensitiveStr::Ascii("laugther"),
        dictgen::InsensitiveStr::Ascii("luaghter"),
    ],
    values: &[
        &["manslaughter"],
        &["manslaughter"],
        &["manslaughter"],
        &["manslaughter"],
        &["manslaughter"],
    ],
    range: 7..=8,
};

static WORD_MANO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MANO_CHILDREN),
    value: None,
};

pub static WORD_MANO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("euverability"),
        dictgen::InsensitiveStr::Ascii("uevring"),
        dictgen::InsensitiveStr::Ascii("uver"),
        dictgen::InsensitiveStr::Ascii("uverability"),
        dictgen::InsensitiveStr::Ascii("uverable"),
        dictgen::InsensitiveStr::Ascii("uvers"),
    ],
    values: &[
        &["maneuverability"],
        &["manoeuvring"],
        &["maneuver"],
        &["maneuverability"],
        &["maneuverable"],
        &["maneuvers"],
    ],
    range: 4..=12,
};

static WORD_MANN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MANN_CHILDREN),
    value: None,
};

pub static WORD_MANN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("arisms"),
        dictgen::InsensitiveStr::Ascii("erisims"),
        dictgen::InsensitiveStr::Ascii("ersims"),
        dictgen::InsensitiveStr::Ascii("or"),
        dictgen::InsensitiveStr::Ascii("orisms"),
        dictgen::InsensitiveStr::Ascii("ual"),
        dictgen::InsensitiveStr::Ascii("ually"),
        dictgen::InsensitiveStr::Ascii("ualy"),
    ],
    values: &[
        &["mannerisms"],
        &["mannerisms"],
        &["mannerisms"],
        &["manner"],
        &["mannerisms"],
        &["manual"],
        &["manually"],
        &["manually"],
    ],
    range: 2..=7,
};

static WORD_MANI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MANI_CHILDREN),
    value: None,
};

pub static WORD_MANI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("facture"),
        dictgen::InsensitiveStr::Ascii("factured"),
        dictgen::InsensitiveStr::Ascii("facturer"),
        dictgen::InsensitiveStr::Ascii("facturers"),
        dictgen::InsensitiveStr::Ascii("factures"),
        dictgen::InsensitiveStr::Ascii("facturing"),
        dictgen::InsensitiveStr::Ascii("fastation"),
        dictgen::InsensitiveStr::Ascii("fect"),
        dictgen::InsensitiveStr::Ascii("feso"),
        dictgen::InsensitiveStr::Ascii("festacion"),
        dictgen::InsensitiveStr::Ascii("festado"),
        dictgen::InsensitiveStr::Ascii("festaion"),
        dictgen::InsensitiveStr::Ascii("festano"),
        dictgen::InsensitiveStr::Ascii("festanti"),
        dictgen::InsensitiveStr::Ascii("festas"),
        dictgen::InsensitiveStr::Ascii("festating"),
        dictgen::InsensitiveStr::Ascii("festato"),
        dictgen::InsensitiveStr::Ascii("festes"),
        dictgen::InsensitiveStr::Ascii("festion"),
        dictgen::InsensitiveStr::Ascii("festior"),
        dictgen::InsensitiveStr::Ascii("festons"),
        dictgen::InsensitiveStr::Ascii("festors"),
        dictgen::InsensitiveStr::Ascii("festus"),
        dictgen::InsensitiveStr::Ascii("fistation"),
        dictgen::InsensitiveStr::Ascii("pluate"),
        dictgen::InsensitiveStr::Ascii("pluated"),
        dictgen::InsensitiveStr::Ascii("pluating"),
        dictgen::InsensitiveStr::Ascii("pluation"),
        dictgen::InsensitiveStr::Ascii("pualte"),
        dictgen::InsensitiveStr::Ascii("pualted"),
        dictgen::InsensitiveStr::Ascii("pualting"),
        dictgen::InsensitiveStr::Ascii("pualtion"),
        dictgen::InsensitiveStr::Ascii("pualtive"),
        dictgen::InsensitiveStr::Ascii("pulacion"),
        dictgen::InsensitiveStr::Ascii("pulant"),
        dictgen::InsensitiveStr::Ascii("pulare"),
        dictgen::InsensitiveStr::Ascii("pulatie"),
        dictgen::InsensitiveStr::Ascii("pulatin"),
        dictgen::InsensitiveStr::Ascii("pulationg"),
        dictgen::InsensitiveStr::Ascii("pulaton"),
        dictgen::InsensitiveStr::Ascii("pule"),
        dictgen::InsensitiveStr::Ascii("pulitive"),
        dictgen::InsensitiveStr::Ascii("pulted"),
        dictgen::InsensitiveStr::Ascii("pute"),
        dictgen::InsensitiveStr::Ascii("puted"),
        dictgen::InsensitiveStr::Ascii("puting"),
        dictgen::InsensitiveStr::Ascii("pution"),
        dictgen::InsensitiveStr::Ascii("putions"),
        dictgen::InsensitiveStr::Ascii("putor"),
        dictgen::InsensitiveStr::Ascii("sfestations"),
        dictgen::InsensitiveStr::Ascii("uplate"),
        dictgen::InsensitiveStr::Ascii("uplated"),
        dictgen::InsensitiveStr::Ascii("uplates"),
        dictgen::InsensitiveStr::Ascii("uplating"),
        dictgen::InsensitiveStr::Ascii("uplation"),
        dictgen::InsensitiveStr::Ascii("uplations"),
        dictgen::InsensitiveStr::Ascii("uplative"),
        dictgen::InsensitiveStr::Ascii("uplator"),
        dictgen::InsensitiveStr::Ascii("uplators"),
    ],
    values: &[
        &["manufacture"],
        &["manufactured"],
        &["manufacturer"],
        &["manufacturers"],
        &["manufactures"],
        &["manufacturing"],
        &["manifestation"],
        &["manifest"],
        &["manifesto"],
        &["manifestation"],
        &["manifesto"],
        &["manifestation"],
        &["manifesto"],
        &["manifestation"],
        &["manifests"],
        &["manifestation"],
        &["manifesto"],
        &["manifests"],
        &["manifesto"],
        &["manifesto"],
        &["manifests"],
        &["manifests"],
        &["manifests"],
        &["manifestation"],
        &["manipulate"],
        &["manipulated"],
        &["manipulating"],
        &["manipulation"],
        &["manipulate"],
        &["manipulated"],
        &["manipulating"],
        &["manipulation"],
        &["manipulative"],
        &["manipulation"],
        &["manipulate"],
        &["manipulate"],
        &["manipulative"],
        &["manipulation", "manipulating"],
        &["manipulating"],
        &["manipulation"],
        &["manipulate"],
        &["manipulative"],
        &["manipulated"],
        &["manipulate"],
        &["manipulated"],
        &["manipulating"],
        &["manipulation"],
        &["manipulations"],
        &["manipulator"],
        &["manifestations"],
        &["manipulate"],
        &["manipulated"],
        &["manipulates"],
        &["manipulating"],
        &["manipulation"],
        &["manipulations"],
        &["manipulative"],
        &["manipulator"],
        &["manipulators"],
    ],
    range: 4..=11,
};

static WORD_MANG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MANG_CHILDREN),
    value: None,
};

pub static WORD_MANG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aed"),
        dictgen::InsensitiveStr::Ascii("aement"),
        dictgen::InsensitiveStr::Ascii("aer"),
        dictgen::InsensitiveStr::Ascii("aers"),
        dictgen::InsensitiveStr::Ascii("ager"),
        dictgen::InsensitiveStr::Ascii("agers"),
        dictgen::InsensitiveStr::Ascii("eld"),
        dictgen::InsensitiveStr::Ascii("ement"),
        dictgen::InsensitiveStr::Ascii("ementt"),
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("esium"),
        dictgen::InsensitiveStr::Ascii("etic"),
        dictgen::InsensitiveStr::Ascii("ets"),
        dictgen::InsensitiveStr::Ascii("itude"),
        dictgen::InsensitiveStr::Ascii("lade"),
    ],
    values: &[
        &["managed"],
        &["management"],
        &["manager", "manger"],
        &["managers", "mangers"],
        &["manager"],
        &["managers"],
        &["mangled"],
        &["management"],
        &["management"],
        &["manages"],
        &["magnesium"],
        &["magnetic"],
        &["magnets"],
        &["magnitude"],
        &["mangled"],
    ],
    range: 2..=6,
};

static WORD_MANF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MANF_CHILDREN),
    value: None,
};

pub static WORD_MANF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("iest"),
        dictgen::InsensitiveStr::Ascii("iesto"),
        dictgen::InsensitiveStr::Ascii("iests"),
        dictgen::InsensitiveStr::Ascii("uacturers"),
    ],
    values: &[
        &["manifest"],
        &["manifesto"],
        &["manifests"],
        &["manufactures"],
    ],
    range: 4..=9,
};

static WORD_MANE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MANE_CHILDREN),
    value: None,
};

pub static WORD_MANE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("agable"),
        dictgen::InsensitiveStr::Ascii("er"),
        dictgen::InsensitiveStr::Ascii("festation"),
        dictgen::InsensitiveStr::Ascii("ment"),
        dictgen::InsensitiveStr::Ascii("ouvre"),
        dictgen::InsensitiveStr::Ascii("ouvred"),
        dictgen::InsensitiveStr::Ascii("ouvres"),
        dictgen::InsensitiveStr::Ascii("ouvring"),
        dictgen::InsensitiveStr::Ascii("tain"),
        dictgen::InsensitiveStr::Ascii("tained"),
        dictgen::InsensitiveStr::Ascii("tainer"),
        dictgen::InsensitiveStr::Ascii("tainers"),
        dictgen::InsensitiveStr::Ascii("taining"),
        dictgen::InsensitiveStr::Ascii("tains"),
        dictgen::InsensitiveStr::Ascii("uveres"),
        dictgen::InsensitiveStr::Ascii("uveur"),
        dictgen::InsensitiveStr::Ascii("uveurs"),
        dictgen::InsensitiveStr::Ascii("veur"),
        dictgen::InsensitiveStr::Ascii("veurs"),
        dictgen::InsensitiveStr::Ascii("vuer"),
    ],
    values: &[
        &["manageable"],
        &["manner"],
        &["manifestation"],
        &["management"],
        &["manoeuvre"],
        &["manoeuvred"],
        &["manoeuvres"],
        &["manoeuvring"],
        &["maintain"],
        &["maintained"],
        &["maintainer"],
        &["maintainers"],
        &["maintaining"],
        &["maintains"],
        &["maneuvers"],
        &["maneuver"],
        &["maneuver"],
        &["maneuver"],
        &["maneuvers"],
        &["maneuver"],
    ],
    range: 2..=9,
};

static WORD_MAND_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MAND_CHILDREN),
    value: None,
};

pub static WORD_MAND_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("arian"),
        dictgen::InsensitiveStr::Ascii("arijn"),
        dictgen::InsensitiveStr::Ascii("arion"),
        dictgen::InsensitiveStr::Ascii("ase"),
        dictgen::InsensitiveStr::Ascii("aste"),
        dictgen::InsensitiveStr::Ascii("atatory"),
        dictgen::InsensitiveStr::Ascii("ats"),
        dictgen::InsensitiveStr::Ascii("ess"),
        dictgen::InsensitiveStr::Ascii("etory"),
        dictgen::InsensitiveStr::Ascii("rain"),
        dictgen::InsensitiveStr::Ascii("rian"),
    ],
    values: &[
        &["mandarin"],
        &["mandarin"],
        &["mandarin"],
        &["mandates"],
        &["mandates"],
        &["mandatory"],
        &["mandates"],
        &["madness"],
        &["mandatory"],
        &["mandarin"],
        &["mandarin"],
    ],
    range: 3..=7,
};

static WORD_MANA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MANA_CHILDREN),
    value: None,
};

pub static WORD_MANA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("drin"),
        dictgen::InsensitiveStr::Ascii("factured"),
        dictgen::InsensitiveStr::Ascii("facturer"),
        dictgen::InsensitiveStr::Ascii("facturers"),
        dictgen::InsensitiveStr::Ascii("factures"),
        dictgen::InsensitiveStr::Ascii("facturing"),
        dictgen::InsensitiveStr::Ascii("festation"),
        dictgen::InsensitiveStr::Ascii("gable"),
        dictgen::InsensitiveStr::Ascii("gament"),
        dictgen::InsensitiveStr::Ascii("gebale"),
        dictgen::InsensitiveStr::Ascii("geed"),
        dictgen::InsensitiveStr::Ascii("gemenet"),
        dictgen::InsensitiveStr::Ascii("genment"),
        dictgen::InsensitiveStr::Ascii("germent"),
        dictgen::InsensitiveStr::Ascii("get"),
        dictgen::InsensitiveStr::Ascii("gets"),
        dictgen::InsensitiveStr::Ascii("gmenet"),
        dictgen::InsensitiveStr::Ascii("gment"),
        dictgen::InsensitiveStr::Ascii("ise"),
        dictgen::InsensitiveStr::Ascii("l"),
        dictgen::InsensitiveStr::Ascii("nge"),
        dictgen::InsensitiveStr::Ascii("ngement"),
        dictgen::InsensitiveStr::Ascii("nger"),
        dictgen::InsensitiveStr::Ascii("ngers"),
        dictgen::InsensitiveStr::Ascii("ul"),
        dictgen::InsensitiveStr::Ascii("ully"),
        dictgen::InsensitiveStr::Ascii("uls"),
        dictgen::InsensitiveStr::Ascii("ze"),
    ],
    values: &[
        &["mandarin"],
        &["manufactured"],
        &["manufacturer"],
        &["manufacturers"],
        &["manufactures"],
        &["manufacturing"],
        &["manifestation"],
        &["manageable", "manageably"],
        &["management"],
        &["manageable"],
        &["managed"],
        &["management"],
        &["management"],
        &["management"],
        &["manager"],
        &["managers"],
        &["management"],
        &["management"],
        &["mayonnaise"],
        &["manual"],
        &["manage"],
        &["management"],
        &["manager"],
        &["managers"],
        &["manual"],
        &["manually"],
        &["manuals"],
        &["mayonnaise"],
    ],
    range: 1..=9,
};

static WORD_MAM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MAM_CHILDREN),
    value: None,
};

pub static WORD_MAM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("agement"),
        dictgen::InsensitiveStr::Ascii("al"),
        dictgen::InsensitiveStr::Ascii("alian"),
        dictgen::InsensitiveStr::Ascii("ento"),
        dictgen::InsensitiveStr::Ascii("entos"),
        dictgen::InsensitiveStr::Ascii("ory"),
        dictgen::InsensitiveStr::Ascii("uth"),
    ],
    values: &[
        &["management"],
        &["mammal"],
        &["mammalian"],
        &["memento"],
        &["mementos"],
        &["memory"],
        &["mammoth"],
    ],
    range: 2..=7,
};

static WORD_MAL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MAL_CHILDREN),
    value: None,
};

pub static WORD_MAL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aira"),
        dictgen::InsensitiveStr::Ascii("ariya"),
        dictgen::InsensitiveStr::Ascii("asiya"),
        dictgen::InsensitiveStr::Ascii("asyia"),
        dictgen::InsensitiveStr::Ascii("asyian"),
        dictgen::InsensitiveStr::Ascii("ayisa"),
        dictgen::InsensitiveStr::Ascii("ayisan"),
        dictgen::InsensitiveStr::Ascii("aysa"),
        dictgen::InsensitiveStr::Ascii("aysain"),
        dictgen::InsensitiveStr::Ascii("clom"),
        dictgen::InsensitiveStr::Ascii("com"),
        dictgen::InsensitiveStr::Ascii("etonin"),
        dictgen::InsensitiveStr::Ascii("fonction"),
        dictgen::InsensitiveStr::Ascii("fucntion"),
        dictgen::InsensitiveStr::Ascii("fucntions"),
        dictgen::InsensitiveStr::Ascii("funcion"),
        dictgen::InsensitiveStr::Ascii("funciton"),
        dictgen::InsensitiveStr::Ascii("functing"),
        dictgen::InsensitiveStr::Ascii("funktion"),
        dictgen::InsensitiveStr::Ascii("iciousally"),
        dictgen::InsensitiveStr::Ascii("icius"),
        dictgen::InsensitiveStr::Ascii("iciusally"),
        dictgen::InsensitiveStr::Ascii("iciusly"),
        dictgen::InsensitiveStr::Ascii("icous"),
        dictgen::InsensitiveStr::Ascii("icousally"),
        dictgen::InsensitiveStr::Ascii("icously"),
        dictgen::InsensitiveStr::Ascii("ine"),
        dictgen::InsensitiveStr::Ascii("ined"),
        dictgen::InsensitiveStr::Ascii("ining"),
        dictgen::InsensitiveStr::Ascii("ins"),
        dictgen::InsensitiveStr::Ascii("less"),
        dictgen::InsensitiveStr::Ascii("place"),
        dictgen::InsensitiveStr::Ascii("placed"),
        dictgen::InsensitiveStr::Ascii("practce"),
        dictgen::InsensitiveStr::Ascii("practise"),
        dictgen::InsensitiveStr::Ascii("practive"),
        dictgen::InsensitiveStr::Ascii("tesian"),
        dictgen::InsensitiveStr::Ascii("yasia"),
        dictgen::InsensitiveStr::Ascii("yasian"),
    ],
    values: &[
        &["malaria"],
        &["malaria"],
        &["malaysia"],
        &["malaysia"],
        &["malaysian"],
        &["malaysia"],
        &["malaysian"],
        &["malaysia"],
        &["malaysian"],
        &["malcolm"],
        &["malcolm"],
        &["melatonin"],
        &["malfunction"],
        &["malfunction"],
        &["malfunction"],
        &["malfunction"],
        &["malfunction"],
        &["malfunction"],
        &["malfunction"],
        &["maliciously"],
        &["malicious"],
        &["maliciously"],
        &["maliciously"],
        &["malicious"],
        &["maliciously"],
        &["maliciously"],
        &["malign"],
        &["maligned"],
        &["maligning"],
        &["maligns"],
        &["malice"],
        &["misplace"],
        &["misplaced"],
        &["malpractice"],
        &["malpractice"],
        &["malpractice"],
        &["maltese"],
        &["malaysia"],
        &["malaysian"],
    ],
    range: 3..=10,
};

static WORD_MAK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MAK_CHILDREN),
    value: Some(&["make", "mask"]),
};

pub static WORD_MAK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("a"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("efle"),
        dictgen::InsensitiveStr::Ascii("eing"),
        dictgen::InsensitiveStr::Ascii("ign"),
        dictgen::InsensitiveStr::Ascii("retplace"),
        dictgen::InsensitiveStr::Ascii("ro"),
        dictgen::InsensitiveStr::Ascii("ros"),
        dictgen::InsensitiveStr::Ascii("rs"),
        dictgen::InsensitiveStr::Ascii("rsman"),
        dictgen::InsensitiveStr::Ascii("s"),
        dictgen::InsensitiveStr::Ascii("se"),
        dictgen::InsensitiveStr::Ascii("ss"),
        dictgen::InsensitiveStr::Ascii("wfile"),
    ],
    values: &[
        &["make"],
        &["marked", "made"],
        &["makefile"],
        &["making"],
        &["making"],
        &["marketplace"],
        &["macro"],
        &["macros"],
        &["makes", "makers", "macros"],
        &["marksman"],
        &["mask", "masks", "makes", "make"],
        &["makes", "masks"],
        &["masks", "makes"],
        &["makefile"],
    ],
    range: 1..=8,
};

static WORD_MAJ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MAJ_CHILDREN),
    value: None,
};

pub static WORD_MAJ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("oroty")],
    values: &[&["majority"]],
    range: 5..=5,
};

static WORD_MAI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MAI_CHILDREN),
    value: None,
};

pub static WORD_MAI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("be"),
        dictgen::InsensitiveStr::Ascii("box"),
        dictgen::InsensitiveStr::Ascii("dson"),
        dictgen::InsensitiveStr::Ascii("lformed"),
        dictgen::InsensitiveStr::Ascii("lling"),
        dictgen::InsensitiveStr::Ascii("lny"),
        dictgen::InsensitiveStr::Ascii("lstrum"),
        dictgen::InsensitiveStr::Ascii("nenance"),
        dictgen::InsensitiveStr::Ascii("nfest"),
        dictgen::InsensitiveStr::Ascii("nfestation"),
        dictgen::InsensitiveStr::Ascii("nfesto"),
        dictgen::InsensitiveStr::Ascii("nfests"),
        dictgen::InsensitiveStr::Ascii("ninly"),
        dictgen::InsensitiveStr::Ascii("nling"),
        dictgen::InsensitiveStr::Ascii("npulate"),
        dictgen::InsensitiveStr::Ascii("nstreem"),
        dictgen::InsensitiveStr::Ascii("nstrem"),
        dictgen::InsensitiveStr::Ascii("ntainance"),
        dictgen::InsensitiveStr::Ascii("ntaince"),
        dictgen::InsensitiveStr::Ascii("ntainces"),
        dictgen::InsensitiveStr::Ascii("ntainence"),
        dictgen::InsensitiveStr::Ascii("ntaines"),
        dictgen::InsensitiveStr::Ascii("ntaing"),
        dictgen::InsensitiveStr::Ascii("ntainig"),
        dictgen::InsensitiveStr::Ascii("ntainted"),
        dictgen::InsensitiveStr::Ascii("ntan"),
        dictgen::InsensitiveStr::Ascii("ntanance"),
        dictgen::InsensitiveStr::Ascii("ntance"),
        dictgen::InsensitiveStr::Ascii("ntane"),
        dictgen::InsensitiveStr::Ascii("ntaned"),
        dictgen::InsensitiveStr::Ascii("ntanence"),
        dictgen::InsensitiveStr::Ascii("ntaner"),
        dictgen::InsensitiveStr::Ascii("ntaners"),
        dictgen::InsensitiveStr::Ascii("ntaning"),
        dictgen::InsensitiveStr::Ascii("ntans"),
        dictgen::InsensitiveStr::Ascii("ntenace"),
        dictgen::InsensitiveStr::Ascii("ntenaince"),
        dictgen::InsensitiveStr::Ascii("ntenamce"),
        dictgen::InsensitiveStr::Ascii("ntenence"),
        dictgen::InsensitiveStr::Ascii("ntiain"),
        dictgen::InsensitiveStr::Ascii("ntian"),
        dictgen::InsensitiveStr::Ascii("ntianed"),
        dictgen::InsensitiveStr::Ascii("ntianing"),
        dictgen::InsensitiveStr::Ascii("ntians"),
        dictgen::InsensitiveStr::Ascii("ntinaing"),
        dictgen::InsensitiveStr::Ascii("ntinance"),
        dictgen::InsensitiveStr::Ascii("ntinence"),
        dictgen::InsensitiveStr::Ascii("ntioned"),
        dictgen::InsensitiveStr::Ascii("rabd"),
        dictgen::InsensitiveStr::Ascii("radb"),
        dictgen::InsensitiveStr::Ascii("rjuana"),
        dictgen::InsensitiveStr::Ascii("rlyn"),
        dictgen::InsensitiveStr::Ascii("tain"),
        dictgen::InsensitiveStr::Ascii("tainance"),
        dictgen::InsensitiveStr::Ascii("tained"),
        dictgen::InsensitiveStr::Ascii("tainers"),
    ],
    values: &[
        &["maybe"],
        &["mailbox"],
        &["madison"],
        &["malformed"],
        &["mailing"],
        &["mainly"],
        &["maelstrom"],
        &["maintenance"],
        &["manifest"],
        &["manifestation"],
        &["manifesto"],
        &["manifests"],
        &["mainly"],
        &["mailing"],
        &["manipulate"],
        &["mainstream"],
        &["mainstream"],
        &["maintenance"],
        &["maintained", "maintenance"],
        &["maintenances"],
        &["maintenance"],
        &["maintains"],
        &["maintaining"],
        &["maintaining"],
        &["maintained"],
        &["maintain"],
        &["maintenance"],
        &["maintenance"],
        &["maintain"],
        &["maintained"],
        &["maintenance"],
        &["maintainer"],
        &["maintainers"],
        &["maintaining"],
        &["maintains"],
        &["maintenance"],
        &["maintenance"],
        &["maintenance"],
        &["maintenance"],
        &["maintain"],
        &["maintain"],
        &["maintained"],
        &["maintaining"],
        &["maintains"],
        &["maintaining"],
        &["maintenance"],
        &["maintenance"],
        &["mentioned"],
        &["mariadb"],
        &["mariadb"],
        &["marijuana"],
        &["marilyn"],
        &["maintain"],
        &["maintenance"],
        &["maintained"],
        &["maintainers"],
    ],
    range: 2..=10,
};

static WORD_MAH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MAH_CHILDREN),
    value: None,
};

pub static WORD_MAH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("cine")],
    values: &[&["machine"]],
    range: 4..=4,
};

static WORD_MAG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MAG_CHILDREN),
    value: None,
};

pub static WORD_MAG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ainzes"),
        dictgen::InsensitiveStr::Ascii("asine"),
        dictgen::InsensitiveStr::Ascii("azins"),
        dictgen::InsensitiveStr::Ascii("ensium"),
        dictgen::InsensitiveStr::Ascii("ent"),
        dictgen::InsensitiveStr::Ascii("entic"),
        dictgen::InsensitiveStr::Ascii("ents"),
        dictgen::InsensitiveStr::Ascii("icain"),
        dictgen::InsensitiveStr::Ascii("icin"),
        dictgen::InsensitiveStr::Ascii("incian"),
        dictgen::InsensitiveStr::Ascii("inficent"),
        dictgen::InsensitiveStr::Ascii("intude"),
        dictgen::InsensitiveStr::Ascii("isine"),
        dictgen::InsensitiveStr::Ascii("izine"),
        dictgen::InsensitiveStr::Ascii("natiude"),
        dictgen::InsensitiveStr::Ascii("natude"),
        dictgen::InsensitiveStr::Ascii("neficent"),
        dictgen::InsensitiveStr::Ascii("neisum"),
        dictgen::InsensitiveStr::Ascii("nesuim"),
        dictgen::InsensitiveStr::Ascii("netis"),
        dictgen::InsensitiveStr::Ascii("nicifent"),
        dictgen::InsensitiveStr::Ascii("nifacent"),
        dictgen::InsensitiveStr::Ascii("nifecent"),
        dictgen::InsensitiveStr::Ascii("nificant"),
        dictgen::InsensitiveStr::Ascii("nificient"),
        dictgen::InsensitiveStr::Ascii("nifient"),
        dictgen::InsensitiveStr::Ascii("nifine"),
        dictgen::InsensitiveStr::Ascii("nited"),
        dictgen::InsensitiveStr::Ascii("nitudine"),
        dictgen::InsensitiveStr::Ascii("nitue"),
        dictgen::InsensitiveStr::Ascii("olia"),
        dictgen::InsensitiveStr::Ascii("or"),
    ],
    values: &[
        &["magazines"],
        &["magazine"],
        &["magazines"],
        &["magnesium"],
        &["magenta", "magnet"],
        &["magnetic"],
        &["magnets"],
        &["magician"],
        &["magician"],
        &["magician"],
        &["magnificent"],
        &["magnitude"],
        &["magazine"],
        &["magazine"],
        &["magnitude"],
        &["magnitude"],
        &["magnificent"],
        &["magnesium"],
        &["magnesium"],
        &["magnets"],
        &["magnificent"],
        &["magnificent"],
        &["magnificent"],
        &["magnificent"],
        &["magnificent"],
        &["magnificent"],
        &["magnificent"],
        &["magnitude"],
        &["magnitude"],
        &["magnitude"],
        &["magnolia"],
        &["major"],
    ],
    range: 2..=9,
};

static WORD_MAE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MAE_CHILDREN),
    value: None,
};

pub static WORD_MAE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aningless"),
        dictgen::InsensitiveStr::Ascii("stries"),
        dictgen::InsensitiveStr::Ascii("sure"),
        dictgen::InsensitiveStr::Ascii("sured"),
        dictgen::InsensitiveStr::Ascii("surement"),
        dictgen::InsensitiveStr::Ascii("surements"),
        dictgen::InsensitiveStr::Ascii("sures"),
        dictgen::InsensitiveStr::Ascii("suring"),
    ],
    values: &[
        &["meaningless"],
        &["masteries"],
        &["measure"],
        &["measured"],
        &["measurement"],
        &["measurements"],
        &["measures"],
        &["measuring"],
    ],
    range: 4..=9,
};

static WORD_MAD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MAD_CHILDREN),
    value: None,
};

pub static WORD_MAD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("antory"),
        dictgen::InsensitiveStr::Ascii("atory"),
        dictgen::InsensitiveStr::Ascii("dness"),
        dictgen::InsensitiveStr::Ascii("sion"),
        dictgen::InsensitiveStr::Ascii("turbating"),
        dictgen::InsensitiveStr::Ascii("turbation"),
    ],
    values: &[
        &["mandatory"],
        &["mandatory"],
        &["madness"],
        &["madison"],
        &["masturbating"],
        &["masturbation"],
    ],
    range: 4..=9,
};

static WORD_MAC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MAC_CHILDREN),
    value: None,
};

pub static WORD_MAC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ack"),
        dictgen::InsensitiveStr::Ascii("arino"),
        dictgen::InsensitiveStr::Ascii("aronni"),
        dictgen::InsensitiveStr::Ascii("ason"),
        dictgen::InsensitiveStr::Ascii("asons"),
        dictgen::InsensitiveStr::Ascii("cro"),
        dictgen::InsensitiveStr::Ascii("cros"),
        dictgen::InsensitiveStr::Ascii("hanism"),
        dictgen::InsensitiveStr::Ascii("hanisms"),
        dictgen::InsensitiveStr::Ascii("hed"),
        dictgen::InsensitiveStr::Ascii("hes"),
        dictgen::InsensitiveStr::Ascii("hettie"),
        dictgen::InsensitiveStr::Ascii("hien"),
        dictgen::InsensitiveStr::Ascii("hiens"),
        dictgen::InsensitiveStr::Ascii("hinary"),
        dictgen::InsensitiveStr::Ascii("hiness"),
        dictgen::InsensitiveStr::Ascii("hing"),
        dictgen::InsensitiveStr::Ascii("hins"),
        dictgen::InsensitiveStr::Ascii("keral"),
        dictgen::InsensitiveStr::Ascii("lolm"),
        dictgen::InsensitiveStr::Ascii("o"),
        dictgen::InsensitiveStr::Ascii("or"),
        dictgen::InsensitiveStr::Ascii("ors"),
        dictgen::InsensitiveStr::Ascii("pakge"),
        dictgen::InsensitiveStr::Ascii("roses"),
        dictgen::InsensitiveStr::Ascii("row"),
        dictgen::InsensitiveStr::Ascii("thing"),
        dictgen::InsensitiveStr::Ascii("thup"),
        dictgen::InsensitiveStr::Ascii("thups"),
    ],
    values: &[
        &["macaque"],
        &["macaroni"],
        &["macaroni"],
        &["moccasin"],
        &["moccasins"],
        &["macro"],
        &["macros"],
        &["mechanism"],
        &["mechanisms"],
        &["matched"],
        &["matches"],
        &["machete"],
        &["machine"],
        &["machines"],
        &["machinery"],
        &["machines"],
        &["machine", "marching", "matching"],
        &["machines"],
        &["mackerel"],
        &["malcolm"],
        &["macro"],
        &["macro"],
        &["macros"],
        &["package"],
        &["macros"],
        &["macro"],
        &["matching"],
        &["matchup"],
        &["matchups"],
    ],
    range: 1..=7,
};

static WORD_MAB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MAB_CHILDREN),
    value: None,
};

pub static WORD_MAB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("ye"),
        dictgen::InsensitiveStr::Ascii("yelline"),
    ],
    values: &[&["maybe"], &["maybe"], &["maybelline"]],
    range: 1..=7,
};

static WORD_MAA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_MAA_CHILDREN),
    value: None,
};

pub static WORD_MAA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ke"),
        dictgen::InsensitiveStr::Ascii("ngement"),
        dictgen::InsensitiveStr::Ascii("nger"),
        dictgen::InsensitiveStr::Ascii("ngers"),
    ],
    values: &[&["make"], &["management"], &["manager"], &["managers"]],
    range: 2..=7,
};

static WORD_L_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_L_CHILDREN),
    value: None,
};

static WORD_L_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_LA_NODE),
    None,
    Some(&WORD_LC_NODE),
    None,
    Some(&WORD_LE_NODE),
    Some(&WORD_LF_NODE),
    None,
    None,
    Some(&WORD_LI_NODE),
    None,
    Some(&WORD_LK_NODE),
    Some(&WORD_LL_NODE),
    Some(&WORD_LM_NODE),
    Some(&WORD_LN_NODE),
    Some(&WORD_LO_NODE),
    Some(&WORD_LP_NODE),
    None,
    None,
    Some(&WORD_LS_NODE),
    None,
    Some(&WORD_LU_NODE),
    Some(&WORD_LV_NODE),
    None,
    None,
    Some(&WORD_LY_NODE),
    None,
];

static WORD_LY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_LY_CHILDREN),
    value: None,
};

pub static WORD_LY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("bia")],
    values: &[&["libya"]],
    range: 3..=3,
};

static WORD_LV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_LV_CHILDREN),
    value: None,
};

pub static WORD_LV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eo"),
        dictgen::InsensitiveStr::Ascii("oe"),
    ],
    values: &[&["love"], &["love"]],
    range: 2..=2,
};

static WORD_LU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_LU_CHILDREN),
    value: None,
};

pub static WORD_LU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("anched"),
        dictgen::InsensitiveStr::Ascii("ancher"),
        dictgen::InsensitiveStr::Ascii("anchers"),
        dictgen::InsensitiveStr::Ascii("anches"),
        dictgen::InsensitiveStr::Ascii("anching"),
        dictgen::InsensitiveStr::Ascii("andry"),
        dictgen::InsensitiveStr::Ascii("bicrant"),
        dictgen::InsensitiveStr::Ascii("bircant"),
        dictgen::InsensitiveStr::Ascii("bricat"),
        dictgen::InsensitiveStr::Ascii("cifear"),
        dictgen::InsensitiveStr::Ascii("ckilly"),
        dictgen::InsensitiveStr::Ascii("ckliy"),
        dictgen::InsensitiveStr::Ascii("ckly"),
        dictgen::InsensitiveStr::Ascii("dcrious"),
        dictgen::InsensitiveStr::Ascii("dricous"),
        dictgen::InsensitiveStr::Ascii("gage"),
        dictgen::InsensitiveStr::Ascii("gages"),
        dictgen::InsensitiveStr::Ascii("icfer"),
        dictgen::InsensitiveStr::Ascii("ietenant"),
        dictgen::InsensitiveStr::Ascii("kid"),
        dictgen::InsensitiveStr::Ascii("minose"),
        dictgen::InsensitiveStr::Ascii("minousity"),
        dictgen::InsensitiveStr::Ascii("naticos"),
        dictgen::InsensitiveStr::Ascii("naticus"),
        dictgen::InsensitiveStr::Ascii("natis"),
        dictgen::InsensitiveStr::Ascii("nguage"),
        dictgen::InsensitiveStr::Ascii("nguages"),
        dictgen::InsensitiveStr::Ascii("shis"),
        dictgen::InsensitiveStr::Ascii("shisly"),
    ],
    values: &[
        &["launched"],
        &["launcher"],
        &["launchers"],
        &["launches"],
        &["launching"],
        &["laundry"],
        &["lubricant"],
        &["lubricant"],
        &["lubricant"],
        &["lucifer"],
        &["luckily"],
        &["luckily"],
        &["luckily"],
        &["ludicrous"],
        &["ludicrous"],
        &["luggage"],
        &["luggage"],
        &["lucifer"],
        &["lieutenant"],
        &["likud", "lucid"],
        &["luminous"],
        &["luminosity"],
        &["lunatics"],
        &["lunatics"],
        &["lunatics"],
        &["language"],
        &["languages"],
        &["luscious"],
        &["lusciously"],
    ],
    range: 3..=9,
};

static WORD_LS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_LS_CHILDREN),
    value: None,
};

pub static WORD_LS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("at"),
        dictgen::InsensitiveStr::Ascii("ip"),
        dictgen::InsensitiveStr::Ascii("it"),
        dictgen::InsensitiveStr::Ascii("its"),
    ],
    values: &[
        &["last", "slat", "sat"],
        &["lisp"],
        &["list", "slit", "sit"],
        &["lists", "slits", "sits"],
    ],
    range: 2..=3,
};

static WORD_LP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_LP_CHILDREN),
    value: None,
};

pub static WORD_LP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("atform")],
    values: &[&["platform"]],
    range: 6..=6,
};

static WORD_LO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_LO_CHILDREN),
    value: None,
};

static WORD_LO_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_LOA_NODE),
    Some(&WORD_LOB_NODE),
    Some(&WORD_LOC_NODE),
    Some(&WORD_LOD_NODE),
    Some(&WORD_LOE_NODE),
    None,
    Some(&WORD_LOG_NODE),
    None,
    Some(&WORD_LOI_NODE),
    None,
    Some(&WORD_LOK_NODE),
    Some(&WORD_LOL_NODE),
    None,
    Some(&WORD_LON_NODE),
    Some(&WORD_LOO_NODE),
    None,
    None,
    Some(&WORD_LOR_NODE),
    Some(&WORD_LOS_NODE),
    Some(&WORD_LOT_NODE),
    Some(&WORD_LOU_NODE),
    None,
    Some(&WORD_LOW_NODE),
    None,
    None,
    Some(&WORD_LOZ_NODE),
];

static WORD_LOZ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_LOZ_CHILDREN),
    value: None,
};

pub static WORD_LOZ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("onya")],
    values: &[&["lasagna"]],
    range: 4..=4,
};

static WORD_LOW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_LOW_CHILDREN),
    value: None,
};

pub static WORD_LOW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("case"),
        dictgen::InsensitiveStr::Ascii("d"),
    ],
    values: &[&["lowercase"], &["load", "low", "loud"]],
    range: 1..=4,
};

static WORD_LOU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_LOU_CHILDREN),
    value: None,
};

pub static WORD_LOU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ieville"),
        dictgen::InsensitiveStr::Ascii("isiania"),
        dictgen::InsensitiveStr::Ascii("isianna"),
        dictgen::InsensitiveStr::Ascii("isivlle"),
        dictgen::InsensitiveStr::Ascii("isviile"),
        dictgen::InsensitiveStr::Ascii("isvile"),
        dictgen::InsensitiveStr::Ascii("isvillle"),
        dictgen::InsensitiveStr::Ascii("siville"),
    ],
    values: &[
        &["louisville"],
        &["louisiana"],
        &["louisiana"],
        &["louisville"],
        &["louisville"],
        &["louisville"],
        &["louisville"],
        &["louisville"],
    ],
    range: 6..=8,
};

static WORD_LOT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_LOT_CHILDREN),
    value: None,
};

pub static WORD_LOT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ation"),
        dictgen::InsensitiveStr::Ascii("haringen"),
    ],
    values: &[&["rotation", "flotation"], &["lothringen"]],
    range: 5..=8,
};

static WORD_LOS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_LOS_CHILDREN),
    value: None,
};

pub static WORD_LOS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("d"),
        dictgen::InsensitiveStr::Ascii("ely"),
        dictgen::InsensitiveStr::Ascii("en"),
        dictgen::InsensitiveStr::Ascii("ened"),
        dictgen::InsensitiveStr::Ascii("slesly"),
        dictgen::InsensitiveStr::Ascii("ted"),
    ],
    values: &[
        &["lost", "loss", "lose", "load"],
        &["loosely"],
        &["loosen"],
        &["loosened"],
        &["losslessly"],
        &["listed", "lost", "lasted"],
    ],
    range: 1..=6,
};

static WORD_LOR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_LOR_CHILDREN),
    value: None,
};

pub static WORD_LOR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("eplay")],
    values: &[&["roleplay"]],
    range: 5..=5,
};

static WORD_LOO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_LOO_CHILDREN),
    value: None,
};

pub static WORD_LOO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("back"),
        dictgen::InsensitiveStr::Ascii("backs"),
        dictgen::InsensitiveStr::Ascii("bpack"),
        dictgen::InsensitiveStr::Ascii("ck"),
        dictgen::InsensitiveStr::Ascii("ckdown"),
        dictgen::InsensitiveStr::Ascii("cking"),
        dictgen::InsensitiveStr::Ascii("ckup"),
        dictgen::InsensitiveStr::Ascii("d"),
        dictgen::InsensitiveStr::Ascii("kes"),
        dictgen::InsensitiveStr::Ascii("knig"),
        dictgen::InsensitiveStr::Ascii("op"),
        dictgen::InsensitiveStr::Ascii("pup"),
        dictgen::InsensitiveStr::Ascii("seley"),
        dictgen::InsensitiveStr::Ascii("sley"),
        dictgen::InsensitiveStr::Ascii("sly"),
        dictgen::InsensitiveStr::Ascii("sy"),
    ],
    values: &[
        &["loopback"],
        &["loopbacks"],
        &["loopback"],
        &["lock", "look"],
        &["lockdown"],
        &["locking", "looking"],
        &["lockup", "lookup"],
        &["blood", "flood", "lewd", "look", "loom", "mood"],
        &["looks"],
        &["looking"],
        &["loop"],
        &["lookup"],
        &["loosely"],
        &["loosely"],
        &["loosely"],
        &["lossy", "lousy", "loose"],
    ],
    range: 1..=6,
};

static WORD_LON_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_LON_CHILDREN),
    value: None,
};

pub static WORD_LON_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ber"),
        dictgen::InsensitiveStr::Ascii("d"),
        dictgen::InsensitiveStr::Ascii("elyness"),
        dictgen::InsensitiveStr::Ascii("ge"),
        dictgen::InsensitiveStr::Ascii("gers"),
        dictgen::InsensitiveStr::Ascii("gevitity"),
        dictgen::InsensitiveStr::Ascii("gevitiy"),
        dictgen::InsensitiveStr::Ascii("gitme"),
        dictgen::InsensitiveStr::Ascii("gitudonal"),
        dictgen::InsensitiveStr::Ascii("gitue"),
        dictgen::InsensitiveStr::Ascii("gitutde"),
        dictgen::InsensitiveStr::Ascii("gitute"),
        dictgen::InsensitiveStr::Ascii("gst"),
        dictgen::InsensitiveStr::Ascii("gtiem"),
        dictgen::InsensitiveStr::Ascii("guer"),
        dictgen::InsensitiveStr::Ascii("guest"),
        dictgen::InsensitiveStr::Ascii("ileness"),
        dictgen::InsensitiveStr::Ascii("ley"),
        dictgen::InsensitiveStr::Ascii("lieness"),
        dictgen::InsensitiveStr::Ascii("ly"),
    ],
    values: &[
        &["longer", "loner"],
        &["long"],
        &["loneliness"],
        &["longer", "lounge"],
        &["longer"],
        &["longevity"],
        &["longevity"],
        &["longtime"],
        &["longitudinal"],
        &["longitude"],
        &["longitude"],
        &["longitude"],
        &["longest"],
        &["longtime"],
        &["longer"],
        &["longest"],
        &["loneliness"],
        &["lonely"],
        &["loneliness"],
        &["lonely", "only"],
    ],
    range: 1..=9,
};

static WORD_LOL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_LOL_CHILDREN),
    value: None,
};

pub static WORD_LOL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("al"),
        dictgen::InsensitiveStr::Ascii("erant"),
        dictgen::InsensitiveStr::Ascii("lipoop"),
        dictgen::InsensitiveStr::Ascii("lipoopy"),
    ],
    values: &[&["total"], &["tolerant"], &["lollipop"], &["lollipop"]],
    range: 2..=7,
};

static WORD_LOK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_LOK_CHILDREN),
    value: None,
};

pub static WORD_LOK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("al"),
        dictgen::InsensitiveStr::Ascii("ale"),
        dictgen::InsensitiveStr::Ascii("ales"),
        dictgen::InsensitiveStr::Ascii("aly"),
    ],
    values: &[&["local"], &["locale"], &["locales"], &["locally"]],
    range: 2..=4,
};

static WORD_LOI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_LOI_CHILDREN),
    value: None,
};

pub static WORD_LOI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("gn"),
        dictgen::InsensitiveStr::Ascii("gns"),
        dictgen::InsensitiveStr::Ascii("usiana"),
        dictgen::InsensitiveStr::Ascii("usville"),
    ],
    values: &[&["login"], &["logins"], &["louisiana"], &["louisville"]],
    range: 2..=7,
};

static WORD_LOG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_LOG_CHILDREN),
    value: None,
};

pub static WORD_LOG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("arithimic"),
        dictgen::InsensitiveStr::Ascii("arithmical"),
        dictgen::InsensitiveStr::Ascii("aritmic"),
        dictgen::InsensitiveStr::Ascii("cal"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("er"),
        dictgen::InsensitiveStr::Ascii("gging"),
        dictgen::InsensitiveStr::Ascii("gin"),
        dictgen::InsensitiveStr::Ascii("ial"),
        dictgen::InsensitiveStr::Ascii("ially"),
        dictgen::InsensitiveStr::Ascii("icaly"),
        dictgen::InsensitiveStr::Ascii("ictech"),
        dictgen::InsensitiveStr::Ascii("ictical"),
        dictgen::InsensitiveStr::Ascii("ile"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("isitcal"),
        dictgen::InsensitiveStr::Ascii("isitcs"),
        dictgen::InsensitiveStr::Ascii("isticas"),
        dictgen::InsensitiveStr::Ascii("isticly"),
        dictgen::InsensitiveStr::Ascii("iteh"),
        dictgen::InsensitiveStr::Ascii("itude"),
        dictgen::InsensitiveStr::Ascii("itudes"),
        dictgen::InsensitiveStr::Ascii("ner"),
        dictgen::InsensitiveStr::Ascii("oic"),
        dictgen::InsensitiveStr::Ascii("orithm"),
        dictgen::InsensitiveStr::Ascii("orithmic"),
        dictgen::InsensitiveStr::Ascii("orithms"),
        dictgen::InsensitiveStr::Ascii("rithm"),
        dictgen::InsensitiveStr::Ascii("rithms"),
        dictgen::InsensitiveStr::Ascii("sitics"),
        dictgen::InsensitiveStr::Ascii("tiech"),
        dictgen::InsensitiveStr::Ascii("writter"),
    ],
    values: &[
        &["logarithmic"],
        &["logarithmically"],
        &["logarithmic"],
        &["logical"],
        &["logged", "lodged", "longed"],
        &["logger", "lodger", "longer"],
        &["logging"],
        &["login", "logging"],
        &["logical"],
        &["logically"],
        &["logically"],
        &["logitech"],
        &["logistical"],
        &["logfile"],
        &["logging", "lodging"],
        &["logistical"],
        &["logistics"],
        &["logistics"],
        &["logistical"],
        &["logitech"],
        &["longitude"],
        &["longitudes"],
        &["logger", "longer"],
        &["logic"],
        &["logarithm"],
        &["logarithmic"],
        &["logarithms"],
        &["logarithm"],
        &["logarithms"],
        &["logistics"],
        &["logitech"],
        &["logwriter"],
    ],
    range: 2..=10,
};

static WORD_LOE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_LOE_CHILDREN),
    value: None,
};

pub static WORD_LOE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("nard"),
        dictgen::InsensitiveStr::Ascii("pard"),
        dictgen::InsensitiveStr::Ascii("v"),
    ],
    values: &[&["leonard"], &["leopard"], &["love"]],
    range: 1..=4,
};

static WORD_LOD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_LOD_CHILDREN),
    value: Some(&["load"]),
};

pub static WORD_LOD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("able"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("er"),
        dictgen::InsensitiveStr::Ascii("ers"),
        dictgen::InsensitiveStr::Ascii("ing"),
    ],
    values: &[
        &["loadable"],
        &["loaded"],
        &["loader"],
        &["loaders"],
        &["loading"],
    ],
    range: 2..=4,
};

static WORD_LOC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_LOC_CHILDREN),
    value: None,
};

pub static WORD_LOC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("a"),
        dictgen::InsensitiveStr::Ascii("ae"),
        dictgen::InsensitiveStr::Ascii("aes"),
        dictgen::InsensitiveStr::Ascii("ahost"),
        dictgen::InsensitiveStr::Ascii("aiing"),
        dictgen::InsensitiveStr::Ascii("ailty"),
        dictgen::InsensitiveStr::Ascii("aing"),
        dictgen::InsensitiveStr::Ascii("aion"),
        dictgen::InsensitiveStr::Ascii("aions"),
        dictgen::InsensitiveStr::Ascii("aise"),
        dictgen::InsensitiveStr::Ascii("aised"),
        dictgen::InsensitiveStr::Ascii("aiser"),
        dictgen::InsensitiveStr::Ascii("aises"),
        dictgen::InsensitiveStr::Ascii("aite"),
        dictgen::InsensitiveStr::Ascii("aites"),
        dictgen::InsensitiveStr::Ascii("aiting"),
        dictgen::InsensitiveStr::Ascii("aition"),
        dictgen::InsensitiveStr::Ascii("aitions"),
        dictgen::InsensitiveStr::Ascii("aiton"),
        dictgen::InsensitiveStr::Ascii("aitons"),
        dictgen::InsensitiveStr::Ascii("aize"),
        dictgen::InsensitiveStr::Ascii("aized"),
        dictgen::InsensitiveStr::Ascii("aizer"),
        dictgen::InsensitiveStr::Ascii("aizes"),
        dictgen::InsensitiveStr::Ascii("alation"),
        dictgen::InsensitiveStr::Ascii("aled"),
        dictgen::InsensitiveStr::Ascii("altion"),
        dictgen::InsensitiveStr::Ascii("altions"),
        dictgen::InsensitiveStr::Ascii("aly"),
        dictgen::InsensitiveStr::Ascii("alzation"),
        dictgen::InsensitiveStr::Ascii("atins"),
        dictgen::InsensitiveStr::Ascii("atio"),
        dictgen::InsensitiveStr::Ascii("atoin"),
        dictgen::InsensitiveStr::Ascii("atoins"),
        dictgen::InsensitiveStr::Ascii("cked"),
        dictgen::InsensitiveStr::Ascii("gical"),
        dictgen::InsensitiveStr::Ascii("kacreen"),
        dictgen::InsensitiveStr::Ascii("kingf"),
        dictgen::InsensitiveStr::Ascii("kscreeen"),
        dictgen::InsensitiveStr::Ascii("kscren"),
        dictgen::InsensitiveStr::Ascii("la"),
        dictgen::InsensitiveStr::Ascii("las"),
    ],
    values: &[
        &["local"],
        &["locate"],
        &["locates"],
        &["localhost"],
        &["locating"],
        &["locality"],
        &["locating"],
        &["location"],
        &["locations"],
        &["localise"],
        &["localised"],
        &["localiser"],
        &["localises"],
        &["locate"],
        &["locates"],
        &["locating"],
        &["location"],
        &["locations"],
        &["location"],
        &["locations"],
        &["localize"],
        &["localized"],
        &["localizer"],
        &["localizes"],
        &["location"],
        &["located"],
        &["location"],
        &["locations"],
        &["locally"],
        &["localization"],
        &["locations"],
        &["locations"],
        &["location"],
        &["locations"],
        &["locked"],
        &["logical"],
        &["lockscreen"],
        &["locking"],
        &["lockscreen"],
        &["lockscreen"],
        &["local"],
        &["locals"],
    ],
    range: 1..=8,
};

static WORD_LOB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_LOB_CHILDREN),
    value: None,
};

pub static WORD_LOB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("byistes"),
        dictgen::InsensitiveStr::Ascii("bysits"),
    ],
    values: &[&["lobbyists"], &["lobbyists"]],
    range: 6..=7,
};

static WORD_LOA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_LOA_CHILDREN),
    value: None,
};

pub static WORD_LOA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ader"),
        dictgen::InsensitiveStr::Ascii("cal"),
        dictgen::InsensitiveStr::Ascii("cality"),
        dictgen::InsensitiveStr::Ascii("cally"),
        dictgen::InsensitiveStr::Ascii("cation"),
        dictgen::InsensitiveStr::Ascii("ction"),
        dictgen::InsensitiveStr::Ascii("ctions"),
        dictgen::InsensitiveStr::Ascii("dig"),
        dictgen::InsensitiveStr::Ascii("din"),
        dictgen::InsensitiveStr::Ascii("dning"),
        dictgen::InsensitiveStr::Ascii("dous"),
    ],
    values: &[
        &["loader"],
        &["local"],
        &["locality"],
        &["locally"],
        &["location"],
        &["location"],
        &["locations"],
        &["loading"],
        &["loading"],
        &["loading"],
        &["loadouts"],
    ],
    range: 3..=6,
};

static WORD_LN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_LN_CHILDREN),
    value: None,
};

pub static WORD_LN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("guage"),
        dictgen::InsensitiveStr::Ascii("guages"),
        dictgen::InsensitiveStr::Ascii("owledgable"),
    ],
    values: &[&["language"], &["languages"], &["knowledgable"]],
    range: 5..=10,
};

static WORD_LM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_LM_CHILDREN),
    value: None,
};

pub static WORD_LM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("its")],
    values: &[&["limits"]],
    range: 3..=3,
};

static WORD_LL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_LL_CHILDREN),
    value: None,
};

pub static WORD_LL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("inear")],
    values: &[&["linear"]],
    range: 5..=5,
};

static WORD_LK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_LK_CHILDREN),
    value: None,
};

pub static WORD_LK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("e")],
    values: &[&["like"]],
    range: 1..=1,
};

static WORD_LI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_LI_CHILDREN),
    value: None,
};

static WORD_LI_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_LIA_NODE),
    Some(&WORD_LIB_NODE),
    Some(&WORD_LIC_NODE),
    None,
    Some(&WORD_LIE_NODE),
    Some(&WORD_LIF_NODE),
    Some(&WORD_LIG_NODE),
    None,
    Some(&WORD_LII_NODE),
    None,
    Some(&WORD_LIK_NODE),
    Some(&WORD_LIL_NODE),
    Some(&WORD_LIM_NODE),
    Some(&WORD_LIN_NODE),
    Some(&WORD_LIO_NODE),
    Some(&WORD_LIP_NODE),
    Some(&WORD_LIQ_NODE),
    None,
    Some(&WORD_LIS_NODE),
    Some(&WORD_LIT_NODE),
    Some(&WORD_LIU_NODE),
    Some(&WORD_LIV_NODE),
    None,
    None,
    None,
    Some(&WORD_LIZ_NODE),
];

static WORD_LIZ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_LIZ_CHILDREN),
    value: None,
};

pub static WORD_LIZ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ens"),
        dictgen::InsensitiveStr::Ascii("ense"),
        dictgen::InsensitiveStr::Ascii("ensing"),
    ],
    values: &[&["license"], &["license"], &["licensing"]],
    range: 3..=6,
};

static WORD_LIV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_LIV_CHILDREN),
    value: None,
};

pub static WORD_LIV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eatream"),
        dictgen::InsensitiveStr::Ascii("eing"),
        dictgen::InsensitiveStr::Ascii("el"),
        dictgen::InsensitiveStr::Ascii("elehood"),
        dictgen::InsensitiveStr::Ascii("eprool"),
        dictgen::InsensitiveStr::Ascii("erpol"),
        dictgen::InsensitiveStr::Ascii("erpoool"),
        dictgen::InsensitiveStr::Ascii("escream"),
        dictgen::InsensitiveStr::Ascii("estreem"),
        dictgen::InsensitiveStr::Ascii("estrem"),
        dictgen::InsensitiveStr::Ascii("estrems"),
        dictgen::InsensitiveStr::Ascii("etime"),
        dictgen::InsensitiveStr::Ascii("ilehood"),
        dictgen::InsensitiveStr::Ascii("ley"),
        dictgen::InsensitiveStr::Ascii("liehood"),
    ],
    values: &[
        &["livestream"],
        &["living"],
        &["level"],
        &["livelihood"],
        &["liverpool"],
        &["liverpool"],
        &["liverpool"],
        &["livestream"],
        &["livestream"],
        &["livestream"],
        &["livestream"],
        &["lifetime"],
        &["livelihood"],
        &["lively"],
        &["livelihood"],
    ],
    range: 2..=7,
};

static WORD_LIU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_LIU_CHILDREN),
    value: None,
};

pub static WORD_LIU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("etenant"),
        dictgen::InsensitiveStr::Ascii("ke"),
    ],
    values: &[&["lieutenant"], &["like"]],
    range: 2..=7,
};

static WORD_LIT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_LIT_CHILDREN),
    value: None,
};

pub static WORD_LIT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aral"),
        dictgen::InsensitiveStr::Ascii("arally"),
        dictgen::InsensitiveStr::Ascii("arals"),
        dictgen::InsensitiveStr::Ascii("ature"),
        dictgen::InsensitiveStr::Ascii("eautrue"),
        dictgen::InsensitiveStr::Ascii("ecion"),
        dictgen::InsensitiveStr::Ascii("econ"),
        dictgen::InsensitiveStr::Ascii("eicon"),
        dictgen::InsensitiveStr::Ascii("erae"),
        dictgen::InsensitiveStr::Ascii("erallly"),
        dictgen::InsensitiveStr::Ascii("eraly"),
        dictgen::InsensitiveStr::Ascii("erarely"),
        dictgen::InsensitiveStr::Ascii("erarlly"),
        dictgen::InsensitiveStr::Ascii("erarly"),
        dictgen::InsensitiveStr::Ascii("erarry"),
        dictgen::InsensitiveStr::Ascii("eratire"),
        dictgen::InsensitiveStr::Ascii("erative"),
        dictgen::InsensitiveStr::Ascii("eratre"),
        dictgen::InsensitiveStr::Ascii("eratue"),
        dictgen::InsensitiveStr::Ascii("eratute"),
        dictgen::InsensitiveStr::Ascii("erture"),
        dictgen::InsensitiveStr::Ascii("haunia"),
        dictgen::InsensitiveStr::Ascii("huaina"),
        dictgen::InsensitiveStr::Ascii("huana"),
        dictgen::InsensitiveStr::Ascii("huanina"),
        dictgen::InsensitiveStr::Ascii("huaninan"),
        dictgen::InsensitiveStr::Ascii("huiana"),
        dictgen::InsensitiveStr::Ascii("huim"),
        dictgen::InsensitiveStr::Ascii("hunaia"),
        dictgen::InsensitiveStr::Ascii("igatin"),
        dictgen::InsensitiveStr::Ascii("igato"),
        dictgen::InsensitiveStr::Ascii("ihum"),
        dictgen::InsensitiveStr::Ascii("le"),
        dictgen::InsensitiveStr::Ascii("llefinger"),
        dictgen::InsensitiveStr::Ascii("quid"),
        dictgen::InsensitiveStr::Ascii("quids"),
        dictgen::InsensitiveStr::Ascii("s"),
        dictgen::InsensitiveStr::Ascii("te"),
        dictgen::InsensitiveStr::Ascii("tel"),
        dictgen::InsensitiveStr::Ascii("tele"),
        dictgen::InsensitiveStr::Ascii("telfinger"),
        dictgen::InsensitiveStr::Ascii("telry"),
        dictgen::InsensitiveStr::Ascii("teral"),
        dictgen::InsensitiveStr::Ascii("terally"),
        dictgen::InsensitiveStr::Ascii("terals"),
        dictgen::InsensitiveStr::Ascii("terate"),
        dictgen::InsensitiveStr::Ascii("terature"),
        dictgen::InsensitiveStr::Ascii("terfinger"),
        dictgen::InsensitiveStr::Ascii("tiefinger"),
        dictgen::InsensitiveStr::Ascii("tlefiger"),
        dictgen::InsensitiveStr::Ascii("tlefigner"),
        dictgen::InsensitiveStr::Ascii("tlefinder"),
        dictgen::InsensitiveStr::Ascii("tlefiner"),
        dictgen::InsensitiveStr::Ascii("tlepinger"),
        dictgen::InsensitiveStr::Ascii("uhania"),
        dictgen::InsensitiveStr::Ascii("urature"),
    ],
    values: &[
        &["literal"],
        &["literally"],
        &["literals"],
        &["literature"],
        &["literature"],
        &["litecoin"],
        &["litecoin"],
        &["litecoin"],
        &["literate"],
        &["literally"],
        &["literally"],
        &["literary"],
        &["literary"],
        &["literary"],
        &["literary"],
        &["literate"],
        &["literate"],
        &["literate"],
        &["literate"],
        &["literate"],
        &["literature"],
        &["lithuania"],
        &["lithuania"],
        &["lithuania"],
        &["lithuania"],
        &["lithuania"],
        &["lithuania"],
        &["lithium"],
        &["lithuania"],
        &["litigation"],
        &["litigation"],
        &["lithium"],
        &["little"],
        &["littlefinger"],
        &["liquid"],
        &["liquids"],
        &["list"],
        &["little"],
        &["little"],
        &["little"],
        &["littlefinger"],
        &["literally"],
        &["literal"],
        &["literally"],
        &["literals"],
        &["literate"],
        &["literature"],
        &["littlefinger"],
        &["littlefinger"],
        &["littlefinger"],
        &["littlefinger"],
        &["littlefinger"],
        &["littlefinger"],
        &["littlefinger"],
        &["lithuania"],
        &["literature"],
    ],
    range: 1..=9,
};

static WORD_LIS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_LIS_CHILDREN),
    value: None,
};

pub static WORD_LIS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cense"),
        dictgen::InsensitiveStr::Ascii("ence"),
        dictgen::InsensitiveStr::Ascii("enced"),
        dictgen::InsensitiveStr::Ascii("ense"),
        dictgen::InsensitiveStr::Ascii("etning"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("pticks"),
        dictgen::InsensitiveStr::Ascii("tapck"),
        dictgen::InsensitiveStr::Ascii("tbbox"),
        dictgen::InsensitiveStr::Ascii("teing"),
        dictgen::InsensitiveStr::Ascii("tend"),
        dictgen::InsensitiveStr::Ascii("teneing"),
        dictgen::InsensitiveStr::Ascii("tenend"),
        dictgen::InsensitiveStr::Ascii("teneres"),
        dictgen::InsensitiveStr::Ascii("tenes"),
        dictgen::InsensitiveStr::Ascii("tenning"),
        dictgen::InsensitiveStr::Ascii("tensers"),
        dictgen::InsensitiveStr::Ascii("tent"),
        dictgen::InsensitiveStr::Ascii("tenter"),
        dictgen::InsensitiveStr::Ascii("tenters"),
        dictgen::InsensitiveStr::Ascii("tents"),
        dictgen::InsensitiveStr::Ascii("terner"),
        dictgen::InsensitiveStr::Ascii("ternes"),
        dictgen::InsensitiveStr::Ascii("tes"),
        dictgen::InsensitiveStr::Ascii("tner"),
        dictgen::InsensitiveStr::Ascii("tners"),
    ],
    values: &[
        &["license"],
        &["licence"],
        &["silenced"],
        &["license"],
        &["listening"],
        &["listing"],
        &["lipsticks"],
        &["listpack"],
        &["listbox"],
        &["listening"],
        &["listened"],
        &["listening"],
        &["listened"],
        &["listeners"],
        &["listens"],
        &["listening"],
        &["listeners"],
        &["listen"],
        &["listener"],
        &["listeners"],
        &["listens"],
        &["listener"],
        &["listeners"],
        &["listed"],
        &["listener"],
        &["listeners"],
    ],
    range: 3..=7,
};

static WORD_LIQ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_LIQ_CHILDREN),
    value: None,
};

pub static WORD_LIQ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("iuds"),
        dictgen::InsensitiveStr::Ascii("uidas"),
        dictgen::InsensitiveStr::Ascii("uides"),
        dictgen::InsensitiveStr::Ascii("uidos"),
        dictgen::InsensitiveStr::Ascii("uour"),
    ],
    values: &[
        &["liquids"],
        &["liquids"],
        &["liquids"],
        &["liquids"],
        &["liquor"],
    ],
    range: 4..=5,
};

static WORD_LIP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_LIP_CHILDREN),
    value: None,
};

pub static WORD_LIP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("pizaner"),
        dictgen::InsensitiveStr::Ascii("stics"),
    ],
    values: &[&["lipizzaner"], &["lipsticks"]],
    range: 5..=7,
};

static WORD_LIO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_LIO_CHILDREN),
    value: None,
};

pub static WORD_LIO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("usville")],
    values: &[&["louisville"]],
    range: 7..=7,
};

static WORD_LIN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_LIN_CHILDREN),
    value: None,
};

pub static WORD_LIN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aer"),
        dictgen::InsensitiveStr::Ascii("ar"),
        dictgen::InsensitiveStr::Ascii("arly"),
        dictgen::InsensitiveStr::Ascii("cese"),
        dictgen::InsensitiveStr::Ascii("cesed"),
        dictgen::InsensitiveStr::Ascii("ceses"),
        dictgen::InsensitiveStr::Ascii("clon"),
        dictgen::InsensitiveStr::Ascii("colin"),
        dictgen::InsensitiveStr::Ascii("colon"),
        dictgen::InsensitiveStr::Ascii("earily"),
        dictgen::InsensitiveStr::Ascii("eary"),
        dictgen::InsensitiveStr::Ascii("erisation"),
        dictgen::InsensitiveStr::Ascii("erisations"),
        dictgen::InsensitiveStr::Ascii("eseach"),
        dictgen::InsensitiveStr::Ascii("eseaches"),
        dictgen::InsensitiveStr::Ascii("ess"),
        dictgen::InsensitiveStr::Ascii("eupes"),
        dictgen::InsensitiveStr::Ascii("ewdith"),
        dictgen::InsensitiveStr::Ascii("ez"),
        dictgen::InsensitiveStr::Ascii("geire"),
        dictgen::InsensitiveStr::Ascii("gerine"),
        dictgen::InsensitiveStr::Ascii("giere"),
        dictgen::InsensitiveStr::Ascii("gth"),
        dictgen::InsensitiveStr::Ascii("guisics"),
        dictgen::InsensitiveStr::Ascii("guisitc"),
        dictgen::InsensitiveStr::Ascii("guisitcs"),
        dictgen::InsensitiveStr::Ascii("guisitic"),
        dictgen::InsensitiveStr::Ascii("guistcs"),
        dictgen::InsensitiveStr::Ascii("guisticas"),
        dictgen::InsensitiveStr::Ascii("guisticos"),
        dictgen::InsensitiveStr::Ascii("guistis"),
        dictgen::InsensitiveStr::Ascii("guistisch"),
        dictgen::InsensitiveStr::Ascii("guitics"),
        dictgen::InsensitiveStr::Ascii("gusitic"),
        dictgen::InsensitiveStr::Ascii("gusitics"),
        dictgen::InsensitiveStr::Ascii("gvistic"),
        dictgen::InsensitiveStr::Ascii("height"),
        dictgen::InsensitiveStr::Ascii("ix"),
        dictgen::InsensitiveStr::Ascii("ke"),
        dictgen::InsensitiveStr::Ascii("kfy"),
        dictgen::InsensitiveStr::Ascii("naena"),
        dictgen::InsensitiveStr::Ascii("tain"),
        dictgen::InsensitiveStr::Ascii("ueps"),
        dictgen::InsensitiveStr::Ascii("z"),
    ],
    values: &[
        &["linear"],
        &["linear"],
        &["linearly"],
        &["license"],
        &["licensed"],
        &["licenses"],
        &["lincoln"],
        &["lincoln"],
        &["lincoln"],
        &["linearly", "linearity"],
        &["linearly"],
        &["linearisation"],
        &["linearisations"],
        &["linesearch"],
        &["linesearches"],
        &["lines"],
        &["lineups"],
        &["linewidth"],
        &["lines"],
        &["lingerie"],
        &["lingerie"],
        &["lingerie"],
        &["length"],
        &["linguistics"],
        &["linguistics"],
        &["linguistics"],
        &["linguistic"],
        &["linguistics"],
        &["linguistics"],
        &["linguistics"],
        &["linguistics"],
        &["linguistics"],
        &["linguistic"],
        &["linguistics"],
        &["linguistics"],
        &["linguistic"],
        &["lineheight"],
        &["linux"],
        &["linked", "like"],
        &["linkify"],
        &["linnaean"],
        &["lintian"],
        &["lineups"],
        &["lines"],
    ],
    range: 1..=10,
};

static WORD_LIM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_LIM_CHILDREN),
    value: None,
};

pub static WORD_LIM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("iation"),
        dictgen::InsensitiveStr::Ascii("iations"),
        dictgen::InsensitiveStr::Ascii("ination"),
        dictgen::InsensitiveStr::Ascii("inted"),
        dictgen::InsensitiveStr::Ascii("itacion"),
        dictgen::InsensitiveStr::Ascii("itaion"),
        dictgen::InsensitiveStr::Ascii("itaions"),
        dictgen::InsensitiveStr::Ascii("itaiton"),
        dictgen::InsensitiveStr::Ascii("itaitons"),
        dictgen::InsensitiveStr::Ascii("itant"),
        dictgen::InsensitiveStr::Ascii("itating"),
        dictgen::InsensitiveStr::Ascii("itativo"),
        dictgen::InsensitiveStr::Ascii("itato"),
        dictgen::InsensitiveStr::Ascii("ite"),
        dictgen::InsensitiveStr::Ascii("itiaion"),
        dictgen::InsensitiveStr::Ascii("itiaions"),
        dictgen::InsensitiveStr::Ascii("itiation"),
        dictgen::InsensitiveStr::Ascii("itiations"),
        dictgen::InsensitiveStr::Ascii("itied"),
        dictgen::InsensitiveStr::Ascii("itier"),
        dictgen::InsensitiveStr::Ascii("itiers"),
        dictgen::InsensitiveStr::Ascii("itiing"),
        dictgen::InsensitiveStr::Ascii("itimg"),
        dictgen::InsensitiveStr::Ascii("ition"),
        dictgen::InsensitiveStr::Ascii("itions"),
        dictgen::InsensitiveStr::Ascii("itis"),
        dictgen::InsensitiveStr::Ascii("ititation"),
        dictgen::InsensitiveStr::Ascii("ititations"),
        dictgen::InsensitiveStr::Ascii("itited"),
        dictgen::InsensitiveStr::Ascii("ititer"),
        dictgen::InsensitiveStr::Ascii("ititers"),
        dictgen::InsensitiveStr::Ascii("ititing"),
        dictgen::InsensitiveStr::Ascii("itted"),
        dictgen::InsensitiveStr::Ascii("itter"),
        dictgen::InsensitiveStr::Ascii("itting"),
        dictgen::InsensitiveStr::Ascii("itts"),
        dictgen::InsensitiveStr::Ascii("k"),
        dictgen::InsensitiveStr::Ascii("osine"),
        dictgen::InsensitiveStr::Ascii("osines"),
        dictgen::InsensitiveStr::Ascii("ted"),
        dictgen::InsensitiveStr::Ascii("ti"),
        dictgen::InsensitiveStr::Ascii("ts"),
    ],
    values: &[
        &["limitation"],
        &["limitations"],
        &["limitation", "lamination"],
        &["limited"],
        &["limitation"],
        &["limitation"],
        &["limitations"],
        &["limitation"],
        &["limitation", "limitations"],
        &["militant"],
        &["limitation"],
        &["limitation"],
        &["limitation"],
        &["limit"],
        &["limitation"],
        &["limitations"],
        &["limitation"],
        &["limitations"],
        &["limited"],
        &["limiter"],
        &["limiters"],
        &["limiting"],
        &["limiting"],
        &["limitation"],
        &["limitations"],
        &["limits"],
        &["limitation"],
        &["limitations"],
        &["limited"],
        &["limiter"],
        &["limiters"],
        &["limiting"],
        &["limited"],
        &["limiter"],
        &["limiting"],
        &["limits"],
        &["link"],
        &["limousine"],
        &["limousines"],
        &["limited"],
        &["limit"],
        &["limits"],
    ],
    range: 1..=10,
};

static WORD_LIL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_LIL_CHILDREN),
    value: None,
};

pub static WORD_LIL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("eral")],
    values: &[&["literal"]],
    range: 4..=4,
};

static WORD_LIK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_LIK_CHILDREN),
    value: Some(&["like", "lick", "link"]),
};

pub static WORD_LIK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ebale"),
        dictgen::InsensitiveStr::Ascii("eley"),
        dictgen::InsensitiveStr::Ascii("elly"),
        dictgen::InsensitiveStr::Ascii("elyhood"),
        dictgen::InsensitiveStr::Ascii("ewis"),
        dictgen::InsensitiveStr::Ascii("ey"),
        dictgen::InsensitiveStr::Ascii("lelihood"),
        dictgen::InsensitiveStr::Ascii("ley"),
        dictgen::InsensitiveStr::Ascii("ly"),
    ],
    values: &[
        &["likeable"],
        &["likely"],
        &["likely"],
        &["likelihood"],
        &["likewise"],
        &["likely"],
        &["likelihood"],
        &["likely"],
        &["likely"],
    ],
    range: 2..=8,
};

static WORD_LII_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_LII_CHILDREN),
    value: None,
};

pub static WORD_LII_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("tle")],
    values: &[&["little"]],
    range: 3..=3,
};

static WORD_LIG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_LIG_CHILDREN),
    value: None,
};

pub static WORD_LIG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("h"),
        dictgen::InsensitiveStr::Ascii("her"),
        dictgen::InsensitiveStr::Ascii("hers"),
        dictgen::InsensitiveStr::Ascii("hhtning"),
        dictgen::InsensitiveStr::Ascii("hing"),
        dictgen::InsensitiveStr::Ascii("hitng"),
        dictgen::InsensitiveStr::Ascii("hlty"),
        dictgen::InsensitiveStr::Ascii("hnting"),
        dictgen::InsensitiveStr::Ascii("htbulp"),
        dictgen::InsensitiveStr::Ascii("htenning"),
        dictgen::InsensitiveStr::Ascii("htenting"),
        dictgen::InsensitiveStr::Ascii("htergas"),
        dictgen::InsensitiveStr::Ascii("htes"),
        dictgen::InsensitiveStr::Ascii("hthearded"),
        dictgen::InsensitiveStr::Ascii("htheared"),
        dictgen::InsensitiveStr::Ascii("hthearthed"),
        dictgen::InsensitiveStr::Ascii("htheated"),
        dictgen::InsensitiveStr::Ascii("hthning"),
        dictgen::InsensitiveStr::Ascii("hthorse"),
        dictgen::InsensitiveStr::Ascii("hthosue"),
        dictgen::InsensitiveStr::Ascii("hthours"),
        dictgen::InsensitiveStr::Ascii("htining"),
        dictgen::InsensitiveStr::Ascii("htneing"),
        dictgen::InsensitiveStr::Ascii("htnig"),
        dictgen::InsensitiveStr::Ascii("htnign"),
        dictgen::InsensitiveStr::Ascii("htnting"),
        dictgen::InsensitiveStr::Ascii("htres"),
        dictgen::InsensitiveStr::Ascii("htrom"),
        dictgen::InsensitiveStr::Ascii("htrooom"),
        dictgen::InsensitiveStr::Ascii("htweigh"),
        dictgen::InsensitiveStr::Ascii("htweigt"),
        dictgen::InsensitiveStr::Ascii("htweigth"),
        dictgen::InsensitiveStr::Ascii("htwieght"),
        dictgen::InsensitiveStr::Ascii("htwight"),
        dictgen::InsensitiveStr::Ascii("htwright"),
        dictgen::InsensitiveStr::Ascii("itamacy"),
        dictgen::InsensitiveStr::Ascii("itamassy"),
        dictgen::InsensitiveStr::Ascii("itamate"),
        dictgen::InsensitiveStr::Ascii("itamately"),
        dictgen::InsensitiveStr::Ascii("itation"),
        dictgen::InsensitiveStr::Ascii("th"),
        dictgen::InsensitiveStr::Ascii("thening"),
        dictgen::InsensitiveStr::Ascii("thers"),
        dictgen::InsensitiveStr::Ascii("thhouse"),
        dictgen::InsensitiveStr::Ascii("thing"),
        dictgen::InsensitiveStr::Ascii("thly"),
        dictgen::InsensitiveStr::Ascii("thning"),
        dictgen::InsensitiveStr::Ascii("throom"),
        dictgen::InsensitiveStr::Ascii("ths"),
        dictgen::InsensitiveStr::Ascii("thweight"),
        dictgen::InsensitiveStr::Ascii("thweights"),
    ],
    values: &[
        &["light", "lie", "lye"],
        &["lighter", "liar", "liger"],
        &["lighters", "liars", "ligers"],
        &["lightening"],
        &["lighting"],
        &["lighting"],
        &["lightly"],
        &["lightning"],
        &["lightbulb"],
        &["lightening"],
        &["lightening"],
        &["lighters"],
        &["lighters"],
        &["lighthearted"],
        &["lighthearted"],
        &["lighthearted"],
        &["lighthearted"],
        &["lightening"],
        &["lighthouse"],
        &["lighthouse"],
        &["lighthouse"],
        &["lighting"],
        &["lightening"],
        &["lightning"],
        &["lightning"],
        &["lightening"],
        &["lighters"],
        &["lightroom"],
        &["lightroom"],
        &["lightweight"],
        &["lightweight"],
        &["lightweight"],
        &["lightweight"],
        &["lightweight"],
        &["lightweight"],
        &["legitimacy"],
        &["legitimacy"],
        &["legitimate"],
        &["legitimately"],
        &["litigation"],
        &["light"],
        &["lightening"],
        &["lighters"],
        &["lighthouse"],
        &["lighting"],
        &["lightly"],
        &["lightning"],
        &["lightroom"],
        &["lights"],
        &["lightweight"],
        &["lightweights"],
    ],
    range: 1..=10,
};

static WORD_LIF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_LIF_CHILDREN),
    value: None,
};

pub static WORD_LIF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ceycle"),
        dictgen::InsensitiveStr::Ascii("ecyle"),
        dictgen::InsensitiveStr::Ascii("epsan"),
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("espawn"),
        dictgen::InsensitiveStr::Ascii("estel"),
        dictgen::InsensitiveStr::Ascii("estiles"),
        dictgen::InsensitiveStr::Ascii("estlye"),
        dictgen::InsensitiveStr::Ascii("estlyes"),
        dictgen::InsensitiveStr::Ascii("estye"),
        dictgen::InsensitiveStr::Ascii("esystem"),
        dictgen::InsensitiveStr::Ascii("esytles"),
        dictgen::InsensitiveStr::Ascii("etimers"),
        dictgen::InsensitiveStr::Ascii("etsyles"),
        dictgen::InsensitiveStr::Ascii("eycle"),
        dictgen::InsensitiveStr::Ascii("time"),
    ],
    values: &[
        &["lifecycle"],
        &["lifecycle"],
        &["lifespan"],
        &["lives"],
        &["lifespan"],
        &["lifesteal"],
        &["lifestyles"],
        &["lifestyle"],
        &["lifestyles"],
        &["lifestyle"],
        &["filesystem"],
        &["lifestyles"],
        &["lifetimes"],
        &["lifestyles"],
        &["lifecycle"],
        &["lifetime"],
    ],
    range: 2..=7,
};

static WORD_LIE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_LIE_CHILDREN),
    value: None,
};

pub static WORD_LIE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("brals"),
        dictgen::InsensitiveStr::Ascii("cester"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("k"),
        dictgen::InsensitiveStr::Ascii("kable"),
        dictgen::InsensitiveStr::Ascii("kd"),
        dictgen::InsensitiveStr::Ascii("nt"),
        dictgen::InsensitiveStr::Ascii("nts"),
        dictgen::InsensitiveStr::Ascii("nups"),
        dictgen::InsensitiveStr::Ascii("sure"),
        dictgen::InsensitiveStr::Ascii("tuenant"),
        dictgen::InsensitiveStr::Ascii("uenant"),
        dictgen::InsensitiveStr::Ascii("utanant"),
        dictgen::InsensitiveStr::Ascii("utanent"),
        dictgen::InsensitiveStr::Ascii("utenat"),
        dictgen::InsensitiveStr::Ascii("utenent"),
        dictgen::InsensitiveStr::Ascii("utennant"),
        dictgen::InsensitiveStr::Ascii("utentant"),
        dictgen::InsensitiveStr::Ascii("v"),
        dictgen::InsensitiveStr::Ascii("ved"),
    ],
    values: &[
        &["liberals"],
        &["leicester"],
        &["lying"],
        &["like"],
        &["likable"],
        &["liked"],
        &["client", "clients"],
        &["clients"],
        &["lineups"],
        &["leisure"],
        &["lieutenant"],
        &["lieutenant"],
        &["lieutenant"],
        &["lieutenant"],
        &["lieutenant"],
        &["lieutenant"],
        &["lieutenant"],
        &["lieutenant"],
        &["live"],
        &["lived"],
    ],
    range: 1..=8,
};

static WORD_LIC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_LIC_CHILDREN),
    value: None,
};

pub static WORD_LIC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ate"),
        dictgen::InsensitiveStr::Ascii("ated"),
        dictgen::InsensitiveStr::Ascii("ation"),
        dictgen::InsensitiveStr::Ascii("ations"),
        dictgen::InsensitiveStr::Ascii("emse"),
        dictgen::InsensitiveStr::Ascii("emses"),
        dictgen::InsensitiveStr::Ascii("enceing"),
        dictgen::InsensitiveStr::Ascii("encie"),
        dictgen::InsensitiveStr::Ascii("encse"),
        dictgen::InsensitiveStr::Ascii("ens"),
        dictgen::InsensitiveStr::Ascii("ese"),
        dictgen::InsensitiveStr::Ascii("esne"),
        dictgen::InsensitiveStr::Ascii("esnes"),
        dictgen::InsensitiveStr::Ascii("esning"),
        dictgen::InsensitiveStr::Ascii("esnse"),
        dictgen::InsensitiveStr::Ascii("esnses"),
        dictgen::InsensitiveStr::Ascii("esnsing"),
        dictgen::InsensitiveStr::Ascii("ker"),
        dictgen::InsensitiveStr::Ascii("sense"),
        dictgen::InsensitiveStr::Ascii("senses"),
        dictgen::InsensitiveStr::Ascii("sensing"),
    ],
    values: &[
        &["locate"],
        &["located"],
        &["location"],
        &["locations"],
        &["license"],
        &["licenses"],
        &["licencing"],
        &["licence"],
        &["licence", "license", "licenses"],
        &["license"],
        &["license"],
        &["license"],
        &["licenses"],
        &["licensing"],
        &["license"],
        &["licenses"],
        &["licensing"],
        &["liquor"],
        &["license"],
        &["licenses"],
        &["licensing"],
    ],
    range: 3..=7,
};

static WORD_LIB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_LIB_CHILDREN),
    value: None,
};

static WORD_LIB_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_LIBA_NODE),
    None,
    None,
    None,
    Some(&WORD_LIBE_NODE),
    None,
    Some(&WORD_LIBG_NODE),
    None,
    Some(&WORD_LIBI_NODE),
    None,
    None,
    Some(&WORD_LIBL_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_LIBR_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_LIBR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_LIBR_CHILDREN),
    value: None,
};

pub static WORD_LIBR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aarie"),
        dictgen::InsensitiveStr::Ascii("aaries"),
        dictgen::InsensitiveStr::Ascii("aary"),
        dictgen::InsensitiveStr::Ascii("abarie"),
        dictgen::InsensitiveStr::Ascii("abaries"),
        dictgen::InsensitiveStr::Ascii("abary"),
        dictgen::InsensitiveStr::Ascii("abie"),
        dictgen::InsensitiveStr::Ascii("abies"),
        dictgen::InsensitiveStr::Ascii("abrie"),
        dictgen::InsensitiveStr::Ascii("abries"),
        dictgen::InsensitiveStr::Ascii("abry"),
        dictgen::InsensitiveStr::Ascii("aby"),
        dictgen::InsensitiveStr::Ascii("aie"),
        dictgen::InsensitiveStr::Ascii("aier"),
        dictgen::InsensitiveStr::Ascii("aies"),
        dictgen::InsensitiveStr::Ascii("aiesr"),
        dictgen::InsensitiveStr::Ascii("aire"),
        dictgen::InsensitiveStr::Ascii("aires"),
        dictgen::InsensitiveStr::Ascii("airies"),
        dictgen::InsensitiveStr::Ascii("airy"),
        dictgen::InsensitiveStr::Ascii("alie"),
        dictgen::InsensitiveStr::Ascii("alies"),
        dictgen::InsensitiveStr::Ascii("aly"),
        dictgen::InsensitiveStr::Ascii("aray"),
        dictgen::InsensitiveStr::Ascii("arie"),
        dictgen::InsensitiveStr::Ascii("aris"),
        dictgen::InsensitiveStr::Ascii("arries"),
        dictgen::InsensitiveStr::Ascii("arry"),
        dictgen::InsensitiveStr::Ascii("arse"),
        dictgen::InsensitiveStr::Ascii("aryes"),
        dictgen::InsensitiveStr::Ascii("atie"),
        dictgen::InsensitiveStr::Ascii("aties"),
        dictgen::InsensitiveStr::Ascii("aty"),
        dictgen::InsensitiveStr::Ascii("ay"),
        dictgen::InsensitiveStr::Ascii("ayr"),
        dictgen::InsensitiveStr::Ascii("eoffie"),
        dictgen::InsensitiveStr::Ascii("eoficekit"),
        dictgen::InsensitiveStr::Ascii("eries"),
        dictgen::InsensitiveStr::Ascii("ery"),
        dictgen::InsensitiveStr::Ascii("etarian"),
        dictgen::InsensitiveStr::Ascii("etarianism"),
        dictgen::InsensitiveStr::Ascii("etarians"),
        dictgen::InsensitiveStr::Ascii("ies"),
        dictgen::InsensitiveStr::Ascii("raies"),
        dictgen::InsensitiveStr::Ascii("raries"),
        dictgen::InsensitiveStr::Ascii("rary"),
        dictgen::InsensitiveStr::Ascii("ray"),
    ],
    values: &[
        &["library"],
        &["libraries"],
        &["library"],
        &["library"],
        &["libraries"],
        &["library"],
        &["library"],
        &["libraries"],
        &["library"],
        &["libraries"],
        &["library"],
        &["library"],
        &["library"],
        &["library"],
        &["libraries"],
        &["libraries"],
        &["library"],
        &["libraries"],
        &["libraries"],
        &["library"],
        &["library"],
        &["libraries"],
        &["library"],
        &["library"],
        &["libraries", "library"],
        &["libraries"],
        &["libraries"],
        &["library"],
        &["libraries"],
        &["libraries"],
        &["library"],
        &["libraries"],
        &["library"],
        &["library"],
        &["library"],
        &["libreoffice"],
        &["libreofficekit"],
        &["libraries"],
        &["library"],
        &["libertarian"],
        &["libertarianism"],
        &["libertarians"],
        &["libraries"],
        &["libraries"],
        &["libraries"],
        &["library"],
        &["library"],
    ],
    range: 2..=10,
};

static WORD_LIBL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_LIBL_CHILDREN),
    value: None,
};

pub static WORD_LIBL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("e")],
    values: &[&["libel", "liable"]],
    range: 1..=1,
};

static WORD_LIBI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_LIBI_CHILDREN),
    value: None,
};

pub static WORD_LIBI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("tarianisn")],
    values: &[&["libertarianism"]],
    range: 9..=9,
};

static WORD_LIBG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_LIBG_CHILDREN),
    value: None,
};

pub static WORD_LIBG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ng"),
        dictgen::InsensitiveStr::Ascii("uistic"),
        dictgen::InsensitiveStr::Ascii("uistics"),
    ],
    values: &[&["libpng"], &["linguistic"], &["linguistics"]],
    range: 2..=7,
};

static WORD_LIBE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_LIBE_CHILDREN),
    value: None,
};

pub static WORD_LIBE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ll"),
        dictgen::InsensitiveStr::Ascii("racion"),
        dictgen::InsensitiveStr::Ascii("rae"),
        dictgen::InsensitiveStr::Ascii("rales"),
        dictgen::InsensitiveStr::Ascii("ralest"),
        dictgen::InsensitiveStr::Ascii("ralim"),
        dictgen::InsensitiveStr::Ascii("ralis"),
        dictgen::InsensitiveStr::Ascii("ralisim"),
        dictgen::InsensitiveStr::Ascii("ralizm"),
        dictgen::InsensitiveStr::Ascii("ralnim"),
        dictgen::InsensitiveStr::Ascii("ralsim"),
        dictgen::InsensitiveStr::Ascii("raries"),
        dictgen::InsensitiveStr::Ascii("rarion"),
        dictgen::InsensitiveStr::Ascii("rary"),
        dictgen::InsensitiveStr::Ascii("ras"),
        dictgen::InsensitiveStr::Ascii("raties"),
        dictgen::InsensitiveStr::Ascii("ratin"),
        dictgen::InsensitiveStr::Ascii("rato"),
        dictgen::InsensitiveStr::Ascii("ratore"),
        dictgen::InsensitiveStr::Ascii("ratrian"),
        dictgen::InsensitiveStr::Ascii("ratrianism"),
        dictgen::InsensitiveStr::Ascii("ratrians"),
        dictgen::InsensitiveStr::Ascii("roffice"),
        dictgen::InsensitiveStr::Ascii("rry"),
        dictgen::InsensitiveStr::Ascii("rtae"),
        dictgen::InsensitiveStr::Ascii("rtairan"),
        dictgen::InsensitiveStr::Ascii("rtania"),
        dictgen::InsensitiveStr::Ascii("rtarain"),
        dictgen::InsensitiveStr::Ascii("rtarainism"),
        dictgen::InsensitiveStr::Ascii("rtarains"),
        dictgen::InsensitiveStr::Ascii("rtariaism"),
        dictgen::InsensitiveStr::Ascii("rtarianisim"),
        dictgen::InsensitiveStr::Ascii("rtarianisme"),
        dictgen::InsensitiveStr::Ascii("rtarianismo"),
        dictgen::InsensitiveStr::Ascii("rtarianists"),
        dictgen::InsensitiveStr::Ascii("rtariansim"),
        dictgen::InsensitiveStr::Ascii("rtariansism"),
        dictgen::InsensitiveStr::Ascii("rtariansm"),
        dictgen::InsensitiveStr::Ascii("rtarias"),
        dictgen::InsensitiveStr::Ascii("rtarien"),
        dictgen::InsensitiveStr::Ascii("rtariens"),
        dictgen::InsensitiveStr::Ascii("rtarinaism"),
        dictgen::InsensitiveStr::Ascii("rtaryan"),
        dictgen::InsensitiveStr::Ascii("rtaryanism"),
        dictgen::InsensitiveStr::Ascii("rtaryans"),
        dictgen::InsensitiveStr::Ascii("rtatian"),
        dictgen::InsensitiveStr::Ascii("rtatianism"),
        dictgen::InsensitiveStr::Ascii("rtatians"),
        dictgen::InsensitiveStr::Ascii("rtea"),
        dictgen::InsensitiveStr::Ascii("rterian"),
        dictgen::InsensitiveStr::Ascii("rterianism"),
        dictgen::InsensitiveStr::Ascii("rterians"),
    ],
    values: &[
        &["libel"],
        &["liberation"],
        &["liberate"],
        &["liberals"],
        &["liberate"],
        &["liberalism"],
        &["liberals"],
        &["liberalism"],
        &["liberalism"],
        &["liberalism"],
        &["liberalism"],
        &["libraries"],
        &["liberation"],
        &["library"],
        &["liberals"],
        &["liberate"],
        &["liberation"],
        &["liberation"],
        &["liberate"],
        &["libertarians"],
        &["libertarianism"],
        &["libertarians"],
        &["libreoffice"],
        &["library"],
        &["liberate"],
        &["libertarians"],
        &["libertarians"],
        &["libertarian"],
        &["libertarianism"],
        &["libertarians"],
        &["libertarianism"],
        &["libertarianism"],
        &["libertarians"],
        &["libertarians"],
        &["libertarians"],
        &["libertarianism"],
        &["libertarianism"],
        &["libertarianism"],
        &["libertarians"],
        &["libertarian"],
        &["libertarians"],
        &["libertarianism"],
        &["libertarian"],
        &["libertarianism"],
        &["libertarians"],
        &["libertarian"],
        &["libertarianism"],
        &["libertarians"],
        &["liberate"],
        &["libertarian"],
        &["libertarianism"],
        &["libertarians"],
    ],
    range: 2..=11,
};

static WORD_LIBA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_LIBA_CHILDREN),
    value: None,
};

pub static WORD_LIBA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("rary"),
        dictgen::InsensitiveStr::Ascii("ries"),
        dictgen::InsensitiveStr::Ascii("ry"),
    ],
    values: &[&["library"], &["libraries"], &["library"]],
    range: 2..=4,
};

static WORD_LIA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_LIA_CHILDREN),
    value: None,
};

pub static WORD_LIA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("res"),
        dictgen::InsensitiveStr::Ascii("sion"),
        dictgen::InsensitiveStr::Ascii("son"),
        dictgen::InsensitiveStr::Ascii("sons"),
    ],
    values: &[&["liars"], &["liaison"], &["liaison"], &["liaisons"]],
    range: 3..=4,
};

static WORD_LF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_LF_CHILDREN),
    value: None,
};

pub static WORD_LF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("iesteal")],
    values: &[&["lifesteal"]],
    range: 7..=7,
};

static WORD_LE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_LE_CHILDREN),
    value: None,
};

static WORD_LE_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_LEA_NODE),
    Some(&WORD_LEB_NODE),
    Some(&WORD_LEC_NODE),
    None,
    Some(&WORD_LEE_NODE),
    Some(&WORD_LEF_NODE),
    Some(&WORD_LEG_NODE),
    None,
    Some(&WORD_LEI_NODE),
    None,
    None,
    None,
    Some(&WORD_LEM_NODE),
    Some(&WORD_LEN_NODE),
    None,
    Some(&WORD_LEP_NODE),
    None,
    Some(&WORD_LER_NODE),
    Some(&WORD_LES_NODE),
    Some(&WORD_LET_NODE),
    Some(&WORD_LEU_NODE),
    Some(&WORD_LEV_NODE),
    Some(&WORD_LEW_NODE),
    Some(&WORD_LEX_NODE),
    Some(&WORD_LEY_NODE),
    None,
];

static WORD_LEY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_LEY_CHILDREN),
    value: None,
};

pub static WORD_LEY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("er"),
        dictgen::InsensitiveStr::Ascii("ered"),
        dictgen::InsensitiveStr::Ascii("ering"),
        dictgen::InsensitiveStr::Ascii("ers"),
    ],
    values: &[&["layer"], &["layered"], &["layering"], &["layers"]],
    range: 2..=5,
};

static WORD_LEX_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_LEX_CHILDREN),
    value: None,
};

pub static WORD_LEX_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ial"),
        dictgen::InsensitiveStr::Ascii("igraphic"),
        dictgen::InsensitiveStr::Ascii("igraphical"),
        dictgen::InsensitiveStr::Ascii("igraphically"),
    ],
    values: &[
        &["lexical"],
        &["lexicographic"],
        &["lexicographical"],
        &["lexicographically"],
    ],
    range: 3..=12,
};

static WORD_LEW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_LEW_CHILDREN),
    value: Some(&["dew", "hew", "lieu", "sew"]),
};

pub static WORD_LEW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("chemia"),
        dictgen::InsensitiveStr::Ascii("ow"),
        dictgen::InsensitiveStr::Ascii("ows"),
        dictgen::InsensitiveStr::Ascii("tenant"),
        dictgen::InsensitiveStr::Ascii("tenants"),
    ],
    values: &[
        &["leukaemia", "leukemia"],
        &["luau"],
        &["luaus"],
        &["lieutenant"],
        &["lieutenants"],
    ],
    range: 2..=7,
};

static WORD_LEV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_LEV_CHILDREN),
    value: None,
};

pub static WORD_LEV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ae"),
        dictgen::InsensitiveStr::Ascii("aithan"),
        dictgen::InsensitiveStr::Ascii("ander"),
        dictgen::InsensitiveStr::Ascii("aridge"),
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("elign"),
        dictgen::InsensitiveStr::Ascii("ellign"),
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("etate"),
        dictgen::InsensitiveStr::Ascii("etated"),
        dictgen::InsensitiveStr::Ascii("etates"),
        dictgen::InsensitiveStr::Ascii("etating"),
        dictgen::InsensitiveStr::Ascii("iathn"),
        dictgen::InsensitiveStr::Ascii("icitus"),
        dictgen::InsensitiveStr::Ascii("l"),
        dictgen::InsensitiveStr::Ascii("le"),
        dictgen::InsensitiveStr::Ascii("leing"),
        dictgen::InsensitiveStr::Ascii("leling"),
    ],
    values: &[
        &["leave", "levee"],
        &["leviathan"],
        &["lavender"],
        &["leverage"],
        &["levee", "level"],
        &["leveling"],
        &["levelling"],
        &["levees", "levels"],
        &["levitate"],
        &["levitated"],
        &["levitates"],
        &["levitating"],
        &["leviathan"],
        &["leviticus"],
        &["level"],
        &["level"],
        &["leveling"],
        &["leveling"],
    ],
    range: 1..=7,
};

static WORD_LEU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_LEU_CHILDREN),
    value: None,
};

pub static WORD_LEU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("itenant"),
        dictgen::InsensitiveStr::Ascii("tenant"),
    ],
    values: &[&["lieutenant"], &["lieutenant"]],
    range: 6..=7,
};

static WORD_LET_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_LET_CHILDREN),
    value: None,
};

pub static WORD_LET_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("gitimate"),
        dictgen::InsensitiveStr::Ascii("ivicus"),
        dictgen::InsensitiveStr::Ascii("most"),
    ],
    values: &[&["legitimate"], &["leviticus"], &["leftmost"]],
    range: 4..=8,
};

static WORD_LES_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_LES_CHILDREN),
    value: None,
};

pub static WORD_LES_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("bain"),
        dictgen::InsensitiveStr::Ascii("bains"),
        dictgen::InsensitiveStr::Ascii("bianas"),
        dictgen::InsensitiveStr::Ascii("bianese"),
        dictgen::InsensitiveStr::Ascii("bianest"),
        dictgen::InsensitiveStr::Ascii("bianus"),
        dictgen::InsensitiveStr::Ascii("iban"),
        dictgen::InsensitiveStr::Ascii("ibans"),
        dictgen::InsensitiveStr::Ascii("iure"),
        dictgen::InsensitiveStr::Ascii("sson"),
        dictgen::InsensitiveStr::Ascii("ssons"),
        dictgen::InsensitiveStr::Ascii("stiff"),
    ],
    values: &[
        &["lesbian"],
        &["lesbians"],
        &["lesbians"],
        &["lesbians"],
        &["lesbians"],
        &["lesbians"],
        &["lesbian"],
        &["lesbians"],
        &["leisure"],
        &["lesson"],
        &["lessons"],
        &["lesstif"],
    ],
    range: 4..=7,
};

static WORD_LER_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_LER_CHILDREN),
    value: None,
};

pub static WORD_LER_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("an"),
        dictgen::InsensitiveStr::Ascii("aned"),
        dictgen::InsensitiveStr::Ascii("ans"),
        dictgen::InsensitiveStr::Ascii("n"),
        dictgen::InsensitiveStr::Ascii("ned"),
        dictgen::InsensitiveStr::Ascii("ning"),
    ],
    values: &[
        &["learn"],
        &["learned"],
        &["learns"],
        &["learn", "lean"],
        &["learned", "leaned"],
        &["learning", "leaning"],
    ],
    range: 1..=4,
};

static WORD_LEP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_LEP_CHILDREN),
    value: None,
};

pub static WORD_LEP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ard"),
        dictgen::InsensitiveStr::Ascii("ards"),
        dictgen::InsensitiveStr::Ascii("oard"),
        dictgen::InsensitiveStr::Ascii("racan"),
        dictgen::InsensitiveStr::Ascii("racans"),
        dictgen::InsensitiveStr::Ascii("rachan"),
        dictgen::InsensitiveStr::Ascii("rachans"),
        dictgen::InsensitiveStr::Ascii("racy"),
    ],
    values: &[
        &["leopard"],
        &["leopards"],
        &["leopard"],
        &["leprechaun"],
        &["leprechauns"],
        &["leprechaun"],
        &["leprechauns"],
        &["leprosy"],
    ],
    range: 3..=7,
};

static WORD_LEN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_LEN_CHILDREN),
    value: None,
};

pub static WORD_LEN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("gedaries"),
        dictgen::InsensitiveStr::Ascii("ggth"),
        dictgen::InsensitiveStr::Ascii("gh"),
        dictgen::InsensitiveStr::Ascii("ghs"),
        dictgen::InsensitiveStr::Ascii("ght"),
        dictgen::InsensitiveStr::Ascii("ghten"),
        dictgen::InsensitiveStr::Ascii("ghtend"),
        dictgen::InsensitiveStr::Ascii("ghtened"),
        dictgen::InsensitiveStr::Ascii("ghtening"),
        dictgen::InsensitiveStr::Ascii("ghth"),
        dictgen::InsensitiveStr::Ascii("ghthen"),
        dictgen::InsensitiveStr::Ascii("ghths"),
        dictgen::InsensitiveStr::Ascii("ghthy"),
        dictgen::InsensitiveStr::Ascii("ghtly"),
        dictgen::InsensitiveStr::Ascii("ghts"),
        dictgen::InsensitiveStr::Ascii("ghty"),
        dictgen::InsensitiveStr::Ascii("gt"),
        dictgen::InsensitiveStr::Ascii("gten"),
        dictgen::InsensitiveStr::Ascii("gtext"),
        dictgen::InsensitiveStr::Ascii("gthes"),
        dictgen::InsensitiveStr::Ascii("gthh"),
        dictgen::InsensitiveStr::Ascii("gthly"),
        dictgen::InsensitiveStr::Ascii("gts"),
        dictgen::InsensitiveStr::Ascii("guage"),
        dictgen::InsensitiveStr::Ascii("guages"),
        dictgen::InsensitiveStr::Ascii("iant"),
        dictgen::InsensitiveStr::Ascii("inent"),
        dictgen::InsensitiveStr::Ascii("ngth"),
        dictgen::InsensitiveStr::Ascii("oard"),
        dictgen::InsensitiveStr::Ascii("tgh"),
        dictgen::InsensitiveStr::Ascii("tghs"),
        dictgen::InsensitiveStr::Ascii("th"),
        dictgen::InsensitiveStr::Ascii("ths"),
        dictgen::InsensitiveStr::Ascii("tiles"),
        dictgen::InsensitiveStr::Ascii("tills"),
    ],
    values: &[
        &["lens"],
        &["legendaries"],
        &["length"],
        &["length"],
        &["lengths"],
        &["length"],
        &["lengthen"],
        &["lengthened"],
        &["lengthened"],
        &["lengthening"],
        &["length"],
        &["lengthen"],
        &["lengths"],
        &["lengthy"],
        &["lengthy"],
        &["lengths"],
        &["lengthy"],
        &["length"],
        &["lengthen"],
        &["longtext"],
        &["lengths"],
        &["length"],
        &["lengthy"],
        &["lengths"],
        &["language"],
        &["languages"],
        &["lenient"],
        &["lenient"],
        &["length"],
        &["leonard"],
        &["length"],
        &["lengths"],
        &["length"],
        &["lengths"],
        &["lentils"],
        &["lentils"],
    ],
    range: 1..=8,
};

static WORD_LEM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_LEM_CHILDREN),
    value: None,
};

pub static WORD_LEM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("osine"),
        dictgen::InsensitiveStr::Ascii("osines"),
    ],
    values: &[&["limousine"], &["limousines"]],
    range: 5..=6,
};

static WORD_LEI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_LEI_CHILDREN),
    value: None,
};

pub static WORD_LEI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("bnitz"),
        dictgen::InsensitiveStr::Ascii("ghtweight"),
        dictgen::InsensitiveStr::Ascii("gons"),
        dictgen::InsensitiveStr::Ascii("utenant"),
    ],
    values: &[
        &["leibniz"],
        &["lightweight"],
        &["legions"],
        &["lieutenant"],
    ],
    range: 4..=9,
};

static WORD_LEG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_LEG_CHILDREN),
    value: None,
};

static WORD_LEG_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_LEGA_NODE),
    None,
    None,
    None,
    Some(&WORD_LEGE_NODE),
    None,
    Some(&WORD_LEGG_NODE),
    Some(&WORD_LEGH_NODE),
    Some(&WORD_LEGI_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_LEGN_NODE),
    Some(&WORD_LEGO_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_LEGT_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_LEGT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_LEGT_CHILDREN),
    value: None,
};

pub static WORD_LEGT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("h"),
        dictgen::InsensitiveStr::Ascii("hs"),
    ],
    values: &[&["length"], &["lengths"]],
    range: 1..=2,
};

static WORD_LEGO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_LEGO_CHILDREN),
    value: None,
};

pub static WORD_LEGO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ins")],
    values: &[&["legions"]],
    range: 3..=3,
};

static WORD_LEGN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_LEGN_CHILDREN),
    value: None,
};

pub static WORD_LEGN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("edaries"),
        dictgen::InsensitiveStr::Ascii("edary"),
        dictgen::InsensitiveStr::Ascii("th"),
        dictgen::InsensitiveStr::Ascii("ths"),
        dictgen::InsensitiveStr::Ascii("thy"),
    ],
    values: &[
        &["legendaries"],
        &["legendary"],
        &["length"],
        &["lengths"],
        &["lengthy"],
    ],
    range: 2..=7,
};

static WORD_LEGI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_LEGI_CHILDREN),
    value: None,
};

pub static WORD_LEGI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("lsation"),
        dictgen::InsensitiveStr::Ascii("mitacy"),
        dictgen::InsensitiveStr::Ascii("mitate"),
        dictgen::InsensitiveStr::Ascii("mitately"),
        dictgen::InsensitiveStr::Ascii("onair"),
        dictgen::InsensitiveStr::Ascii("onaires"),
        dictgen::InsensitiveStr::Ascii("onairs"),
        dictgen::InsensitiveStr::Ascii("onis"),
        dictgen::InsensitiveStr::Ascii("slacion"),
        dictgen::InsensitiveStr::Ascii("slatie"),
        dictgen::InsensitiveStr::Ascii("slatiors"),
        dictgen::InsensitiveStr::Ascii("slativo"),
        dictgen::InsensitiveStr::Ascii("station"),
        dictgen::InsensitiveStr::Ascii("stative"),
        dictgen::InsensitiveStr::Ascii("stators"),
        dictgen::InsensitiveStr::Ascii("stration"),
        dictgen::InsensitiveStr::Ascii("tamacy"),
        dictgen::InsensitiveStr::Ascii("tamate"),
        dictgen::InsensitiveStr::Ascii("tamately"),
        dictgen::InsensitiveStr::Ascii("tamicy"),
        dictgen::InsensitiveStr::Ascii("tamite"),
        dictgen::InsensitiveStr::Ascii("tamitely"),
        dictgen::InsensitiveStr::Ascii("temacy"),
        dictgen::InsensitiveStr::Ascii("temate"),
        dictgen::InsensitiveStr::Ascii("temately"),
        dictgen::InsensitiveStr::Ascii("tematly"),
        dictgen::InsensitiveStr::Ascii("timaly"),
        dictgen::InsensitiveStr::Ascii("timancy"),
        dictgen::InsensitiveStr::Ascii("timatcy"),
        dictgen::InsensitiveStr::Ascii("timatelly"),
        dictgen::InsensitiveStr::Ascii("timatley"),
        dictgen::InsensitiveStr::Ascii("timatly"),
        dictgen::InsensitiveStr::Ascii("timetly"),
        dictgen::InsensitiveStr::Ascii("timiately"),
        dictgen::InsensitiveStr::Ascii("timicy"),
        dictgen::InsensitiveStr::Ascii("timite"),
        dictgen::InsensitiveStr::Ascii("timitely"),
        dictgen::InsensitiveStr::Ascii("timt"),
        dictgen::InsensitiveStr::Ascii("tmate"),
    ],
    values: &[
        &["legislation"],
        &["legitimacy"],
        &["legitimate"],
        &["legitimately"],
        &["legionnaire"],
        &["legionnaires"],
        &["legionnaires"],
        &["legions"],
        &["legislation"],
        &["legislative"],
        &["legislators"],
        &["legislation"],
        &["legislation"],
        &["legislative"],
        &["legislators"],
        &["registration"],
        &["legitimacy"],
        &["legitimate"],
        &["legitimately"],
        &["legitimacy"],
        &["legitimate"],
        &["legitimately"],
        &["legitimacy"],
        &["legitimate"],
        &["legitimately"],
        &["legitimately"],
        &["legitimacy"],
        &["legitimacy"],
        &["legitimacy"],
        &["legitimately"],
        &["legitimately"],
        &["legitimately"],
        &["legitimately"],
        &["legitimately"],
        &["legitimacy"],
        &["legitimate"],
        &["legitimately"],
        &["legitimate"],
        &["legitimate"],
    ],
    range: 4..=9,
};

static WORD_LEGH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_LEGH_CHILDREN),
    value: None,
};

pub static WORD_LEGH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("ts"),
    ],
    values: &[&["length"], &["lengths"]],
    range: 1..=2,
};

static WORD_LEGG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_LEGG_CHILDREN),
    value: None,
};

pub static WORD_LEGG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("acies"),
        dictgen::InsensitiveStr::Ascii("acy"),
    ],
    values: &[&["legacies"], &["legacy"]],
    range: 3..=5,
};

static WORD_LEGE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_LEGE_CHILDREN),
    value: None,
};

pub static WORD_LEGE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("l"),
        dictgen::InsensitiveStr::Ascii("nadries"),
        dictgen::InsensitiveStr::Ascii("ndaies"),
        dictgen::InsensitiveStr::Ascii("ndaires"),
        dictgen::InsensitiveStr::Ascii("ndarios"),
        dictgen::InsensitiveStr::Ascii("ndaris"),
        dictgen::InsensitiveStr::Ascii("ndarisk"),
        dictgen::InsensitiveStr::Ascii("ndariske"),
        dictgen::InsensitiveStr::Ascii("ndaryes"),
        dictgen::InsensitiveStr::Ascii("nday"),
        dictgen::InsensitiveStr::Ascii("nderies"),
    ],
    values: &[
        &["legal"],
        &["legendaries"],
        &["legendaries"],
        &["legendaries"],
        &["legendaries"],
        &["legendaries"],
        &["legendaries"],
        &["legendaries"],
        &["legendaries"],
        &["legendary"],
        &["legendaries"],
    ],
    range: 1..=8,
};

static WORD_LEGA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_LEGA_CHILDREN),
    value: None,
};

pub static WORD_LEGA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("c"),
        dictgen::InsensitiveStr::Ascii("ct"),
        dictgen::InsensitiveStr::Ascii("lazing"),
        dictgen::InsensitiveStr::Ascii("limate"),
        dictgen::InsensitiveStr::Ascii("lizacion"),
        dictgen::InsensitiveStr::Ascii("lizaing"),
        dictgen::InsensitiveStr::Ascii("lizaiton"),
        dictgen::InsensitiveStr::Ascii("lizare"),
        dictgen::InsensitiveStr::Ascii("lizate"),
        dictgen::InsensitiveStr::Ascii("lizaton"),
        dictgen::InsensitiveStr::Ascii("lizeing"),
        dictgen::InsensitiveStr::Ascii("sy"),
    ],
    values: &[
        &["legacy"],
        &["legacy"],
        &["legalizing"],
        &["legitimate"],
        &["legalization"],
        &["legalizing"],
        &["legalization"],
        &["legalize"],
        &["legalize"],
        &["legalization"],
        &["legalizing"],
        &["legacy"],
    ],
    range: 1..=8,
};

static WORD_LEF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_LEF_CHILDREN),
    value: None,
};

pub static WORD_LEF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("itst"),
        dictgen::InsensitiveStr::Ascii("itsts"),
        dictgen::InsensitiveStr::Ascii("ted"),
        dictgen::InsensitiveStr::Ascii("tits"),
        dictgen::InsensitiveStr::Ascii("tsits"),
    ],
    values: &[
        &["leftist"],
        &["leftists"],
        &["left"],
        &["leftist"],
        &["leftists"],
    ],
    range: 3..=5,
};

static WORD_LEE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_LEE_CHILDREN),
    value: None,
};

pub static WORD_LEE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("g"),
        dictgen::InsensitiveStr::Ascii("gs"),
        dictgen::InsensitiveStr::Ascii("gun"),
        dictgen::InsensitiveStr::Ascii("guns"),
        dictgen::InsensitiveStr::Ascii("sure"),
        dictgen::InsensitiveStr::Ascii("surely"),
        dictgen::InsensitiveStr::Ascii("sures"),
    ],
    values: &[
        &["league"],
        &["leagues"],
        &["legion"],
        &["legions"],
        &["leisure"],
        &["leisurely"],
        &["leisures"],
    ],
    range: 1..=6,
};

static WORD_LEC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_LEC_CHILDREN),
    value: None,
};

pub static WORD_LEC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eister"),
        dictgen::InsensitiveStr::Ascii("iester"),
        dictgen::InsensitiveStr::Ascii("teurs"),
        dictgen::InsensitiveStr::Ascii("tureres"),
        dictgen::InsensitiveStr::Ascii("utres"),
    ],
    values: &[
        &["leicester"],
        &["leicester"],
        &["lectures"],
        &["lectures"],
        &["lectures"],
    ],
    range: 5..=7,
};

static WORD_LEB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_LEB_CHILDREN),
    value: None,
};

pub static WORD_LEB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("anesse")],
    values: &[&["lebanese"]],
    range: 6..=6,
};

static WORD_LEA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_LEA_CHILDREN),
    value: None,
};

pub static WORD_LEA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ast"),
        dictgen::InsensitiveStr::Ascii("ce"),
        dictgen::InsensitiveStr::Ascii("ck"),
        dictgen::InsensitiveStr::Ascii("gacy"),
        dictgen::InsensitiveStr::Ascii("gal"),
        dictgen::InsensitiveStr::Ascii("galise"),
        dictgen::InsensitiveStr::Ascii("gality"),
        dictgen::InsensitiveStr::Ascii("galize"),
        dictgen::InsensitiveStr::Ascii("gcy"),
        dictgen::InsensitiveStr::Ascii("ge"),
        dictgen::InsensitiveStr::Ascii("gel"),
        dictgen::InsensitiveStr::Ascii("gelise"),
        dictgen::InsensitiveStr::Ascii("gelity"),
        dictgen::InsensitiveStr::Ascii("gelize"),
        dictgen::InsensitiveStr::Ascii("geue"),
        dictgen::InsensitiveStr::Ascii("gl"),
        dictgen::InsensitiveStr::Ascii("glise"),
        dictgen::InsensitiveStr::Ascii("glity"),
        dictgen::InsensitiveStr::Ascii("glization"),
        dictgen::InsensitiveStr::Ascii("glize"),
        dictgen::InsensitiveStr::Ascii("glizing"),
        dictgen::InsensitiveStr::Ascii("neant"),
        dictgen::InsensitiveStr::Ascii("neantly"),
        dictgen::InsensitiveStr::Ascii("nr"),
        dictgen::InsensitiveStr::Ascii("ring"),
        dictgen::InsensitiveStr::Ascii("ry"),
        dictgen::InsensitiveStr::Ascii("set"),
        dictgen::InsensitiveStr::Ascii("sure"),
        dictgen::InsensitiveStr::Ascii("surely"),
        dictgen::InsensitiveStr::Ascii("sures"),
        dictgen::InsensitiveStr::Ascii("sy"),
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("thal"),
        dictgen::InsensitiveStr::Ascii("ts"),
        dictgen::InsensitiveStr::Ascii("veing"),
        dictgen::InsensitiveStr::Ascii("vong"),
    ],
    values: &[
        &["least"],
        &["leave"],
        &["leak"],
        &["legacy"],
        &["legal"],
        &["legalise"],
        &["legality"],
        &["legalize"],
        &["legacy"],
        &["league"],
        &["legal"],
        &["legalise"],
        &["legality"],
        &["legalize"],
        &["league"],
        &["legal"],
        &["legalise"],
        &["legality"],
        &["legalization"],
        &["legalize"],
        &["legalizing"],
        &["lenient"],
        &["leniently"],
        &["lean", "learn", "leaner"],
        &["learning"],
        &["leery"],
        &["least"],
        &["leisure"],
        &["leisurely"],
        &["leisures"],
        &["least"],
        &["lead", "leak", "least", "leaf"],
        &["lethal"],
        &["least"],
        &["leaving"],
        &["leaving"],
    ],
    range: 1..=9,
};

static WORD_LC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_LC_CHILDREN),
    value: None,
};

pub static WORD_LC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("oal"),
        dictgen::InsensitiveStr::Ascii("oally"),
        dictgen::InsensitiveStr::Ascii("oation"),
        dictgen::InsensitiveStr::Ascii("uase"),
    ],
    values: &[&["local", "coal"], &["locally"], &["location"], &["clause"]],
    range: 3..=6,
};

static WORD_LA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_LA_CHILDREN),
    value: None,
};

static WORD_LA_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    Some(&WORD_LAB_NODE),
    Some(&WORD_LAC_NODE),
    None,
    Some(&WORD_LAE_NODE),
    Some(&WORD_LAF_NODE),
    Some(&WORD_LAG_NODE),
    None,
    Some(&WORD_LAI_NODE),
    None,
    None,
    None,
    Some(&WORD_LAM_NODE),
    Some(&WORD_LAN_NODE),
    Some(&WORD_LAO_NODE),
    None,
    None,
    Some(&WORD_LAR_NODE),
    Some(&WORD_LAS_NODE),
    Some(&WORD_LAT_NODE),
    Some(&WORD_LAU_NODE),
    Some(&WORD_LAV_NODE),
    Some(&WORD_LAW_NODE),
    None,
    Some(&WORD_LAY_NODE),
    Some(&WORD_LAZ_NODE),
];

static WORD_LAZ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_LAZ_CHILDREN),
    value: None,
};

pub static WORD_LAZ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("er"),
        dictgen::InsensitiveStr::Ascii("iliy"),
        dictgen::InsensitiveStr::Ascii("yness"),
    ],
    values: &[&["laser"], &["lazily"], &["laziness"]],
    range: 2..=5,
};

static WORD_LAY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_LAY_CHILDREN),
    value: None,
};

pub static WORD_LAY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("brinth"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("ou"),
        dictgen::InsensitiveStr::Ascii("our"),
        dictgen::InsensitiveStr::Ascii("ringes"),
        dictgen::InsensitiveStr::Ascii("rinks"),
        dictgen::InsensitiveStr::Ascii("rinx"),
        dictgen::InsensitiveStr::Ascii("rinxes"),
        dictgen::InsensitiveStr::Ascii("ser"),
        dictgen::InsensitiveStr::Ascii("sered"),
        dictgen::InsensitiveStr::Ascii("sering"),
        dictgen::InsensitiveStr::Ascii("sers"),
    ],
    values: &[
        &["labyrinth"],
        &["laid"],
        &["layout"],
        &["layout"],
        &["larynges"],
        &["larynx"],
        &["larynx"],
        &["larynxes"],
        &["laser", "layer"],
        &["lasered", "layered"],
        &["lasering", "layering"],
        &["lasers", "layers"],
    ],
    range: 2..=6,
};

static WORD_LAW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_LAW_CHILDREN),
    value: None,
};

pub static WORD_LAW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ernce")],
    values: &[&["lawrence"]],
    range: 5..=5,
};

static WORD_LAV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_LAV_CHILDREN),
    value: None,
};

pub static WORD_LAV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ae"),
        dictgen::InsensitiveStr::Ascii("el"),
        dictgen::InsensitiveStr::Ascii("eled"),
        dictgen::InsensitiveStr::Ascii("eling"),
        dictgen::InsensitiveStr::Ascii("elled"),
        dictgen::InsensitiveStr::Ascii("elling"),
        dictgen::InsensitiveStr::Ascii("els"),
        dictgen::InsensitiveStr::Ascii("endr"),
    ],
    values: &[
        &["larvae"],
        &["level", "laravel", "label"],
        &["leveled", "labeled"],
        &["leveling", "labeling"],
        &["labelled", "levelled"],
        &["levelling", "labelling"],
        &["levels", "labels"],
        &["lavender"],
    ],
    range: 2..=6,
};

static WORD_LAU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_LAU_CHILDREN),
    value: None,
};

pub static WORD_LAU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ch"),
        dictgen::InsensitiveStr::Ascii("ched"),
        dictgen::InsensitiveStr::Ascii("cher"),
        dictgen::InsensitiveStr::Ascii("ches"),
        dictgen::InsensitiveStr::Ascii("ching"),
        dictgen::InsensitiveStr::Ascii("cnhed"),
        dictgen::InsensitiveStr::Ascii("cnher"),
        dictgen::InsensitiveStr::Ascii("cnhers"),
        dictgen::InsensitiveStr::Ascii("cnhes"),
        dictgen::InsensitiveStr::Ascii("cnhing"),
        dictgen::InsensitiveStr::Ascii("ghablely"),
        dictgen::InsensitiveStr::Ascii("ghabley"),
        dictgen::InsensitiveStr::Ascii("ghablly"),
        dictgen::InsensitiveStr::Ascii("gnage"),
        dictgen::InsensitiveStr::Ascii("gnages"),
        dictgen::InsensitiveStr::Ascii("guage"),
        dictgen::InsensitiveStr::Ascii("nchered"),
        dictgen::InsensitiveStr::Ascii("nchign"),
        dictgen::InsensitiveStr::Ascii("nchs"),
        dictgen::InsensitiveStr::Ascii("nck"),
        dictgen::InsensitiveStr::Ascii("ndrey"),
        dictgen::InsensitiveStr::Ascii("ngage"),
        dictgen::InsensitiveStr::Ascii("ngages"),
        dictgen::InsensitiveStr::Ascii("nguage"),
        dictgen::InsensitiveStr::Ascii("nguages"),
        dictgen::InsensitiveStr::Ascii("nhed"),
    ],
    values: &[
        &["launch"],
        &["launched"],
        &["launcher"],
        &["launches"],
        &["launching"],
        &["launched"],
        &["launcher"],
        &["launchers"],
        &["launches"],
        &["launching"],
        &["laughably"],
        &["laughably"],
        &["laughably"],
        &["language"],
        &["languages"],
        &["language"],
        &["launched"],
        &["launching"],
        &["launch", "launches"],
        &["launch"],
        &["laundry"],
        &["language"],
        &["languages"],
        &["language"],
        &["languages"],
        &["launched"],
    ],
    range: 2..=8,
};

static WORD_LAT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_LAT_CHILDREN),
    value: None,
};

pub static WORD_LAT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eration"),
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("ets"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("itide"),
        dictgen::InsensitiveStr::Ascii("itudie"),
        dictgen::InsensitiveStr::Ascii("itudine"),
        dictgen::InsensitiveStr::Ascii("itue"),
        dictgen::InsensitiveStr::Ascii("itute"),
        dictgen::InsensitiveStr::Ascii("nern"),
        dictgen::InsensitiveStr::Ascii("ops"),
        dictgen::InsensitiveStr::Ascii("set"),
        dictgen::InsensitiveStr::Ascii("st"),
        dictgen::InsensitiveStr::Ascii("titude"),
    ],
    values: &[
        &["alteration"],
        &["later", "latest"],
        &["latest"],
        &["latin"],
        &["latitude"],
        &["latitude"],
        &["latitude"],
        &["latitude"],
        &["latitude"],
        &["lantern"],
        &["laptops"],
        &["latest"],
        &["latest"],
        &["latitude"],
    ],
    range: 2..=7,
};

static WORD_LAS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_LAS_CHILDREN),
    value: None,
};

pub static WORD_LAS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("agnea"),
        dictgen::InsensitiveStr::Ascii("agnia"),
        dictgen::InsensitiveStr::Ascii("anga"),
        dictgen::InsensitiveStr::Ascii("gana"),
        dictgen::InsensitiveStr::Ascii("o"),
        dictgen::InsensitiveStr::Ascii("onya"),
        dictgen::InsensitiveStr::Ascii("tes"),
        dictgen::InsensitiveStr::Ascii("test"),
        dictgen::InsensitiveStr::Ascii("tr"),
    ],
    values: &[
        &["lasagna"],
        &["lasagna"],
        &["lasagna"],
        &["lasagna"],
        &["also", "lasso"],
        &["lasagna"],
        &["latest"],
        &["latest", "last"],
        &["last"],
    ],
    range: 1..=5,
};

static WORD_LAR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_LAR_CHILDREN),
    value: None,
};

pub static WORD_LAR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eady"),
        dictgen::InsensitiveStr::Ascii("egly"),
        dictgen::InsensitiveStr::Ascii("er"),
        dictgen::InsensitiveStr::Ascii("g"),
        dictgen::InsensitiveStr::Ascii("get"),
        dictgen::InsensitiveStr::Ascii("gets"),
        dictgen::InsensitiveStr::Ascii("gley"),
        dictgen::InsensitiveStr::Ascii("gst"),
        dictgen::InsensitiveStr::Ascii("inges"),
        dictgen::InsensitiveStr::Ascii("ington"),
        dictgen::InsensitiveStr::Ascii("inx"),
        dictgen::InsensitiveStr::Ascii("inxes"),
        dictgen::InsensitiveStr::Ascii("rry"),
        dictgen::InsensitiveStr::Ascii("vas"),
        dictgen::InsensitiveStr::Ascii("vay"),
        dictgen::InsensitiveStr::Ascii("vays"),
        dictgen::InsensitiveStr::Ascii("vy"),
        dictgen::InsensitiveStr::Ascii("wence"),
    ],
    values: &[
        &["already"],
        &["largely"],
        &["larger", "later", "layer"],
        &["large"],
        &["larger", "largest", "target"],
        &["largest", "targets"],
        &["largely"],
        &["largest"],
        &["larynxes"],
        &["arlington"],
        &["larynx"],
        &["larynxes"],
        &["larry"],
        &["larvae"],
        &["larvae"],
        &["larvae"],
        &["larvae"],
        &["lawrence"],
    ],
    range: 1..=6,
};

static WORD_LAO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_LAO_CHILDREN),
    value: None,
};

pub static WORD_LAO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("d"),
        dictgen::InsensitiveStr::Ascii("ded"),
        dictgen::InsensitiveStr::Ascii("ding"),
        dictgen::InsensitiveStr::Ascii("douts"),
        dictgen::InsensitiveStr::Ascii("ds"),
        dictgen::InsensitiveStr::Ascii("tion"),
        dictgen::InsensitiveStr::Ascii("tions"),
        dictgen::InsensitiveStr::Ascii("ut"),
    ],
    values: &[
        &["load"],
        &["loaded"],
        &["loading"],
        &["loadouts"],
        &["loads"],
        &["laotian", "lotion"],
        &["laotians", "lotions"],
        &["layout"],
    ],
    range: 1..=5,
};

static WORD_LAN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_LAN_CHILDREN),
    value: None,
};

static WORD_LAN_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_LANA_NODE),
    None,
    None,
    Some(&WORD_LAND_NODE),
    None,
    None,
    Some(&WORD_LANG_NODE),
    None,
    Some(&WORD_LANI_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_LANN_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_LANT_NODE),
    Some(&WORD_LANU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_LANU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_LANU_CHILDREN),
    value: None,
};

pub static WORD_LANU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("age"),
        dictgen::InsensitiveStr::Ascii("ch"),
        dictgen::InsensitiveStr::Ascii("ched"),
        dictgen::InsensitiveStr::Ascii("cher"),
        dictgen::InsensitiveStr::Ascii("chers"),
        dictgen::InsensitiveStr::Ascii("ches"),
        dictgen::InsensitiveStr::Ascii("ching"),
        dictgen::InsensitiveStr::Ascii("gage"),
        dictgen::InsensitiveStr::Ascii("gages"),
    ],
    values: &[
        &["language"],
        &["launch"],
        &["launched"],
        &["launcher"],
        &["launchers"],
        &["launches"],
        &["launching"],
        &["language"],
        &["languages"],
    ],
    range: 2..=5,
};

static WORD_LANT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_LANT_CHILDREN),
    value: None,
};

pub static WORD_LANT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ren")],
    values: &[&["lantern"]],
    range: 3..=3,
};

static WORD_LANN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_LANN_CHILDREN),
    value: None,
};

pub static WORD_LANN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("asters"),
        dictgen::InsensitiveStr::Ascii("esters"),
        dictgen::InsensitiveStr::Ascii("guage"),
        dictgen::InsensitiveStr::Ascii("guages"),
        dictgen::InsensitiveStr::Ascii("istars"),
        dictgen::InsensitiveStr::Ascii("siters"),
    ],
    values: &[
        &["lannisters"],
        &["lannisters"],
        &["language"],
        &["languages"],
        &["lannisters"],
        &["lannisters"],
    ],
    range: 5..=6,
};

static WORD_LANI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_LANI_CHILDREN),
    value: None,
};

pub static WORD_LANI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ch")],
    values: &[&["launch"]],
    range: 2..=2,
};

static WORD_LANG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_LANG_CHILDREN),
    value: None,
};

static WORD_LANG_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_LANGA_NODE),
    None,
    None,
    None,
    Some(&WORD_LANGE_NODE),
    None,
    None,
    Some(&WORD_LANGH_NODE),
    Some(&WORD_LANGI_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_LANGN_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_LANGT_NODE),
    Some(&WORD_LANGU_NODE),
    None,
    None,
    None,
    Some(&WORD_LANGY_NODE),
    None,
];

static WORD_LANGY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_LANGY_CHILDREN),
    value: None,
};

pub static WORD_LANGY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("age"),
        dictgen::InsensitiveStr::Ascii("ages"),
    ],
    values: &[&["language"], &["languages"]],
    range: 3..=4,
};

static WORD_LANGU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_LANGU_CHILDREN),
    value: None,
};

pub static WORD_LANGU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ace"),
        dictgen::InsensitiveStr::Ascii("aces"),
        dictgen::InsensitiveStr::Ascii("ae"),
        dictgen::InsensitiveStr::Ascii("aes"),
        dictgen::InsensitiveStr::Ascii("ag"),
        dictgen::InsensitiveStr::Ascii("agee"),
        dictgen::InsensitiveStr::Ascii("agees"),
        dictgen::InsensitiveStr::Ascii("ague"),
        dictgen::InsensitiveStr::Ascii("agues"),
        dictgen::InsensitiveStr::Ascii("ahe"),
        dictgen::InsensitiveStr::Ascii("ahes"),
        dictgen::InsensitiveStr::Ascii("aje"),
        dictgen::InsensitiveStr::Ascii("ajes"),
        dictgen::InsensitiveStr::Ascii("al"),
        dictgen::InsensitiveStr::Ascii("ale"),
        dictgen::InsensitiveStr::Ascii("ales"),
        dictgen::InsensitiveStr::Ascii("alge"),
        dictgen::InsensitiveStr::Ascii("alges"),
        dictgen::InsensitiveStr::Ascii("anage"),
        dictgen::InsensitiveStr::Ascii("anages"),
        dictgen::InsensitiveStr::Ascii("ange"),
        dictgen::InsensitiveStr::Ascii("anges"),
        dictgen::InsensitiveStr::Ascii("aqe"),
        dictgen::InsensitiveStr::Ascii("aqes"),
        dictgen::InsensitiveStr::Ascii("are"),
        dictgen::InsensitiveStr::Ascii("ares"),
        dictgen::InsensitiveStr::Ascii("ate"),
        dictgen::InsensitiveStr::Ascii("ates"),
        dictgen::InsensitiveStr::Ascii("auge"),
        dictgen::InsensitiveStr::Ascii("auges"),
        dictgen::InsensitiveStr::Ascii("eage"),
        dictgen::InsensitiveStr::Ascii("eages"),
        dictgen::InsensitiveStr::Ascii("ege"),
        dictgen::InsensitiveStr::Ascii("eges"),
        dictgen::InsensitiveStr::Ascii("gae"),
        dictgen::InsensitiveStr::Ascii("gaes"),
        dictgen::InsensitiveStr::Ascii("gage"),
        dictgen::InsensitiveStr::Ascii("gages"),
        dictgen::InsensitiveStr::Ascii("ge"),
        dictgen::InsensitiveStr::Ascii("ges"),
        dictgen::InsensitiveStr::Ascii("gue"),
        dictgen::InsensitiveStr::Ascii("gues"),
        dictgen::InsensitiveStr::Ascii("lage"),
        dictgen::InsensitiveStr::Ascii("lages"),
        dictgen::InsensitiveStr::Ascii("qge"),
        dictgen::InsensitiveStr::Ascii("qges"),
        dictgen::InsensitiveStr::Ascii("rage"),
        dictgen::InsensitiveStr::Ascii("rages"),
    ],
    values: &[
        &["language"],
        &["languages"],
        &["language"],
        &["languages"],
        &["language"],
        &["language"],
        &["languages"],
        &["language"],
        &["languages"],
        &["language"],
        &["languages"],
        &["language"],
        &["languages"],
        &["lingual"],
        &["language"],
        &["languages"],
        &["language"],
        &["languages"],
        &["language"],
        &["languages"],
        &["language"],
        &["languages"],
        &["language"],
        &["languages"],
        &["language"],
        &["languages"],
        &["language"],
        &["languages"],
        &["language"],
        &["languages"],
        &["language"],
        &["languages"],
        &["language"],
        &["languages"],
        &["language"],
        &["languages"],
        &["language"],
        &["languages"],
        &["language"],
        &["languages"],
        &["language"],
        &["languages"],
        &["language"],
        &["languages"],
        &["language"],
        &["languages"],
        &["language"],
        &["languages"],
    ],
    range: 2..=6,
};

static WORD_LANGT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_LANGT_CHILDREN),
    value: None,
};

pub static WORD_LANGT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("h"),
        dictgen::InsensitiveStr::Ascii("hs"),
    ],
    values: &[&["length"], &["lengths"]],
    range: 1..=2,
};

static WORD_LANGN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_LANGN_CHILDREN),
    value: None,
};

pub static WORD_LANGN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("guage"),
        dictgen::InsensitiveStr::Ascii("guages"),
    ],
    values: &[&["language"], &["languages"]],
    range: 5..=6,
};

static WORD_LANGI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_LANGI_CHILDREN),
    value: None,
};

pub static WORD_LANGI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("age"),
        dictgen::InsensitiveStr::Ascii("ages"),
    ],
    values: &[&["language"], &["languages"]],
    range: 3..=4,
};

static WORD_LANGH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_LANGH_CHILDREN),
    value: None,
};

pub static WORD_LANGH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("ts"),
    ],
    values: &[&["length"], &["lengths"]],
    range: 1..=2,
};

static WORD_LANGE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_LANGE_CHILDREN),
    value: None,
};

pub static WORD_LANGE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("rie"),
        dictgen::InsensitiveStr::Ascii("rray"),
        dictgen::InsensitiveStr::Ascii("uage"),
        dictgen::InsensitiveStr::Ascii("uagesection"),
    ],
    values: &[
        &["lingerie"],
        &["lingerie"],
        &["language"],
        &["languagesection"],
    ],
    range: 3..=11,
};

static WORD_LANGA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_LANGA_CHILDREN),
    value: None,
};

pub static WORD_LANGA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ge"),
        dictgen::InsensitiveStr::Ascii("ges"),
        dictgen::InsensitiveStr::Ascii("gue"),
        dictgen::InsensitiveStr::Ascii("gues"),
        dictgen::InsensitiveStr::Ascii("uage"),
        dictgen::InsensitiveStr::Ascii("uge"),
        dictgen::InsensitiveStr::Ascii("uges"),
    ],
    values: &[
        &["language"],
        &["languages"],
        &["language"],
        &["languages"],
        &["language"],
        &["language"],
        &["languages"],
    ],
    range: 2..=4,
};

static WORD_LAND_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_LAND_CHILDREN),
    value: None,
};

pub static WORD_LAND_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("acapes"),
        dictgen::InsensitiveStr::Ascii("ingers"),
        dictgen::InsensitiveStr::Ascii("ins"),
        dictgen::InsensitiveStr::Ascii("scae"),
        dictgen::InsensitiveStr::Ascii("scaps"),
        dictgen::InsensitiveStr::Ascii("scspe"),
        dictgen::InsensitiveStr::Ascii("shapes"),
        dictgen::InsensitiveStr::Ascii("spaces"),
    ],
    values: &[
        &["landscapes"],
        &["landings"],
        &["landings"],
        &["landscapes"],
        &["landscapes"],
        &["landscapes"],
        &["landscapes"],
        &["landscapes"],
    ],
    range: 3..=6,
};

static WORD_LANA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_LANA_CHILDREN),
    value: None,
};

pub static WORD_LANA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("guage"),
        dictgen::InsensitiveStr::Ascii("guge"),
        dictgen::InsensitiveStr::Ascii("guges"),
        dictgen::InsensitiveStr::Ascii("gugs"),
        dictgen::InsensitiveStr::Ascii("uage"),
        dictgen::InsensitiveStr::Ascii("uages"),
        dictgen::InsensitiveStr::Ascii("uge"),
    ],
    values: &[
        &["language"],
        &["language"],
        &["languages"],
        &["languages"],
        &["language"],
        &["languages"],
        &["language"],
    ],
    range: 3..=5,
};

static WORD_LAM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_LAM_CHILDREN),
    value: None,
};

pub static WORD_LAM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("da"),
        dictgen::InsensitiveStr::Ascii("das"),
    ],
    values: &[&["lambda"], &["lambdas"]],
    range: 2..=3,
};

static WORD_LAI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_LAI_CHILDREN),
    value: None,
};

pub static WORD_LAI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ter")],
    values: &[&["later"]],
    range: 3..=3,
};

static WORD_LAG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_LAG_CHILDREN),
    value: None,
};

pub static WORD_LAG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("acies"),
        dictgen::InsensitiveStr::Ascii("acy"),
        dictgen::InsensitiveStr::Ascii("uage"),
        dictgen::InsensitiveStr::Ascii("uages"),
        dictgen::InsensitiveStr::Ascii("uague"),
        dictgen::InsensitiveStr::Ascii("uagues"),
        dictgen::InsensitiveStr::Ascii("uange"),
        dictgen::InsensitiveStr::Ascii("uanges"),
    ],
    values: &[
        &["legacies"],
        &["legacy"],
        &["language"],
        &["languages"],
        &["language"],
        &["languages"],
        &["language"],
        &["languages"],
    ],
    range: 3..=6,
};

static WORD_LAF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_LAF_CHILDREN),
    value: Some(&["kaf", "kaph", "lac", "lad", "lag", "laugh", "leaf", "loaf"]),
};

pub static WORD_LAF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[],
    values: &[],
    range: 0..=0,
};

static WORD_LAE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_LAE_CHILDREN),
    value: None,
};

pub static WORD_LAE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("r")],
    values: &[&["later", "layer"]],
    range: 1..=1,
};

static WORD_LAC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_LAC_CHILDREN),
    value: None,
};

pub static WORD_LAC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("kbuster"),
        dictgen::InsensitiveStr::Ascii("ker"),
        dictgen::InsensitiveStr::Ascii("kered"),
        dictgen::InsensitiveStr::Ascii("keres"),
        dictgen::InsensitiveStr::Ascii("kering"),
        dictgen::InsensitiveStr::Ascii("kers"),
        dictgen::InsensitiveStr::Ascii("klaster"),
        dictgen::InsensitiveStr::Ascii("klusture"),
        dictgen::InsensitiveStr::Ascii("krimose"),
        dictgen::InsensitiveStr::Ascii("krimosity"),
        dictgen::InsensitiveStr::Ascii("krimosly"),
    ],
    values: &[
        &["lackluster"],
        &["lacquer"],
        &["lacquered"],
        &["lacquers"],
        &["lacquering"],
        &["lacquers"],
        &["lackluster"],
        &["lacklustre"],
        &["lachrymose"],
        &["lachrymosity"],
        &["lachrymosely"],
    ],
    range: 3..=9,
};

static WORD_LAB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_LAB_CHILDREN),
    value: None,
};

pub static WORD_LAB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("arotory"),
        dictgen::InsensitiveStr::Ascii("atory"),
        dictgen::InsensitiveStr::Ascii("bel"),
        dictgen::InsensitiveStr::Ascii("beled"),
        dictgen::InsensitiveStr::Ascii("bels"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("eld"),
        dictgen::InsensitiveStr::Ascii("enese"),
        dictgen::InsensitiveStr::Ascii("irinth"),
        dictgen::InsensitiveStr::Ascii("irynth"),
        dictgen::InsensitiveStr::Ascii("le"),
        dictgen::InsensitiveStr::Ascii("led"),
        dictgen::InsensitiveStr::Ascii("lel"),
        dictgen::InsensitiveStr::Ascii("lels"),
        dictgen::InsensitiveStr::Ascii("les"),
        dictgen::InsensitiveStr::Ascii("ling"),
        dictgen::InsensitiveStr::Ascii("oratoy"),
        dictgen::InsensitiveStr::Ascii("oratroy"),
        dictgen::InsensitiveStr::Ascii("oraty"),
        dictgen::InsensitiveStr::Ascii("orerers"),
        dictgen::InsensitiveStr::Ascii("oreres"),
        dictgen::InsensitiveStr::Ascii("oritory"),
        dictgen::InsensitiveStr::Ascii("orotory"),
        dictgen::InsensitiveStr::Ascii("ouriously"),
        dictgen::InsensitiveStr::Ascii("ratory"),
        dictgen::InsensitiveStr::Ascii("riynth"),
        dictgen::InsensitiveStr::Ascii("ryinth"),
        dictgen::InsensitiveStr::Ascii("rynth"),
        dictgen::InsensitiveStr::Ascii("rynths"),
        dictgen::InsensitiveStr::Ascii("yrnith"),
    ],
    values: &[
        &["laboratory"],
        &["lavatory", "laboratory"],
        &["label"],
        &["labeled"],
        &["labels"],
        &["labeled"],
        &["labeled"],
        &["lebanese"],
        &["labyrinth"],
        &["labyrinth"],
        &["label"],
        &["labeled"],
        &["label"],
        &["labels"],
        &["labels"],
        &["labeling"],
        &["laboratory"],
        &["laboratory"],
        &["laboratory"],
        &["laborers"],
        &["laborers"],
        &["laboratory"],
        &["laboratory"],
        &["laboriously"],
        &["laboratory"],
        &["labyrinth"],
        &["labyrinth"],
        &["labyrinth"],
        &["labyrinths"],
        &["labyrinth"],
    ],
    range: 2..=9,
};

static WORD_K_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_K_CHILDREN),
    value: None,
};

static WORD_K_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_KA_NODE),
    None,
    None,
    None,
    Some(&WORD_KE_NODE),
    None,
    None,
    None,
    Some(&WORD_KI_NODE),
    None,
    None,
    Some(&WORD_KL_NODE),
    None,
    Some(&WORD_KN_NODE),
    Some(&WORD_KO_NODE),
    None,
    None,
    Some(&WORD_KR_NODE),
    None,
    Some(&WORD_KT_NODE),
    Some(&WORD_KU_NODE),
    None,
    Some(&WORD_KW_NODE),
    None,
    Some(&WORD_KY_NODE),
    None,
];

static WORD_KY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_KY_CHILDREN),
    value: None,
};

pub static WORD_KY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ebosh"),
        dictgen::InsensitiveStr::Ascii("eboshed"),
        dictgen::InsensitiveStr::Ascii("eboshes"),
        dictgen::InsensitiveStr::Ascii("eboshing"),
        dictgen::InsensitiveStr::Ascii("rillic"),
        dictgen::InsensitiveStr::Ascii("rptonite"),
    ],
    values: &[
        &["kibosh"],
        &["kiboshed"],
        &["kiboshes"],
        &["kiboshing"],
        &["cyrillic"],
        &["kryptonite"],
    ],
    range: 5..=8,
};

static WORD_KW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_KW_CHILDREN),
    value: None,
};

pub static WORD_KW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("no"),
        dictgen::InsensitiveStr::Ascii("uzine"),
        dictgen::InsensitiveStr::Ascii("uzines"),
    ],
    values: &[&["know"], &["cuisine"], &["cuisines"]],
    range: 2..=6,
};

static WORD_KU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_KU_CHILDREN),
    value: None,
};

pub static WORD_KU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("benates"),
        dictgen::InsensitiveStr::Ascii("benernetes"),
        dictgen::InsensitiveStr::Ascii("benertes"),
        dictgen::InsensitiveStr::Ascii("benetes"),
        dictgen::InsensitiveStr::Ascii("benretes"),
        dictgen::InsensitiveStr::Ascii("berenetes"),
        dictgen::InsensitiveStr::Ascii("berentes"),
        dictgen::InsensitiveStr::Ascii("beretes"),
        dictgen::InsensitiveStr::Ascii("bermetes"),
        dictgen::InsensitiveStr::Ascii("bernates"),
        dictgen::InsensitiveStr::Ascii("bernests"),
        dictgen::InsensitiveStr::Ascii("bernete"),
        dictgen::InsensitiveStr::Ascii("bernetest"),
        dictgen::InsensitiveStr::Ascii("bernets"),
        dictgen::InsensitiveStr::Ascii("berntes"),
        dictgen::InsensitiveStr::Ascii("birck"),
        dictgen::InsensitiveStr::Ascii("nckle"),
        dictgen::InsensitiveStr::Ascii("nckles"),
        dictgen::InsensitiveStr::Ascii("rbick"),
        dictgen::InsensitiveStr::Ascii("rdisch"),
        dictgen::InsensitiveStr::Ascii("ridsh"),
    ],
    values: &[
        &["kubernetes"],
        &["kubernetes"],
        &["kubernetes"],
        &["kubernetes"],
        &["kubernetes"],
        &["kubernetes"],
        &["kubernetes"],
        &["kubernetes"],
        &["kubernetes"],
        &["kubernetes"],
        &["kubernetes"],
        &["kubernetes"],
        &["kubernetes"],
        &["kubernetes"],
        &["kubernetes"],
        &["kubrick"],
        &["knuckle"],
        &["knuckles"],
        &["kubrick"],
        &["kurdish"],
        &["kurdish"],
    ],
    range: 5..=10,
};

static WORD_KT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_KT_CHILDREN),
    value: None,
};

pub static WORD_KT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ichen")],
    values: &[&["kitchen"]],
    range: 5..=5,
};

static WORD_KR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_KR_CHILDREN),
    value: None,
};

pub static WORD_KR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ankenstein"),
        dictgen::InsensitiveStr::Ascii("esh"),
        dictgen::InsensitiveStr::Ascii("oeans"),
        dictgen::InsensitiveStr::Ascii("onicle"),
        dictgen::InsensitiveStr::Ascii("onicled"),
        dictgen::InsensitiveStr::Ascii("onicler"),
        dictgen::InsensitiveStr::Ascii("oniclers"),
        dictgen::InsensitiveStr::Ascii("onicles"),
        dictgen::InsensitiveStr::Ascii("onicling"),
        dictgen::InsensitiveStr::Ascii("pytonite"),
        dictgen::InsensitiveStr::Ascii("udish"),
        dictgen::InsensitiveStr::Ascii("ypotnite"),
        dictgen::InsensitiveStr::Ascii("ypronite"),
        dictgen::InsensitiveStr::Ascii("yptinite"),
        dictgen::InsensitiveStr::Ascii("yptolite"),
        dictgen::InsensitiveStr::Ascii("yptonie"),
        dictgen::InsensitiveStr::Ascii("yptoninte"),
        dictgen::InsensitiveStr::Ascii("yptonyte"),
        dictgen::InsensitiveStr::Ascii("ypyonite"),
        dictgen::InsensitiveStr::Ascii("ytponite"),
    ],
    values: &[
        &["frankenstein"],
        &["crèche"],
        &["koreans"],
        &["chronicle"],
        &["chronicled"],
        &["chronicler"],
        &["chroniclers"],
        &["chronicles"],
        &["chronicling"],
        &["kryptonite"],
        &["kurdish"],
        &["kryptonite"],
        &["kryptonite"],
        &["kryptonite"],
        &["kryptonite"],
        &["kryptonite"],
        &["kryptonite"],
        &["kryptonite"],
        &["kryptonite"],
        &["kryptonite"],
    ],
    range: 3..=10,
};

static WORD_KO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_KO_CHILDREN),
    value: None,
};

pub static WORD_KO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("calized"),
        dictgen::InsensitiveStr::Ascii("llaboration"),
        dictgen::InsensitiveStr::Ascii("lonization"),
        dictgen::InsensitiveStr::Ascii("mbinations"),
        dictgen::InsensitiveStr::Ascii("mma"),
        dictgen::InsensitiveStr::Ascii("mmas"),
        dictgen::InsensitiveStr::Ascii("mmissioner"),
        dictgen::InsensitiveStr::Ascii("mpensation"),
        dictgen::InsensitiveStr::Ascii("ncentration"),
        dictgen::InsensitiveStr::Ascii("ncentrations"),
        dictgen::InsensitiveStr::Ascii("nckback"),
        dictgen::InsensitiveStr::Ascii("nfidential"),
        dictgen::InsensitiveStr::Ascii("nfiguration"),
        dictgen::InsensitiveStr::Ascii("nfirmation"),
        dictgen::InsensitiveStr::Ascii("nfrontation"),
        dictgen::InsensitiveStr::Ascii("ngregation"),
        dictgen::InsensitiveStr::Ascii("nservatism"),
        dictgen::InsensitiveStr::Ascii("nservative"),
        dictgen::InsensitiveStr::Ascii("nservatives"),
        dictgen::InsensitiveStr::Ascii("nstant"),
        dictgen::InsensitiveStr::Ascii("nstants"),
        dictgen::InsensitiveStr::Ascii("nstellation"),
        dictgen::InsensitiveStr::Ascii("nsultation"),
        dictgen::InsensitiveStr::Ascii("ntamination"),
        dictgen::InsensitiveStr::Ascii("nversation"),
        dictgen::InsensitiveStr::Ascii("nw"),
        dictgen::InsensitiveStr::Ascii("nwn"),
        dictgen::InsensitiveStr::Ascii("nws"),
        dictgen::InsensitiveStr::Ascii("okoo"),
        dictgen::InsensitiveStr::Ascii("okoos"),
        dictgen::InsensitiveStr::Ascii("olot"),
        dictgen::InsensitiveStr::Ascii("olots"),
        dictgen::InsensitiveStr::Ascii("ordinate"),
        dictgen::InsensitiveStr::Ascii("ordinates"),
        dictgen::InsensitiveStr::Ascii("ordination"),
        dictgen::InsensitiveStr::Ascii("reanos"),
        dictgen::InsensitiveStr::Ascii("wn"),
    ],
    values: &[
        &["localized"],
        &["collaboration"],
        &["colonization"],
        &["combinations"],
        &["coma", "comma"],
        &["comas", "commas"],
        &["commissioner"],
        &["compensation"],
        &["concentration"],
        &["concentrations"],
        &["knockback"],
        &["confidential"],
        &["configuration"],
        &["confirmation"],
        &["confrontation"],
        &["congregation"],
        &["conservatism"],
        &["conservative"],
        &["conservatives"],
        &["constant"],
        &["constants"],
        &["constellation"],
        &["consultation"],
        &["contamination"],
        &["conversation"],
        &["know"],
        &["known"],
        &["knows"],
        &["cuckoo"],
        &["cuckoos"],
        &["culotte"],
        &["culottes"],
        &["coordinate"],
        &["coordinates"],
        &["coordination"],
        &["koreans"],
        &["known"],
    ],
    range: 2..=12,
};

static WORD_KN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_KN_CHILDREN),
    value: None,
};

pub static WORD_KN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("arl"),
        dictgen::InsensitiveStr::Ascii("arled"),
        dictgen::InsensitiveStr::Ascii("arling"),
        dictgen::InsensitiveStr::Ascii("arls"),
        dictgen::InsensitiveStr::Ascii("arly"),
        dictgen::InsensitiveStr::Ascii("cokback"),
        dictgen::InsensitiveStr::Ascii("ietic"),
        dictgen::InsensitiveStr::Ascii("igths"),
        dictgen::InsensitiveStr::Ascii("ive"),
        dictgen::InsensitiveStr::Ascii("o"),
        dictgen::InsensitiveStr::Ascii("ockbak"),
        dictgen::InsensitiveStr::Ascii("ockous"),
        dictgen::InsensitiveStr::Ascii("ockously"),
        dictgen::InsensitiveStr::Ascii("olwedgable"),
        dictgen::InsensitiveStr::Ascii("oweldgable"),
        dictgen::InsensitiveStr::Ascii("oweldge"),
        dictgen::InsensitiveStr::Ascii("oweldgeable"),
        dictgen::InsensitiveStr::Ascii("owladgable"),
        dictgen::InsensitiveStr::Ascii("owladge"),
        dictgen::InsensitiveStr::Ascii("owlage"),
        dictgen::InsensitiveStr::Ascii("owlageable"),
        dictgen::InsensitiveStr::Ascii("owldegable"),
        dictgen::InsensitiveStr::Ascii("owldgeable"),
        dictgen::InsensitiveStr::Ascii("owleagable"),
        dictgen::InsensitiveStr::Ascii("owledagble"),
        dictgen::InsensitiveStr::Ascii("owledeable"),
        dictgen::InsensitiveStr::Ascii("owledegable"),
        dictgen::InsensitiveStr::Ascii("owledgabe"),
        dictgen::InsensitiveStr::Ascii("owledgabel"),
        dictgen::InsensitiveStr::Ascii("owledgble"),
        dictgen::InsensitiveStr::Ascii("owledgebale"),
        dictgen::InsensitiveStr::Ascii("owledgeble"),
        dictgen::InsensitiveStr::Ascii("owledgebly"),
        dictgen::InsensitiveStr::Ascii("owledgible"),
        dictgen::InsensitiveStr::Ascii("owlegable"),
        dictgen::InsensitiveStr::Ascii("owlegdable"),
        dictgen::InsensitiveStr::Ascii("owlegde"),
        dictgen::InsensitiveStr::Ascii("owlegdeable"),
        dictgen::InsensitiveStr::Ascii("owlege"),
        dictgen::InsensitiveStr::Ascii("owlegeabel"),
        dictgen::InsensitiveStr::Ascii("owlegeable"),
        dictgen::InsensitiveStr::Ascii("uckel"),
        dictgen::InsensitiveStr::Ascii("uckels"),
        dictgen::InsensitiveStr::Ascii("wo"),
        dictgen::InsensitiveStr::Ascii("woing"),
        dictgen::InsensitiveStr::Ascii("woingly"),
        dictgen::InsensitiveStr::Ascii("woledgable"),
        dictgen::InsensitiveStr::Ascii("won"),
        dictgen::InsensitiveStr::Ascii("wos"),
    ],
    values: &[
        &["gnarl"],
        &["gnarled"],
        &["gnarling"],
        &["gnarls"],
        &["gnarly"],
        &["knockback"],
        &["kinetic"],
        &["knights"],
        &["knife"],
        &["know"],
        &["knockback"],
        &["noxious"],
        &["noxiously"],
        &["knowledgable"],
        &["knowledgable"],
        &["knowledge"],
        &["knowledgeable"],
        &["knowledgable"],
        &["knowledge"],
        &["knowledge"],
        &["knowledgeable"],
        &["knowledgable"],
        &["knowledgable"],
        &["knowledgable"],
        &["knowledgable"],
        &["knowledgable"],
        &["knowledgeable"],
        &["knowledgable"],
        &["knowledgable"],
        &["knowledgable"],
        &["knowledgable"],
        &["knowledgeable"],
        &["knowledgable"],
        &["knowledgable"],
        &["knowledgeable"],
        &["knowledgable"],
        &["knowledge"],
        &["knowledgeable"],
        &["knowledge"],
        &["knowledgeable"],
        &["knowledgeable"],
        &["knuckle"],
        &["knuckles"],
        &["know"],
        &["knowing"],
        &["knowingly"],
        &["knowledgable"],
        &["known"],
        &["knows"],
    ],
    range: 1..=11,
};

static WORD_KL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_KL_CHILDREN),
    value: None,
};

pub static WORD_KL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("enex"),
        dictgen::InsensitiveStr::Ascii("ick"),
        dictgen::InsensitiveStr::Ascii("icked"),
        dictgen::InsensitiveStr::Ascii("icks"),
        dictgen::InsensitiveStr::Ascii("unky"),
    ],
    values: &[
        &["kleenex"],
        &["click"],
        &["clicked"],
        &["clicks"],
        &["clunky"],
    ],
    range: 3..=5,
};

static WORD_KI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_KI_CHILDREN),
    value: None,
};

static WORD_KI_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    Some(&WORD_KIB_NODE),
    Some(&WORD_KIC_NODE),
    Some(&WORD_KID_NODE),
    None,
    None,
    Some(&WORD_KIG_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_KIL_NODE),
    Some(&WORD_KIM_NODE),
    Some(&WORD_KIN_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_KIT_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_KIY_NODE),
    None,
];

static WORD_KIY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_KIY_CHILDREN),
    value: None,
};

pub static WORD_KIY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ack"),
        dictgen::InsensitiveStr::Ascii("acked"),
        dictgen::InsensitiveStr::Ascii("acker"),
        dictgen::InsensitiveStr::Ascii("ackers"),
        dictgen::InsensitiveStr::Ascii("acking"),
        dictgen::InsensitiveStr::Ascii("acks"),
    ],
    values: &[
        &["kayak"],
        &["kayaked"],
        &["kayaker"],
        &["kayakers"],
        &["kayaking"],
        &["kayaks"],
    ],
    range: 3..=6,
};

static WORD_KIT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_KIT_CHILDREN),
    value: None,
};

pub static WORD_KIT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ches"),
        dictgen::InsensitiveStr::Ascii("ites"),
        dictgen::InsensitiveStr::Ascii("tiens"),
    ],
    values: &[&["kitchens"], &["kitties"], &["kitties"]],
    range: 4..=5,
};

static WORD_KIN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_KIN_CHILDREN),
    value: None,
};

pub static WORD_KIN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("dapped"),
        dictgen::InsensitiveStr::Ascii("dapping"),
        dictgen::InsensitiveStr::Ascii("dergarden"),
        dictgen::InsensitiveStr::Ascii("dergaten"),
        dictgen::InsensitiveStr::Ascii("dgergarden"),
        dictgen::InsensitiveStr::Ascii("dgergarten"),
        dictgen::InsensitiveStr::Ascii("dgoms"),
        dictgen::InsensitiveStr::Ascii("eitc"),
        dictgen::InsensitiveStr::Ascii("f"),
        dictgen::InsensitiveStr::Ascii("fs"),
        dictgen::InsensitiveStr::Ascii("gdomers"),
        dictgen::InsensitiveStr::Ascii("gergarten"),
        dictgen::InsensitiveStr::Ascii("ghts"),
        dictgen::InsensitiveStr::Ascii("nect"),
        dictgen::InsensitiveStr::Ascii("teic"),
        dictgen::InsensitiveStr::Ascii("tergarten"),
    ],
    values: &[
        &["kidnapped"],
        &["kidnapping"],
        &["kindergarten"],
        &["kindergarten"],
        &["kindergarten"],
        &["kindergarten"],
        &["kingdoms"],
        &["kinetic"],
        &["kind"],
        &["kinds"],
        &["kingdoms"],
        &["kindergarten"],
        &["knights"],
        &["kinect"],
        &["kinetic"],
        &["kindergarten"],
    ],
    range: 1..=10,
};

static WORD_KIM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_KIM_CHILDREN),
    value: None,
};

pub static WORD_KIM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("era"),
        dictgen::InsensitiveStr::Ascii("eric"),
        dictgen::InsensitiveStr::Ascii("erical"),
        dictgen::InsensitiveStr::Ascii("erically"),
        dictgen::InsensitiveStr::Ascii("erra"),
        dictgen::InsensitiveStr::Ascii("erric"),
        dictgen::InsensitiveStr::Ascii("errical"),
        dictgen::InsensitiveStr::Ascii("errically"),
    ],
    values: &[
        &["chimera"],
        &["chimeric"],
        &["chimerical"],
        &["chimerically"],
        &["chimera"],
        &["chimeric"],
        &["chimerical"],
        &["chimerically"],
    ],
    range: 3..=9,
};

static WORD_KIL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_KIL_CHILDREN),
    value: None,
};

pub static WORD_KIL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("lingest"),
        dictgen::InsensitiveStr::Ascii("lins"),
        dictgen::InsensitiveStr::Ascii("ometeres"),
        dictgen::InsensitiveStr::Ascii("ometes"),
        dictgen::InsensitiveStr::Ascii("ometros"),
        dictgen::InsensitiveStr::Ascii("omiters"),
        dictgen::InsensitiveStr::Ascii("omoters"),
        dictgen::InsensitiveStr::Ascii("omteres"),
    ],
    values: &[
        &["killings"],
        &["killings"],
        &["kilometers"],
        &["kilometers"],
        &["kilometres"],
        &["kilometers"],
        &["kilometers"],
        &["kilometers"],
    ],
    range: 4..=8,
};

static WORD_KIG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_KIG_CHILDREN),
    value: None,
};

pub static WORD_KIG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("hbosh"),
        dictgen::InsensitiveStr::Ascii("hboshed"),
        dictgen::InsensitiveStr::Ascii("hboshes"),
        dictgen::InsensitiveStr::Ascii("hboshing"),
    ],
    values: &[&["kibosh"], &["kiboshed"], &["kiboshes"], &["kiboshing"]],
    range: 5..=8,
};

static WORD_KID_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_KID_CHILDREN),
    value: None,
};

pub static WORD_KID_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("knap"),
        dictgen::InsensitiveStr::Ascii("knapped"),
        dictgen::InsensitiveStr::Ascii("knappee"),
        dictgen::InsensitiveStr::Ascii("knappees"),
        dictgen::InsensitiveStr::Ascii("knapper"),
        dictgen::InsensitiveStr::Ascii("knappers"),
        dictgen::InsensitiveStr::Ascii("knapping"),
        dictgen::InsensitiveStr::Ascii("knaps"),
        dictgen::InsensitiveStr::Ascii("napning"),
        dictgen::InsensitiveStr::Ascii("nappade"),
        dictgen::InsensitiveStr::Ascii("nappning"),
        dictgen::InsensitiveStr::Ascii("nappping"),
        dictgen::InsensitiveStr::Ascii("nergarten"),
    ],
    values: &[
        &["kidnap"],
        &["kidnapped"],
        &["kidnappee"],
        &["kidnappees"],
        &["kidnapper"],
        &["kidnappers"],
        &["kidnapping"],
        &["kidnaps"],
        &["kidnapping"],
        &["kidnapped"],
        &["kidnapping"],
        &["kidnapping"],
        &["kindergarten"],
    ],
    range: 4..=9,
};

static WORD_KIC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_KIC_CHILDREN),
    value: None,
};

pub static WORD_KIC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("kstarer"),
        dictgen::InsensitiveStr::Ascii("kstartr"),
        dictgen::InsensitiveStr::Ascii("kstater"),
        dictgen::InsensitiveStr::Ascii("then"),
        dictgen::InsensitiveStr::Ascii("thens"),
    ],
    values: &[
        &["kickstarter"],
        &["kickstarter"],
        &["kickstarter"],
        &["kitchen"],
        &["kitchens"],
    ],
    range: 4..=7,
};

static WORD_KIB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_KIB_CHILDREN),
    value: None,
};

pub static WORD_KIB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("utz"),
        dictgen::InsensitiveStr::Ascii("utzes"),
        dictgen::InsensitiveStr::Ascii("utzim"),
    ],
    values: &[&["kibbutz"], &["kibbutzim"], &["kibbutzim"]],
    range: 3..=5,
};

static WORD_KE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_KE_CHILDREN),
    value: None,
};

static WORD_KE_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    None,
    None,
    Some(&WORD_KEE_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_KEN_NODE),
    None,
    Some(&WORD_KEP_NODE),
    None,
    Some(&WORD_KER_NODE),
    None,
    Some(&WORD_KET_NODE),
    None,
    None,
    Some(&WORD_KEW_NODE),
    None,
    Some(&WORD_KEY_NODE),
    None,
];

static WORD_KEY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_KEY_CHILDREN),
    value: None,
};

pub static WORD_KEY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("baord"),
        dictgen::InsensitiveStr::Ascii("baords"),
        dictgen::InsensitiveStr::Ascii("bard"),
        dictgen::InsensitiveStr::Ascii("boaard"),
        dictgen::InsensitiveStr::Ascii("boaards"),
        dictgen::InsensitiveStr::Ascii("boad"),
        dictgen::InsensitiveStr::Ascii("boads"),
        dictgen::InsensitiveStr::Ascii("boars"),
        dictgen::InsensitiveStr::Ascii("booard"),
        dictgen::InsensitiveStr::Ascii("booards"),
        dictgen::InsensitiveStr::Ascii("borad"),
        dictgen::InsensitiveStr::Ascii("borads"),
        dictgen::InsensitiveStr::Ascii("bord"),
        dictgen::InsensitiveStr::Ascii("bords"),
        dictgen::InsensitiveStr::Ascii("broad"),
        dictgen::InsensitiveStr::Ascii("broads"),
        dictgen::InsensitiveStr::Ascii("chan"),
        dictgen::InsensitiveStr::Ascii("chian"),
        dictgen::InsensitiveStr::Ascii("ensian"),
        dictgen::InsensitiveStr::Ascii("esnian"),
        dictgen::InsensitiveStr::Ascii("evente"),
        dictgen::InsensitiveStr::Ascii("node"),
        dictgen::InsensitiveStr::Ascii("nseian"),
        dictgen::InsensitiveStr::Ascii("ords"),
        dictgen::InsensitiveStr::Ascii("osk"),
        dictgen::InsensitiveStr::Ascii("osks"),
        dictgen::InsensitiveStr::Ascii("outch"),
        dictgen::InsensitiveStr::Ascii("owrd"),
        dictgen::InsensitiveStr::Ascii("senian"),
        dictgen::InsensitiveStr::Ascii("stokes"),
        dictgen::InsensitiveStr::Ascii("ward"),
        dictgen::InsensitiveStr::Ascii("woards"),
        dictgen::InsensitiveStr::Ascii("woed"),
        dictgen::InsensitiveStr::Ascii("work"),
        dictgen::InsensitiveStr::Ascii("workd"),
        dictgen::InsensitiveStr::Ascii("workds"),
        dictgen::InsensitiveStr::Ascii("wors"),
        dictgen::InsensitiveStr::Ascii("wprd"),
    ],
    values: &[
        &["keyboard"],
        &["keyboards"],
        &["keyboard"],
        &["keyboard"],
        &["keyboards"],
        &["keyboard"],
        &["keyboards"],
        &["keyboards", "keyboard"],
        &["keyboard"],
        &["keyboards"],
        &["keyboard"],
        &["keyboards"],
        &["keyboard"],
        &["keyboards"],
        &["keyboard"],
        &["keyboards"],
        &["keychain"],
        &["keychain"],
        &["keynesian"],
        &["keynesian"],
        &["keyevent"],
        &["keynote"],
        &["keynesian"],
        &["keywords"],
        &["kiosk"],
        &["kiosks"],
        &["keytouch"],
        &["keyword"],
        &["keynesian"],
        &["keystrokes"],
        &["keyword"],
        &["keywords"],
        &["keyword"],
        &["keyword"],
        &["keyword"],
        &["keywords"],
        &["keywords"],
        &["keyword"],
    ],
    range: 3..=7,
};

static WORD_KEW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_KEW_CHILDREN),
    value: None,
};

pub static WORD_KEW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ord"),
        dictgen::InsensitiveStr::Ascii("ords"),
        dictgen::InsensitiveStr::Ascii("word"),
        dictgen::InsensitiveStr::Ascii("words"),
    ],
    values: &[&["keyword"], &["keywords"], &["keyword"], &["keywords"]],
    range: 3..=5,
};

static WORD_KET_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_KET_CHILDREN),
    value: Some(&["kept", "key"]),
};

pub static WORD_KET_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("maine")],
    values: &[&["ketamine"]],
    range: 5..=5,
};

static WORD_KER_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_KER_CHILDREN),
    value: None,
};

pub static WORD_KER_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("enl"),
        dictgen::InsensitiveStr::Ascii("enls"),
        dictgen::InsensitiveStr::Ascii("nal"),
        dictgen::InsensitiveStr::Ascii("nals"),
        dictgen::InsensitiveStr::Ascii("nerl"),
        dictgen::InsensitiveStr::Ascii("nerls"),
        dictgen::InsensitiveStr::Ascii("nul"),
        dictgen::InsensitiveStr::Ascii("nuls"),
    ],
    values: &[
        &["kernel"],
        &["kernels"],
        &["kernel"],
        &["kernels"],
        &["kernel"],
        &["kernels"],
        &["colonel", "kernel"],
        &["colonels", "kernels"],
    ],
    range: 3..=5,
};

static WORD_KEP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_KEP_CHILDREN),
    value: None,
};

pub static WORD_KEP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ping"),
        dictgen::InsensitiveStr::Ascii("ps"),
    ],
    values: &[&["keeping"], &["keeps"]],
    range: 2..=4,
};

static WORD_KEN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_KEN_CHILDREN),
    value: None,
};

pub static WORD_KEN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("el"),
        dictgen::InsensitiveStr::Ascii("els"),
        dictgen::InsensitiveStr::Ascii("endy"),
        dictgen::InsensitiveStr::Ascii("erl"),
        dictgen::InsensitiveStr::Ascii("erls"),
        dictgen::InsensitiveStr::Ascii("eysian"),
        dictgen::InsensitiveStr::Ascii("ndey"),
        dictgen::InsensitiveStr::Ascii("nedey"),
        dictgen::InsensitiveStr::Ascii("rel"),
        dictgen::InsensitiveStr::Ascii("rels"),
        dictgen::InsensitiveStr::Ascii("tuckey"),
        dictgen::InsensitiveStr::Ascii("tucy"),
        dictgen::InsensitiveStr::Ascii("yesian"),
    ],
    values: &[
        &["kernel", "kennel"],
        &["kernels", "kennels"],
        &["kennedy"],
        &["kernel"],
        &["kernels"],
        &["keynesian"],
        &["kennedy"],
        &["kennedy"],
        &["kernel"],
        &["kernels"],
        &["kentucky"],
        &["kentucky"],
        &["keynesian"],
    ],
    range: 2..=6,
};

static WORD_KEE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_KEE_CHILDREN),
    value: None,
};

pub static WORD_KEE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("o"),
        dictgen::InsensitiveStr::Ascii("pt"),
        dictgen::InsensitiveStr::Ascii("sh"),
    ],
    values: &[&["keep"], &["kept"], &["quiche"]],
    range: 1..=2,
};

static WORD_KA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_KA_CHILDREN),
    value: None,
};

pub static WORD_KA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ckie"),
        dictgen::InsensitiveStr::Ascii("ckies"),
        dictgen::InsensitiveStr::Ascii("ke"),
        dictgen::InsensitiveStr::Ascii("kfa"),
        dictgen::InsensitiveStr::Ascii("lidescope"),
        dictgen::InsensitiveStr::Ascii("lidescopes"),
        dictgen::InsensitiveStr::Ascii("rakoe"),
        dictgen::InsensitiveStr::Ascii("rbohydrates"),
        dictgen::InsensitiveStr::Ascii("risma"),
        dictgen::InsensitiveStr::Ascii("rismatic"),
        dictgen::InsensitiveStr::Ascii("rismatically"),
        dictgen::InsensitiveStr::Ascii("roake"),
        dictgen::InsensitiveStr::Ascii("tastrophic"),
        dictgen::InsensitiveStr::Ascii("temine"),
        dictgen::InsensitiveStr::Ascii("zakstan"),
    ],
    values: &[
        &["khaki"],
        &["khakis"],
        &["cake", "take"],
        &["kafka"],
        &["kaleidoscope"],
        &["kaleidoscopes"],
        &["karaoke"],
        &["carbohydrates"],
        &["charisma"],
        &["charismatic"],
        &["charismatically"],
        &["karaoke"],
        &["catastrophic"],
        &["ketamine"],
        &["kazakhstan"],
    ],
    range: 2..=12,
};

static WORD_J_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_J_CHILDREN),
    value: None,
};

static WORD_J_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_JA_NODE),
    None,
    None,
    None,
    Some(&WORD_JE_NODE),
    None,
    None,
    Some(&WORD_JH_NODE),
    Some(&WORD_JI_NODE),
    None,
    Some(&WORD_JK_NODE),
    None,
    None,
    None,
    Some(&WORD_JO_NODE),
    Some(&WORD_JP_NODE),
    None,
    None,
    Some(&WORD_JS_NODE),
    None,
    Some(&WORD_JU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_JU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_JU_CHILDREN),
    value: None,
};

static WORD_JU_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_JUA_NODE),
    None,
    None,
    Some(&WORD_JUD_NODE),
    None,
    None,
    Some(&WORD_JUG_NODE),
    None,
    Some(&WORD_JUI_NODE),
    None,
    None,
    Some(&WORD_JUL_NODE),
    Some(&WORD_JUM_NODE),
    Some(&WORD_JUN_NODE),
    None,
    Some(&WORD_JUP_NODE),
    None,
    Some(&WORD_JUR_NODE),
    Some(&WORD_JUS_NODE),
    None,
    None,
    Some(&WORD_JUV_NODE),
    None,
    Some(&WORD_JUX_NODE),
    None,
    None,
];

static WORD_JUX_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_JUX_CHILDREN),
    value: None,
};

pub static WORD_JUX_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("tification"),
        dictgen::InsensitiveStr::Ascii("tifications"),
        dictgen::InsensitiveStr::Ascii("tified"),
        dictgen::InsensitiveStr::Ascii("tifies"),
        dictgen::InsensitiveStr::Ascii("tifying"),
    ],
    values: &[
        &["just"],
        &["justification"],
        &["justifications"],
        &["justified"],
        &["justifies"],
        &["justifying"],
    ],
    range: 1..=11,
};

static WORD_JUV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_JUV_CHILDREN),
    value: None,
};

pub static WORD_JUV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eline"),
        dictgen::InsensitiveStr::Ascii("enille"),
        dictgen::InsensitiveStr::Ascii("enilles"),
        dictgen::InsensitiveStr::Ascii("enlie"),
    ],
    values: &[&["juvenile"], &["juvenile"], &["juvenile"], &["juvenile"]],
    range: 5..=7,
};

static WORD_JUS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_JUS_CHILDREN),
    value: Some(&["just"]),
};

pub static WORD_JUS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("itfication"),
        dictgen::InsensitiveStr::Ascii("itfy"),
        dictgen::InsensitiveStr::Ascii("ridiction"),
        dictgen::InsensitiveStr::Ascii("tfied"),
        dictgen::InsensitiveStr::Ascii("tfiy"),
        dictgen::InsensitiveStr::Ascii("tication"),
        dictgen::InsensitiveStr::Ascii("tifed"),
        dictgen::InsensitiveStr::Ascii("tifiaction"),
        dictgen::InsensitiveStr::Ascii("tifible"),
        dictgen::InsensitiveStr::Ascii("tificacion"),
        dictgen::InsensitiveStr::Ascii("tificaiton"),
        dictgen::InsensitiveStr::Ascii("tificatin"),
        dictgen::InsensitiveStr::Ascii("tificativo"),
        dictgen::InsensitiveStr::Ascii("tificativos"),
        dictgen::InsensitiveStr::Ascii("tificatons"),
        dictgen::InsensitiveStr::Ascii("tificstion"),
        dictgen::InsensitiveStr::Ascii("tifiy"),
        dictgen::InsensitiveStr::Ascii("tifyable"),
        dictgen::InsensitiveStr::Ascii("tiifcation"),
        dictgen::InsensitiveStr::Ascii("ts"),
    ],
    values: &[
        &["just", "juice", "jude", "june"],
        &["justifications"],
        &["justify"],
        &["jurisdiction"],
        &["justified"],
        &["justify"],
        &["justification"],
        &["justified"],
        &["justifications"],
        &["justifiable"],
        &["justification"],
        &["justification"],
        &["justifications"],
        &["justification"],
        &["justifications"],
        &["justifications"],
        &["justifications"],
        &["justify"],
        &["justifiable"],
        &["justifications"],
        &["just"],
    ],
    range: 1..=11,
};

static WORD_JUR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_JUR_CHILDREN),
    value: None,
};

pub static WORD_JUR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("idisction"),
        dictgen::InsensitiveStr::Ascii("isdiccion"),
        dictgen::InsensitiveStr::Ascii("isdiciton"),
        dictgen::InsensitiveStr::Ascii("isdicitons"),
        dictgen::InsensitiveStr::Ascii("isdiktion"),
        dictgen::InsensitiveStr::Ascii("isfiction"),
        dictgen::InsensitiveStr::Ascii("isidction"),
        dictgen::InsensitiveStr::Ascii("isidctions"),
        dictgen::InsensitiveStr::Ascii("istiction"),
        dictgen::InsensitiveStr::Ascii("istictions"),
        dictgen::InsensitiveStr::Ascii("nal"),
        dictgen::InsensitiveStr::Ascii("naled"),
        dictgen::InsensitiveStr::Ascii("naler"),
        dictgen::InsensitiveStr::Ascii("nales"),
        dictgen::InsensitiveStr::Ascii("naling"),
        dictgen::InsensitiveStr::Ascii("nals"),
        dictgen::InsensitiveStr::Ascii("nied"),
        dictgen::InsensitiveStr::Ascii("nies"),
        dictgen::InsensitiveStr::Ascii("ny"),
        dictgen::InsensitiveStr::Ascii("nyed"),
        dictgen::InsensitiveStr::Ascii("nyes"),
        dictgen::InsensitiveStr::Ascii("nys"),
        dictgen::InsensitiveStr::Ascii("sidiction"),
        dictgen::InsensitiveStr::Ascii("sidictions"),
    ],
    values: &[
        &["jurisdictions"],
        &["jurisdiction"],
        &["jurisdiction"],
        &["jurisdictions"],
        &["jurisdiction"],
        &["jurisdiction"],
        &["jurisdiction"],
        &["jurisdictions"],
        &["jurisdiction"],
        &["jurisdictions"],
        &["journal"],
        &["journaled"],
        &["journaler"],
        &["journals"],
        &["journaling"],
        &["journals"],
        &["journeyed"],
        &["journeys"],
        &["journey"],
        &["journeyed"],
        &["journeys"],
        &["journeys"],
        &["jurisdiction"],
        &["jurisdictions"],
    ],
    range: 2..=10,
};

static WORD_JUP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_JUP_CHILDREN),
    value: None,
};

pub static WORD_JUP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("tier"),
        dictgen::InsensitiveStr::Ascii("yther"),
    ],
    values: &[&["jupiter"], &["jupyter"]],
    range: 4..=5,
};

static WORD_JUN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_JUN_CHILDREN),
    value: None,
};

pub static WORD_JUN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("glig"),
        dictgen::InsensitiveStr::Ascii("glign"),
        dictgen::InsensitiveStr::Ascii("i"),
        dictgen::InsensitiveStr::Ascii("lging"),
    ],
    values: &[&["jungling"], &["jungling"], &["june"], &["jungling"]],
    range: 1..=5,
};

static WORD_JUM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_JUM_CHILDREN),
    value: None,
};

pub static WORD_JUM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("o"),
        dictgen::InsensitiveStr::Ascii("oed"),
        dictgen::InsensitiveStr::Ascii("pimng"),
        dictgen::InsensitiveStr::Ascii("pt"),
    ],
    values: &[&["jump"], &["jumped"], &["jumping"], &["jumped", "jump"]],
    range: 1..=5,
};

static WORD_JUL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_JUL_CHILDREN),
    value: None,
};

pub static WORD_JUL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("i")],
    values: &[&["july"]],
    range: 1..=1,
};

static WORD_JUI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_JUI_CHILDREN),
    value: None,
};

pub static WORD_JUI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("pter")],
    values: &[&["jupiter"]],
    range: 4..=4,
};

static WORD_JUG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_JUG_CHILDREN),
    value: None,
};

pub static WORD_JUG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("dement"),
        dictgen::InsensitiveStr::Ascii("demental"),
        dictgen::InsensitiveStr::Ascii("dements"),
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("garnaut"),
        dictgen::InsensitiveStr::Ascii("geranut"),
        dictgen::InsensitiveStr::Ascii("gernat"),
        dictgen::InsensitiveStr::Ascii("gernath"),
        dictgen::InsensitiveStr::Ascii("gernaugt"),
        dictgen::InsensitiveStr::Ascii("gernault"),
        dictgen::InsensitiveStr::Ascii("gernaunt"),
        dictgen::InsensitiveStr::Ascii("gernaunts"),
        dictgen::InsensitiveStr::Ascii("gernout"),
        dictgen::InsensitiveStr::Ascii("gernuat"),
        dictgen::InsensitiveStr::Ascii("getnaut"),
        dictgen::InsensitiveStr::Ascii("glenaut"),
        dictgen::InsensitiveStr::Ascii("gurnaut"),
        dictgen::InsensitiveStr::Ascii("nling"),
    ],
    values: &[
        &["judgement"],
        &["judgemental"],
        &["judgements"],
        &["judge"],
        &["juggernaut"],
        &["juggernaut"],
        &["juggernaut"],
        &["juggernaut"],
        &["juggernaut"],
        &["juggernaut"],
        &["juggernaut"],
        &["juggernaut"],
        &["juggernaut"],
        &["juggernaut"],
        &["juggernaut"],
        &["juggernaut"],
        &["juggernaut"],
        &["jungling"],
    ],
    range: 1..=9,
};

static WORD_JUD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_JUD_CHILDREN),
    value: None,
};

pub static WORD_JUD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aisim"),
        dictgen::InsensitiveStr::Ascii("asim"),
        dictgen::InsensitiveStr::Ascii("egment"),
        dictgen::InsensitiveStr::Ascii("egmental"),
        dictgen::InsensitiveStr::Ascii("egments"),
        dictgen::InsensitiveStr::Ascii("gamental"),
        dictgen::InsensitiveStr::Ascii("gemant"),
        dictgen::InsensitiveStr::Ascii("gemenal"),
        dictgen::InsensitiveStr::Ascii("gementals"),
        dictgen::InsensitiveStr::Ascii("gementle"),
        dictgen::InsensitiveStr::Ascii("gementsl"),
        dictgen::InsensitiveStr::Ascii("gemet"),
        dictgen::InsensitiveStr::Ascii("gemetal"),
        dictgen::InsensitiveStr::Ascii("genental"),
        dictgen::InsensitiveStr::Ascii("ical"),
        dictgen::InsensitiveStr::Ascii("isuary"),
        dictgen::InsensitiveStr::Ascii("ucial"),
    ],
    values: &[
        &["judaism"],
        &["judaism"],
        &["judgment"],
        &["judgmental"],
        &["judgments"],
        &["judgemental"],
        &["judgemental"],
        &["judgemental"],
        &["judgements"],
        &["judgemental"],
        &["judgemental"],
        &["judgements"],
        &["judgemental"],
        &["judgemental"],
        &["judicial"],
        &["judiciary"],
        &["judicial"],
    ],
    range: 4..=9,
};

static WORD_JUA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_JUA_CHILDREN),
    value: None,
};

pub static WORD_JUA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("daism"),
        dictgen::InsensitiveStr::Ascii("dism"),
    ],
    values: &[&["judaism"], &["judaism"]],
    range: 4..=5,
};

static WORD_JS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_JS_CHILDREN),
    value: None,
};

pub static WORD_JS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cipt"),
        dictgen::InsensitiveStr::Ascii("tu"),
        dictgen::InsensitiveStr::Ascii("ut"),
        dictgen::InsensitiveStr::Ascii("utification"),
    ],
    values: &[&["jscript"], &["just"], &["just"], &["justifications"]],
    range: 2..=11,
};

static WORD_JP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_JP_CHILDREN),
    value: None,
};

pub static WORD_JP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("in"),
        dictgen::InsensitiveStr::Ascii("ng"),
    ],
    values: &[&["join"], &["png", "jpg", "jpeg"]],
    range: 2..=2,
};

static WORD_JO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_JO_CHILDREN),
    value: None,
};

pub static WORD_JO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("anthan"),
        dictgen::InsensitiveStr::Ascii("dpers"),
        dictgen::InsensitiveStr::Ascii("epardy"),
        dictgen::InsensitiveStr::Ascii("hanine"),
        dictgen::InsensitiveStr::Ascii("ineable"),
        dictgen::InsensitiveStr::Ascii("inning"),
        dictgen::InsensitiveStr::Ascii("natahn"),
        dictgen::InsensitiveStr::Ascii("nt"),
        dictgen::InsensitiveStr::Ascii("nts"),
        dictgen::InsensitiveStr::Ascii("rnal"),
        dictgen::InsensitiveStr::Ascii("runal"),
        dictgen::InsensitiveStr::Ascii("sn"),
        dictgen::InsensitiveStr::Ascii("speh"),
        dictgen::InsensitiveStr::Ascii("ssle"),
        dictgen::InsensitiveStr::Ascii("uney"),
        dictgen::InsensitiveStr::Ascii("unral"),
        dictgen::InsensitiveStr::Ascii("unralism"),
        dictgen::InsensitiveStr::Ascii("unralist"),
        dictgen::InsensitiveStr::Ascii("unralistic"),
        dictgen::InsensitiveStr::Ascii("unralists"),
        dictgen::InsensitiveStr::Ascii("uranlism"),
        dictgen::InsensitiveStr::Ascii("uranlist"),
        dictgen::InsensitiveStr::Ascii("uranlistic"),
        dictgen::InsensitiveStr::Ascii("uranlists"),
        dictgen::InsensitiveStr::Ascii("urnaal"),
        dictgen::InsensitiveStr::Ascii("urnalims"),
        dictgen::InsensitiveStr::Ascii("urnalis"),
        dictgen::InsensitiveStr::Ascii("urnalisim"),
        dictgen::InsensitiveStr::Ascii("urnalisitc"),
        dictgen::InsensitiveStr::Ascii("urnalisitic"),
        dictgen::InsensitiveStr::Ascii("urnalistc"),
        dictgen::InsensitiveStr::Ascii("urnalistens"),
        dictgen::InsensitiveStr::Ascii("urnalisters"),
        dictgen::InsensitiveStr::Ascii("urnalistes"),
        dictgen::InsensitiveStr::Ascii("urnalistisch"),
        dictgen::InsensitiveStr::Ascii("urnalistische"),
        dictgen::InsensitiveStr::Ascii("urnalistisk"),
        dictgen::InsensitiveStr::Ascii("urnalits"),
        dictgen::InsensitiveStr::Ascii("urnalizm"),
        dictgen::InsensitiveStr::Ascii("urnalsim"),
        dictgen::InsensitiveStr::Ascii("urnied"),
        dictgen::InsensitiveStr::Ascii("urnies"),
        dictgen::InsensitiveStr::Ascii("urning"),
        dictgen::InsensitiveStr::Ascii("urnolist"),
        dictgen::InsensitiveStr::Ascii("urnolists"),
        dictgen::InsensitiveStr::Ascii("urny"),
        dictgen::InsensitiveStr::Ascii("urnyed"),
        dictgen::InsensitiveStr::Ascii("urnyes"),
        dictgen::InsensitiveStr::Ascii("urnying"),
        dictgen::InsensitiveStr::Ascii("urnys"),
        dictgen::InsensitiveStr::Ascii("ysitck"),
        dictgen::InsensitiveStr::Ascii("ystik"),
    ],
    values: &[
        &["jonathan"],
        &["jodhpurs"],
        &["jeopardy"],
        &["johannine"],
        &["joinable"],
        &["joining"],
        &["jonathan"],
        &["joint"],
        &["joints"],
        &["journal"],
        &["journal"],
        &["json"],
        &["joseph"],
        &["jostle"],
        &["journey"],
        &["journal"],
        &["journalism"],
        &["journalist"],
        &["journalistic"],
        &["journalists"],
        &["journalism"],
        &["journalist"],
        &["journalistic"],
        &["journalists"],
        &["journal"],
        &["journals"],
        &["journals"],
        &["journalism"],
        &["journalistic"],
        &["journalistic"],
        &["journalistic"],
        &["journalists"],
        &["journalists"],
        &["journalists"],
        &["journalistic"],
        &["journalistic"],
        &["journalists"],
        &["journals"],
        &["journalism"],
        &["journalism"],
        &["journeyed"],
        &["journeys"],
        &["journeying"],
        &["journalist"],
        &["journalists"],
        &["journey"],
        &["journeyed"],
        &["journeyed", "journeys"],
        &["journeying"],
        &["journeys"],
        &["joystick"],
        &["joystick"],
    ],
    range: 2..=13,
};

static WORD_JK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_JK_CHILDREN),
    value: None,
};

pub static WORD_JK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("d")],
    values: &[&["jdk"]],
    range: 1..=1,
};

static WORD_JI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_JI_CHILDREN),
    value: None,
};

pub static WORD_JI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("on"),
        dictgen::InsensitiveStr::Ascii("st"),
        dictgen::InsensitiveStr::Ascii("tterr"),
        dictgen::InsensitiveStr::Ascii("tterring"),
    ],
    values: &[&["join"], &["gist"], &["jitter"], &["jittering"]],
    range: 2..=8,
};

static WORD_JH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_JH_CHILDREN),
    value: None,
};

pub static WORD_JH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ondoe")],
    values: &[&["johndoe"]],
    range: 5..=5,
};

static WORD_JE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_JE_CHILDREN),
    value: None,
};

pub static WORD_JE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("apardy"),
        dictgen::InsensitiveStr::Ascii("fferry"),
        dictgen::InsensitiveStr::Ascii("fferty"),
        dictgen::InsensitiveStr::Ascii("ffies"),
        dictgen::InsensitiveStr::Ascii("ircho"),
        dictgen::InsensitiveStr::Ascii("kins"),
        dictgen::InsensitiveStr::Ascii("lous"),
        dictgen::InsensitiveStr::Ascii("lousy"),
        dictgen::InsensitiveStr::Ascii("lusey"),
        dictgen::InsensitiveStr::Ascii("nkin"),
        dictgen::InsensitiveStr::Ascii("nkkins"),
        dictgen::InsensitiveStr::Ascii("nkns"),
        dictgen::InsensitiveStr::Ascii("nnigns"),
        dictgen::InsensitiveStr::Ascii("nnins"),
        dictgen::InsensitiveStr::Ascii("opary"),
        dictgen::InsensitiveStr::Ascii("oprady"),
        dictgen::InsensitiveStr::Ascii("poardy"),
        dictgen::InsensitiveStr::Ascii("pordize"),
        dictgen::InsensitiveStr::Ascii("resys"),
        dictgen::InsensitiveStr::Ascii("ricoh"),
        dictgen::InsensitiveStr::Ascii("rsualem"),
        dictgen::InsensitiveStr::Ascii("rsyes"),
        dictgen::InsensitiveStr::Ascii("rusaleum"),
        dictgen::InsensitiveStr::Ascii("rusalm"),
        dictgen::InsensitiveStr::Ascii("ruselam"),
        dictgen::InsensitiveStr::Ascii("ruslaem"),
        dictgen::InsensitiveStr::Ascii("tbrain"),
        dictgen::InsensitiveStr::Ascii("welrey"),
        dictgen::InsensitiveStr::Ascii("werly"),
        dictgen::InsensitiveStr::Ascii("wl"),
        dictgen::InsensitiveStr::Ascii("wllery"),
    ],
    values: &[
        &["jeopardy"],
        &["jeffery"],
        &["jeffery"],
        &["jiffies"],
        &["jericho"],
        &["jenkins"],
        &["jealous"],
        &["jealousy"],
        &["jealousy"],
        &["jenkins"],
        &["jenkins"],
        &["jenkins"],
        &["jennings"],
        &["jennings"],
        &["jeopardy"],
        &["jeopardy"],
        &["jeopardy"],
        &["jeopardize"],
        &["jerseys"],
        &["jericho"],
        &["jerusalem"],
        &["jerseys"],
        &["jerusalem"],
        &["jerusalem"],
        &["jerusalem"],
        &["jerusalem"],
        &["jetbrains"],
        &["jewelry"],
        &["jewelry"],
        &["jew", "jewel"],
        &["jewellery"],
    ],
    range: 2..=8,
};

static WORD_JA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_JA_CHILDREN),
    value: None,
};

pub static WORD_JA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ckonsville"),
        dictgen::InsensitiveStr::Ascii("cksonvile"),
        dictgen::InsensitiveStr::Ascii("cksonvillle"),
        dictgen::InsensitiveStr::Ascii("gaurs"),
        dictgen::InsensitiveStr::Ascii("gid"),
        dictgen::InsensitiveStr::Ascii("guards"),
        dictgen::InsensitiveStr::Ascii("guares"),
        dictgen::InsensitiveStr::Ascii("guras"),
        dictgen::InsensitiveStr::Ascii("gwar"),
        dictgen::InsensitiveStr::Ascii("ilborken"),
        dictgen::InsensitiveStr::Ascii("ilbrake"),
        dictgen::InsensitiveStr::Ascii("ilbrek"),
        dictgen::InsensitiveStr::Ascii("ilbroaken"),
        dictgen::InsensitiveStr::Ascii("ilbrocken"),
        dictgen::InsensitiveStr::Ascii("imacan"),
        dictgen::InsensitiveStr::Ascii("libreak"),
        dictgen::InsensitiveStr::Ascii("libroken"),
        dictgen::InsensitiveStr::Ascii("lusey"),
        dictgen::InsensitiveStr::Ascii("macain"),
        dictgen::InsensitiveStr::Ascii("macia"),
        dictgen::InsensitiveStr::Ascii("maicain"),
        dictgen::InsensitiveStr::Ascii("maicains"),
        dictgen::InsensitiveStr::Ascii("maicaman"),
        dictgen::InsensitiveStr::Ascii("maicia"),
        dictgen::InsensitiveStr::Ascii("maina"),
        dictgen::InsensitiveStr::Ascii("miaca"),
        dictgen::InsensitiveStr::Ascii("miacan"),
        dictgen::InsensitiveStr::Ascii("mine"),
        dictgen::InsensitiveStr::Ascii("msine"),
        dictgen::InsensitiveStr::Ascii("naury"),
        dictgen::InsensitiveStr::Ascii("nuar"),
        dictgen::InsensitiveStr::Ascii("nuaray"),
        dictgen::InsensitiveStr::Ascii("nurary"),
        dictgen::InsensitiveStr::Ascii("nuray"),
        dictgen::InsensitiveStr::Ascii("nury"),
        dictgen::InsensitiveStr::Ascii("panease"),
        dictgen::InsensitiveStr::Ascii("paneese"),
        dictgen::InsensitiveStr::Ascii("panes"),
        dictgen::InsensitiveStr::Ascii("panses"),
        dictgen::InsensitiveStr::Ascii("ques"),
        dictgen::InsensitiveStr::Ascii("ring"),
        dictgen::InsensitiveStr::Ascii("smien"),
        dictgen::InsensitiveStr::Ascii("ugars"),
        dictgen::InsensitiveStr::Ascii("unary"),
        dictgen::InsensitiveStr::Ascii("vacript"),
        dictgen::InsensitiveStr::Ascii("vascipt"),
        dictgen::InsensitiveStr::Ascii("vasciript"),
        dictgen::InsensitiveStr::Ascii("vascritp"),
        dictgen::InsensitiveStr::Ascii("vascropt"),
        dictgen::InsensitiveStr::Ascii("vasript"),
        dictgen::InsensitiveStr::Ascii("vasrript"),
        dictgen::InsensitiveStr::Ascii("ve"),
        dictgen::InsensitiveStr::Ascii("vescript"),
        dictgen::InsensitiveStr::Ascii("vscript"),
        dictgen::InsensitiveStr::Ascii("vsscript"),
    ],
    values: &[
        &["jacksonville"],
        &["jacksonville"],
        &["jacksonville"],
        &["jaguars"],
        &["jagged"],
        &["jaguars"],
        &["jaguars"],
        &["jaguars"],
        &["jaguar"],
        &["jailbroken"],
        &["jailbreak"],
        &["jailbreak"],
        &["jailbroken"],
        &["jailbroken"],
        &["jamaican"],
        &["jailbreak"],
        &["jailbroken"],
        &["jealousy", "jalousie"],
        &["jamaican"],
        &["jamaica"],
        &["jamaican"],
        &["jamaican"],
        &["jamaican"],
        &["jamaica"],
        &["jamaican"],
        &["jamaica"],
        &["jamaican"],
        &["jasmine"],
        &["jasmine"],
        &["january"],
        &["january"],
        &["january"],
        &["january"],
        &["january"],
        &["january"],
        &["japanese"],
        &["japanese"],
        &["japanese"],
        &["japanese"],
        &["jacques"],
        &["jarring"],
        &["jasmine"],
        &["jaguars"],
        &["january"],
        &["javascript"],
        &["javascript"],
        &["javascript"],
        &["javascript"],
        &["javascript"],
        &["javascript"],
        &["javascript"],
        &["java", "have"],
        &["javascript"],
        &["javascript"],
        &["javascript"],
    ],
    range: 2..=11,
};

static WORD_I_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_I_CHILDREN),
    value: None,
};

static WORD_I_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_IA_NODE),
    Some(&WORD_IB_NODE),
    Some(&WORD_IC_NODE),
    Some(&WORD_ID_NODE),
    Some(&WORD_IE_NODE),
    Some(&WORD_IF_NODE),
    Some(&WORD_IG_NODE),
    Some(&WORD_IH_NODE),
    Some(&WORD_II_NODE),
    None,
    None,
    Some(&WORD_IL_NODE),
    Some(&WORD_IM_NODE),
    Some(&WORD_IN_NODE),
    Some(&WORD_IO_NODE),
    Some(&WORD_IP_NODE),
    None,
    Some(&WORD_IR_NODE),
    Some(&WORD_IS_NODE),
    Some(&WORD_IT_NODE),
    Some(&WORD_IU_NODE),
    Some(&WORD_IV_NODE),
    Some(&WORD_IW_NODE),
    None,
    None,
    None,
];

static WORD_IW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_IW_CHILDREN),
    value: None,
};

pub static WORD_IW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ithout"),
        dictgen::InsensitiveStr::Ascii("ll"),
        dictgen::InsensitiveStr::Ascii("th"),
    ],
    values: &[&["without"], &["will"], &["with"]],
    range: 2..=6,
};

static WORD_IV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_IV_CHILDREN),
    value: None,
};

pub static WORD_IV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("alid"),
        dictgen::InsensitiveStr::Ascii("erse"),
        dictgen::InsensitiveStr::Ascii("ersed"),
        dictgen::InsensitiveStr::Ascii("ocation"),
        dictgen::InsensitiveStr::Ascii("oked"),
    ],
    values: &[
        &["invalid"],
        &["diverse", "inverse"],
        &["inverse", "inversed"],
        &["invocation"],
        &["invoked"],
    ],
    range: 4..=7,
};

static WORD_IU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_IU_CHILDREN),
    value: None,
};

pub static WORD_IU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("nior")],
    values: &[&["junior"]],
    range: 4..=4,
};

static WORD_IT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_IT_CHILDREN),
    value: None,
};

static WORD_IT_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_ITA_NODE),
    None,
    None,
    None,
    Some(&WORD_ITE_NODE),
    None,
    None,
    Some(&WORD_ITH_NODE),
    Some(&WORD_ITI_NODE),
    None,
    None,
    None,
    Some(&WORD_ITM_NODE),
    Some(&WORD_ITN_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_ITS_NODE),
    Some(&WORD_ITT_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_ITT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ITT_CHILDREN),
    value: None,
};

pub static WORD_ITT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("erate"),
        dictgen::InsensitiveStr::Ascii("erated"),
        dictgen::InsensitiveStr::Ascii("erates"),
        dictgen::InsensitiveStr::Ascii("erating"),
        dictgen::InsensitiveStr::Ascii("eration"),
        dictgen::InsensitiveStr::Ascii("erations"),
        dictgen::InsensitiveStr::Ascii("erative"),
        dictgen::InsensitiveStr::Ascii("erator"),
        dictgen::InsensitiveStr::Ascii("erators"),
    ],
    values: &[
        &["iterate"],
        &["iterated"],
        &["iterates"],
        &["iterating"],
        &["iteration"],
        &["iterations"],
        &["iterative"],
        &["iterator"],
        &["iterators"],
    ],
    range: 5..=8,
};

static WORD_ITS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ITS_CHILDREN),
    value: None,
};

pub static WORD_ITS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ef"),
        dictgen::InsensitiveStr::Ascii("el"),
        dictgen::InsensitiveStr::Ascii("elfs"),
        dictgen::InsensitiveStr::Ascii("elt"),
        dictgen::InsensitiveStr::Ascii("elv"),
        dictgen::InsensitiveStr::Ascii("ems"),
        dictgen::InsensitiveStr::Ascii("lef"),
        dictgen::InsensitiveStr::Ascii("lev"),
        dictgen::InsensitiveStr::Ascii("self"),
    ],
    values: &[
        &["itself"],
        &["itself"],
        &["itself"],
        &["itself"],
        &["itself"],
        &["items"],
        &["itself"],
        &["itself"],
        &["itself"],
    ],
    range: 2..=4,
};

static WORD_ITN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ITN_CHILDREN),
    value: None,
};

pub static WORD_ITN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("erest"),
        dictgen::InsensitiveStr::Ascii("erface"),
        dictgen::InsensitiveStr::Ascii("erfaces"),
        dictgen::InsensitiveStr::Ascii("ernal"),
        dictgen::InsensitiveStr::Ascii("erprelation"),
        dictgen::InsensitiveStr::Ascii("erpret"),
        dictgen::InsensitiveStr::Ascii("erpretation"),
        dictgen::InsensitiveStr::Ascii("erpretaton"),
        dictgen::InsensitiveStr::Ascii("erpreted"),
        dictgen::InsensitiveStr::Ascii("erpreter"),
        dictgen::InsensitiveStr::Ascii("erpreting"),
        dictgen::InsensitiveStr::Ascii("erprets"),
        dictgen::InsensitiveStr::Ascii("ervals"),
        dictgen::InsensitiveStr::Ascii("roduced"),
    ],
    values: &[
        &["interest"],
        &["interface"],
        &["interfaces"],
        &["internal"],
        &["interpretation"],
        &["interpret"],
        &["interpretation"],
        &["interpretation"],
        &["interpreted"],
        &["interpreter"],
        &["interpreting"],
        &["interprets"],
        &["intervals"],
        &["introduced"],
    ],
    range: 5..=11,
};

static WORD_ITM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ITM_CHILDREN),
    value: None,
};

pub static WORD_ITM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("es")],
    values: &[&["items", "times"]],
    range: 2..=2,
};

static WORD_ITI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ITI_CHILDREN),
    value: None,
};

pub static WORD_ITI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("alise"),
        dictgen::InsensitiveStr::Ascii("alised"),
        dictgen::InsensitiveStr::Ascii("alises"),
        dictgen::InsensitiveStr::Ascii("alising"),
        dictgen::InsensitiveStr::Ascii("alize"),
        dictgen::InsensitiveStr::Ascii("alized"),
        dictgen::InsensitiveStr::Ascii("alizes"),
        dictgen::InsensitiveStr::Ascii("alizing"),
    ],
    values: &[
        &["initialise"],
        &["initialised"],
        &["initialises"],
        &["initialising"],
        &["initialize"],
        &["initialized"],
        &["initializes"],
        &["initializing"],
    ],
    range: 5..=7,
};

static WORD_ITH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ITH_CHILDREN),
    value: None,
};

pub static WORD_ITH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eir"),
        dictgen::InsensitiveStr::Ascii("eirs"),
    ],
    values: &[&["their"], &["theirs"]],
    range: 3..=4,
};

static WORD_ITE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ITE_CHILDREN),
    value: None,
};

pub static WORD_ITE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("artor"),
        dictgen::InsensitiveStr::Ascii("ator"),
        dictgen::InsensitiveStr::Ascii("ger"),
        dictgen::InsensitiveStr::Ascii("gral"),
        dictgen::InsensitiveStr::Ascii("grals"),
        dictgen::InsensitiveStr::Ascii("n"),
        dictgen::InsensitiveStr::Ascii("ns"),
        dictgen::InsensitiveStr::Ascii("ntion"),
        dictgen::InsensitiveStr::Ascii("ntional"),
        dictgen::InsensitiveStr::Ascii("ntionally"),
        dictgen::InsensitiveStr::Ascii("ntionaly"),
        dictgen::InsensitiveStr::Ascii("ract"),
        dictgen::InsensitiveStr::Ascii("raction"),
        dictgen::InsensitiveStr::Ascii("ractions"),
        dictgen::InsensitiveStr::Ascii("raion"),
        dictgen::InsensitiveStr::Ascii("raions"),
        dictgen::InsensitiveStr::Ascii("ratable"),
        dictgen::InsensitiveStr::Ascii("rater"),
        dictgen::InsensitiveStr::Ascii("raterate"),
        dictgen::InsensitiveStr::Ascii("ratered"),
        dictgen::InsensitiveStr::Ascii("ratior"),
        dictgen::InsensitiveStr::Ascii("ratiors"),
        dictgen::InsensitiveStr::Ascii("ratons"),
        dictgen::InsensitiveStr::Ascii("reate"),
        dictgen::InsensitiveStr::Ascii("reating"),
        dictgen::InsensitiveStr::Ascii("reator"),
        dictgen::InsensitiveStr::Ascii("rface"),
        dictgen::InsensitiveStr::Ascii("rfaces"),
        dictgen::InsensitiveStr::Ascii("rm"),
        dictgen::InsensitiveStr::Ascii("rnations"),
        dictgen::InsensitiveStr::Ascii("rpreter"),
        dictgen::InsensitiveStr::Ascii("rration"),
        dictgen::InsensitiveStr::Ascii("rrations"),
        dictgen::InsensitiveStr::Ascii("rrupt"),
        dictgen::InsensitiveStr::Ascii("rstion"),
        dictgen::InsensitiveStr::Ascii("rstions"),
        dictgen::InsensitiveStr::Ascii("rtation"),
        dictgen::InsensitiveStr::Ascii("self"),
        dictgen::InsensitiveStr::Ascii("sm"),
    ],
    values: &[
        &["iterator"],
        &["iterator"],
        &["integer"],
        &["integral"],
        &["integrals"],
        &["item"],
        &["items"],
        &["intention"],
        &["intentional"],
        &["intentionally"],
        &["intentionally"],
        &["interact"],
        &["interaction", "iteration"],
        &["interactions", "iterations"],
        &["iteration"],
        &["iterations"],
        &["iterable"],
        &["iterator"],
        &["iterate"],
        &["iterated"],
        &["iterator"],
        &["iterators"],
        &["iterations"],
        &["iterate"],
        &["iterating"],
        &["iterator"],
        &["interface"],
        &["interfaces"],
        &["term", "item", "intern"],
        &["iterations"],
        &["interpreter"],
        &["iteration"],
        &["iterations"],
        &["interrupt"],
        &["iteration"],
        &["iterations"],
        &["iteration"],
        &["itself"],
        &["items"],
    ],
    range: 1..=9,
};

static WORD_ITA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ITA_CHILDREN),
    value: None,
};

pub static WORD_ITA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("lains"),
        dictgen::InsensitiveStr::Ascii("lianas"),
        dictgen::InsensitiveStr::Ascii("lianess"),
        dictgen::InsensitiveStr::Ascii("lianos"),
        dictgen::InsensitiveStr::Ascii("lias"),
    ],
    values: &[
        &["italians"],
        &["italians"],
        &["italians"],
        &["italians"],
        &["italians"],
    ],
    range: 4..=7,
};

static WORD_IS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_IS_CHILDREN),
    value: None,
};

static WORD_IS_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_ISA_NODE),
    None,
    Some(&WORD_ISC_NODE),
    Some(&WORD_ISD_NODE),
    Some(&WORD_ISE_NODE),
    None,
    None,
    None,
    Some(&WORD_ISI_NODE),
    None,
    None,
    Some(&WORD_ISL_NODE),
    Some(&WORD_ISM_NODE),
    Some(&WORD_ISN_NODE),
    Some(&WORD_ISO_NODE),
    Some(&WORD_ISP_NODE),
    None,
    Some(&WORD_ISR_NODE),
    Some(&WORD_ISS_NODE),
    Some(&WORD_IST_NODE),
    Some(&WORD_ISU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_ISU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ISU_CHILDREN),
    value: None,
};

pub static WORD_ISU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("es"),
    ],
    values: &[&["issue"], &["issues"]],
    range: 1..=2,
};

static WORD_IST_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_IST_CHILDREN),
    value: Some(&["is", "it", "its", "sit", "list"]),
};

pub static WORD_IST_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("alling"),
        dictgen::InsensitiveStr::Ascii("ambul"),
        dictgen::InsensitiveStr::Ascii("ance"),
        dictgen::InsensitiveStr::Ascii("ead"),
        dictgen::InsensitiveStr::Ascii("ened"),
        dictgen::InsensitiveStr::Ascii("ener"),
        dictgen::InsensitiveStr::Ascii("eners"),
        dictgen::InsensitiveStr::Ascii("ening"),
        dictgen::InsensitiveStr::Ascii("s"),
        dictgen::InsensitiveStr::Ascii("self"),
    ],
    values: &[
        &["installing"],
        &["istanbul"],
        &["instance"],
        &["instead"],
        &["listened"],
        &["listener"],
        &["listeners"],
        &["listening"],
        &["its", "lists"],
        &["itself"],
    ],
    range: 1..=6,
};

static WORD_ISS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ISS_CHILDREN),
    value: None,
};

pub static WORD_ISS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("sue"),
        dictgen::InsensitiveStr::Ascii("sued"),
        dictgen::InsensitiveStr::Ascii("sues"),
        dictgen::InsensitiveStr::Ascii("ueing"),
        dictgen::InsensitiveStr::Ascii("ure"),
        dictgen::InsensitiveStr::Ascii("us"),
    ],
    values: &[
        &["issue"],
        &["issues"],
        &["issue"],
        &["issued"],
        &["issues"],
        &["issuing"],
        &["issue"],
        &["issues"],
    ],
    range: 1..=5,
};

static WORD_ISR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ISR_CHILDREN),
    value: None,
};

pub static WORD_ISR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aeliens"),
        dictgen::InsensitiveStr::Ascii("aelies"),
        dictgen::InsensitiveStr::Ascii("aelitas"),
        dictgen::InsensitiveStr::Ascii("aelits"),
        dictgen::InsensitiveStr::Ascii("aelli"),
        dictgen::InsensitiveStr::Ascii("alei"),
        dictgen::InsensitiveStr::Ascii("aleis"),
        dictgen::InsensitiveStr::Ascii("alies"),
        dictgen::InsensitiveStr::Ascii("eali"),
        dictgen::InsensitiveStr::Ascii("ealis"),
    ],
    values: &[
        &["israelis"],
        &["israelis"],
        &["israelis"],
        &["israelis"],
        &["israeli"],
        &["israeli"],
        &["israelis"],
        &["israelis"],
        &["israeli"],
        &["israelis"],
    ],
    range: 4..=7,
};

static WORD_ISP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ISP_CHILDREN),
    value: None,
};

pub static WORD_ISP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("atches"),
        dictgen::InsensitiveStr::Ascii("lay"),
    ],
    values: &[&["dispatches"], &["display"]],
    range: 3..=6,
};

static WORD_ISO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ISO_CHILDREN),
    value: None,
};

pub static WORD_ISO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("latie"),
        dictgen::InsensitiveStr::Ascii("trophically"),
    ],
    values: &[&["isolate"], &["isotropically"]],
    range: 5..=11,
};

static WORD_ISN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ISN_CHILDREN),
    value: None,
};

pub static WORD_ISN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("b"),
        dictgen::InsensitiveStr::Ascii("piron"),
        dictgen::InsensitiveStr::Ascii("talation"),
        dictgen::InsensitiveStr::Ascii("talations"),
        dictgen::InsensitiveStr::Ascii("tall"),
        dictgen::InsensitiveStr::Ascii("tallation"),
        dictgen::InsensitiveStr::Ascii("tallations"),
        dictgen::InsensitiveStr::Ascii("talled"),
        dictgen::InsensitiveStr::Ascii("taller"),
        dictgen::InsensitiveStr::Ascii("talling"),
        dictgen::InsensitiveStr::Ascii("talls"),
        dictgen::InsensitiveStr::Ascii("tance"),
        dictgen::InsensitiveStr::Ascii("tances"),
        dictgen::InsensitiveStr::Ascii("tantly"),
        dictgen::InsensitiveStr::Ascii("tead"),
        dictgen::InsensitiveStr::Ascii("tructed"),
        dictgen::InsensitiveStr::Ascii("trument"),
        dictgen::InsensitiveStr::Ascii("trumental"),
        dictgen::InsensitiveStr::Ascii("truments"),
    ],
    values: &[
        &["isbn"],
        &["inspiron"],
        &["installation"],
        &["installations"],
        &["install"],
        &["installation"],
        &["installations"],
        &["installed"],
        &["installer"],
        &["installing"],
        &["installs"],
        &["instance"],
        &["instances"],
        &["instantly"],
        &["instead"],
        &["instructed"],
        &["instrument"],
        &["instrumental"],
        &["instruments"],
    ],
    range: 1..=10,
};

static WORD_ISM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ISM_CHILDREN),
    value: None,
};

pub static WORD_ISM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("alist"),
        dictgen::InsensitiveStr::Ascii("as"),
    ],
    values: &[&["islamist"], &["isthmus"]],
    range: 2..=5,
};

static WORD_ISL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ISL_CHILDREN),
    value: None,
};

pub static WORD_ISL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("amisist"),
        dictgen::InsensitiveStr::Ascii("amisists"),
        dictgen::InsensitiveStr::Ascii("amiskt"),
        dictgen::InsensitiveStr::Ascii("amistas"),
        dictgen::InsensitiveStr::Ascii("amisters"),
        dictgen::InsensitiveStr::Ascii("amistisk"),
        dictgen::InsensitiveStr::Ascii("amit"),
        dictgen::InsensitiveStr::Ascii("amits"),
        dictgen::InsensitiveStr::Ascii("amsit"),
        dictgen::InsensitiveStr::Ascii("amsits"),
        dictgen::InsensitiveStr::Ascii("andes"),
        dictgen::InsensitiveStr::Ascii("maic"),
        dictgen::InsensitiveStr::Ascii("maists"),
        dictgen::InsensitiveStr::Ascii("oate"),
        dictgen::InsensitiveStr::Ascii("oation"),
    ],
    values: &[
        &["islamist"],
        &["islamists"],
        &["islamist"],
        &["islamists"],
        &["islamists"],
        &["islamists"],
        &["islamist"],
        &["islamist"],
        &["islamist"],
        &["islamists"],
        &["islanders"],
        &["islamic"],
        &["islamists"],
        &["isolate"],
        &["isolation"],
    ],
    range: 4..=8,
};

static WORD_ISI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ISI_CHILDREN),
    value: None,
};

pub static WORD_ISI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("milar")],
    values: &[&["similar"]],
    range: 5..=5,
};

static WORD_ISE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ISE_CHILDREN),
    value: None,
};

pub static WORD_ISE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("lf"),
        dictgen::InsensitiveStr::Ascii("lfe"),
        dictgen::InsensitiveStr::Ascii("rting"),
    ],
    values: &[&["itself"], &["itself"], &["inserting"]],
    range: 2..=5,
};

static WORD_ISD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ISD_CHILDREN),
    value: None,
};

pub static WORD_ISD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("efinitely")],
    values: &[&["indefinitely"]],
    range: 9..=9,
};

static WORD_ISC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ISC_CHILDREN),
    value: None,
};

pub static WORD_ISC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("onnection"),
        dictgen::InsensitiveStr::Ascii("rated"),
    ],
    values: &[&["isconnected"], &["iscreated"]],
    range: 5..=9,
};

static WORD_ISA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ISA_CHILDREN),
    value: None,
};

pub static WORD_ISA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("lha"),
        dictgen::InsensitiveStr::Ascii("lmic"),
        dictgen::InsensitiveStr::Ascii("lmist"),
        dictgen::InsensitiveStr::Ascii("lmists"),
        dictgen::InsensitiveStr::Ascii("lnders"),
        dictgen::InsensitiveStr::Ascii("reli"),
        dictgen::InsensitiveStr::Ascii("relis"),
    ],
    values: &[
        &["isalpha"],
        &["islamic"],
        &["islamist"],
        &["islamists"],
        &["islanders"],
        &["israeli"],
        &["israelis"],
    ],
    range: 3..=6,
};

static WORD_IR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_IR_CHILDREN),
    value: None,
};

static WORD_IR_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_IRA_NODE),
    None,
    None,
    None,
    Some(&WORD_IRE_NODE),
    None,
    None,
    None,
    Some(&WORD_IRI_NODE),
    None,
    None,
    Some(&WORD_IRL_NODE),
    None,
    None,
    Some(&WORD_IRO_NODE),
    None,
    None,
    Some(&WORD_IRR_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_IRR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_IRR_CHILDREN),
    value: None,
};

pub static WORD_IRR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("acional"),
        dictgen::InsensitiveStr::Ascii("adate"),
        dictgen::InsensitiveStr::Ascii("adated"),
        dictgen::InsensitiveStr::Ascii("adates"),
        dictgen::InsensitiveStr::Ascii("adating"),
        dictgen::InsensitiveStr::Ascii("adation"),
        dictgen::InsensitiveStr::Ascii("aditate"),
        dictgen::InsensitiveStr::Ascii("aditated"),
        dictgen::InsensitiveStr::Ascii("aditates"),
        dictgen::InsensitiveStr::Ascii("aditating"),
        dictgen::InsensitiveStr::Ascii("ationably"),
        dictgen::InsensitiveStr::Ascii("ationallity"),
        dictgen::InsensitiveStr::Ascii("ationallly"),
        dictgen::InsensitiveStr::Ascii("ationaly"),
        dictgen::InsensitiveStr::Ascii("ationatly"),
        dictgen::InsensitiveStr::Ascii("ationel"),
        dictgen::InsensitiveStr::Ascii("ationella"),
        dictgen::InsensitiveStr::Ascii("ationnal"),
        dictgen::InsensitiveStr::Ascii("egularties"),
        dictgen::InsensitiveStr::Ascii("egulier"),
        dictgen::InsensitiveStr::Ascii("egulierties"),
        dictgen::InsensitiveStr::Ascii("elavant"),
        dictgen::InsensitiveStr::Ascii("elavent"),
        dictgen::InsensitiveStr::Ascii("elevent"),
        dictgen::InsensitiveStr::Ascii("elivant"),
        dictgen::InsensitiveStr::Ascii("elivent"),
        dictgen::InsensitiveStr::Ascii("elvant"),
        dictgen::InsensitiveStr::Ascii("eplacable"),
        dictgen::InsensitiveStr::Ascii("eplacalbe"),
        dictgen::InsensitiveStr::Ascii("eproducable"),
        dictgen::InsensitiveStr::Ascii("esepective"),
        dictgen::InsensitiveStr::Ascii("esistable"),
        dictgen::InsensitiveStr::Ascii("esistably"),
        dictgen::InsensitiveStr::Ascii("especitve"),
        dictgen::InsensitiveStr::Ascii("esponcible"),
        dictgen::InsensitiveStr::Ascii("esponisble"),
        dictgen::InsensitiveStr::Ascii("esponsable"),
        dictgen::InsensitiveStr::Ascii("esponsbile"),
        dictgen::InsensitiveStr::Ascii("esponsble"),
        dictgen::InsensitiveStr::Ascii("esponsibe"),
        dictgen::InsensitiveStr::Ascii("esponsibile"),
        dictgen::InsensitiveStr::Ascii("evelant"),
        dictgen::InsensitiveStr::Ascii("everant"),
        dictgen::InsensitiveStr::Ascii("everisble"),
        dictgen::InsensitiveStr::Ascii("eversable"),
        dictgen::InsensitiveStr::Ascii("eversebly"),
        dictgen::InsensitiveStr::Ascii("eversiable"),
        dictgen::InsensitiveStr::Ascii("eversibel"),
        dictgen::InsensitiveStr::Ascii("eversibelt"),
        dictgen::InsensitiveStr::Ascii("eversibile"),
        dictgen::InsensitiveStr::Ascii("evirsible"),
        dictgen::InsensitiveStr::Ascii("idation"),
        dictgen::InsensitiveStr::Ascii("iration"),
        dictgen::InsensitiveStr::Ascii("ispective"),
        dictgen::InsensitiveStr::Ascii("isponsible"),
        dictgen::InsensitiveStr::Ascii("itacion"),
        dictgen::InsensitiveStr::Ascii("itatie"),
        dictgen::InsensitiveStr::Ascii("itaties"),
        dictgen::InsensitiveStr::Ascii("itatin"),
        dictgen::InsensitiveStr::Ascii("itato"),
        dictgen::InsensitiveStr::Ascii("iversible"),
    ],
    values: &[
        &["irrational"],
        &["irradiate"],
        &["irradiated"],
        &["irradiates"],
        &["irradiating"],
        &["irradiation"],
        &["irradiate"],
        &["irradiated"],
        &["irradiates"],
        &["irradiating"],
        &["irrationally"],
        &["irrationally"],
        &["irrationally"],
        &["irrationally"],
        &["irrationally"],
        &["irrational"],
        &["irrational"],
        &["irrational"],
        &["irregularities"],
        &["irregular"],
        &["irregularities"],
        &["irrelevant"],
        &["irrelevant"],
        &["irrelevant"],
        &["irrelevant"],
        &["irrelevant"],
        &["irrelevant"],
        &["irreplaceable"],
        &["irreplaceable"],
        &["irreproducible"],
        &["irrespective"],
        &["irresistible"],
        &["irresistibly"],
        &["irrespective"],
        &["irresponsible"],
        &["irresponsible"],
        &["irresponsible"],
        &["irresponsible"],
        &["irresponsible"],
        &["irresponsible"],
        &["irresponsible"],
        &["irrelevant"],
        &["irrelevant"],
        &["irreversible"],
        &["irreversible"],
        &["irreversible"],
        &["irreversible"],
        &["irreversible"],
        &["irreversible"],
        &["irreversible"],
        &["irreversible"],
        &["irritation"],
        &["irritation"],
        &["irrespective"],
        &["irresponsible"],
        &["irritation"],
        &["irritate"],
        &["irritate"],
        &["irritation"],
        &["irritation"],
        &["irreversible"],
    ],
    range: 5..=11,
};

static WORD_IRO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_IRO_CHILDREN),
    value: None,
};

pub static WORD_IRO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("namn"),
        dictgen::InsensitiveStr::Ascii("ncially"),
        dictgen::InsensitiveStr::Ascii("nicaly"),
        dictgen::InsensitiveStr::Ascii("nicly"),
    ],
    values: &[
        &["ironman"],
        &["ironically"],
        &["ironically"],
        &["ironically"],
    ],
    range: 4..=7,
};

static WORD_IRL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_IRL_CHILDREN),
    value: None,
};

pub static WORD_IRL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("eand")],
    values: &[&["ireland"]],
    range: 4..=4,
};

static WORD_IRI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_IRI_CHILDREN),
    value: None,
};

pub static WORD_IRI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("table"),
        dictgen::InsensitiveStr::Ascii("tate"),
        dictgen::InsensitiveStr::Ascii("tated"),
        dictgen::InsensitiveStr::Ascii("tating"),
    ],
    values: &[
        &["irritable"],
        &["irritate"],
        &["irritated"],
        &["irritating"],
    ],
    range: 4..=6,
};

static WORD_IRE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_IRE_CHILDREN),
    value: None,
};

pub static WORD_IRE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("elevant"),
        dictgen::InsensitiveStr::Ascii("levent"),
        dictgen::InsensitiveStr::Ascii("sistable"),
        dictgen::InsensitiveStr::Ascii("sistably"),
        dictgen::InsensitiveStr::Ascii("sistible"),
        dictgen::InsensitiveStr::Ascii("sistibly"),
    ],
    values: &[
        &["irrelevant"],
        &["irrelevant"],
        &["irresistible"],
        &["irresistibly"],
        &["irresistible"],
        &["irresistibly"],
    ],
    range: 6..=8,
};

static WORD_IRA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_IRA_CHILDREN),
    value: None,
};

pub static WORD_IRA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("nain"),
        dictgen::InsensitiveStr::Ascii("nains"),
        dictgen::InsensitiveStr::Ascii("nianos"),
        dictgen::InsensitiveStr::Ascii("nias"),
        dictgen::InsensitiveStr::Ascii("nina"),
        dictgen::InsensitiveStr::Ascii("ninas"),
    ],
    values: &[
        &["iranian"],
        &["iranians"],
        &["iranians"],
        &["iranians"],
        &["iranian"],
        &["iranians"],
    ],
    range: 4..=6,
};

static WORD_IP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_IP_CHILDREN),
    value: None,
};

pub static WORD_IP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("lementation"),
        dictgen::InsensitiveStr::Ascii("mrovement"),
        dictgen::InsensitiveStr::Ascii("mrovements"),
        dictgen::InsensitiveStr::Ascii("ubrofen"),
        dictgen::InsensitiveStr::Ascii("ut"),
    ],
    values: &[
        &["implementation"],
        &["improvement"],
        &["improvements"],
        &["ibuprofen"],
        &["input"],
    ],
    range: 2..=11,
};

static WORD_IO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_IO_CHILDREN),
    value: None,
};

pub static WORD_IO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("clt"),
        dictgen::InsensitiveStr::Ascii("maped"),
        dictgen::InsensitiveStr::Ascii("nde"),
        dictgen::InsensitiveStr::Ascii("rnman"),
        dictgen::InsensitiveStr::Ascii("und"),
    ],
    values: &[
        &["ioctl"],
        &["iomapped"],
        &["inode"],
        &["ironman"],
        &["round", "wound"],
    ],
    range: 3..=5,
};

static WORD_IN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_IN_CHILDREN),
    value: None,
};

static WORD_IN_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_INA_NODE),
    Some(&WORD_INB_NODE),
    Some(&WORD_INC_NODE),
    Some(&WORD_IND_NODE),
    Some(&WORD_INE_NODE),
    Some(&WORD_INF_NODE),
    Some(&WORD_ING_NODE),
    Some(&WORD_INH_NODE),
    Some(&WORD_INI_NODE),
    Some(&WORD_INJ_NODE),
    Some(&WORD_INK_NODE),
    Some(&WORD_INL_NODE),
    Some(&WORD_INM_NODE),
    Some(&WORD_INN_NODE),
    Some(&WORD_INO_NODE),
    Some(&WORD_INP_NODE),
    Some(&WORD_INQ_NODE),
    Some(&WORD_INR_NODE),
    Some(&WORD_INS_NODE),
    Some(&WORD_INT_NODE),
    Some(&WORD_INU_NODE),
    Some(&WORD_INV_NODE),
    None,
    None,
    None,
    None,
];

static WORD_INV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_INV_CHILDREN),
    value: None,
};

static WORD_INV_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_INVA_NODE),
    None,
    None,
    None,
    Some(&WORD_INVE_NODE),
    None,
    None,
    None,
    Some(&WORD_INVI_NODE),
    None,
    None,
    Some(&WORD_INVL_NODE),
    None,
    None,
    Some(&WORD_INVO_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_INVU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_INVU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INVU_CHILDREN),
    value: None,
};

pub static WORD_INVU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("lenrable"),
        dictgen::InsensitiveStr::Ascii("lernable"),
        dictgen::InsensitiveStr::Ascii("lnarable"),
        dictgen::InsensitiveStr::Ascii("lnerabe"),
        dictgen::InsensitiveStr::Ascii("lnerabile"),
        dictgen::InsensitiveStr::Ascii("lnerbale"),
        dictgen::InsensitiveStr::Ascii("lnerble"),
        dictgen::InsensitiveStr::Ascii("lnurable"),
        dictgen::InsensitiveStr::Ascii("lverable"),
        dictgen::InsensitiveStr::Ascii("nlerable"),
        dictgen::InsensitiveStr::Ascii("rnerable"),
    ],
    values: &[
        &["invulnerable"],
        &["invulnerable"],
        &["invulnerable"],
        &["invulnerable"],
        &["invulnerable"],
        &["invulnerable"],
        &["invulnerable"],
        &["invulnerable"],
        &["invulnerable"],
        &["invulnerable"],
        &["invulnerable"],
    ],
    range: 7..=9,
};

static WORD_INVO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INVO_CHILDREN),
    value: None,
};

pub static WORD_INVO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("caition"),
        dictgen::InsensitiveStr::Ascii("ekr"),
        dictgen::InsensitiveStr::Ascii("kable"),
        dictgen::InsensitiveStr::Ascii("kation"),
        dictgen::InsensitiveStr::Ascii("kations"),
        dictgen::InsensitiveStr::Ascii("kee"),
        dictgen::InsensitiveStr::Ascii("kve"),
        dictgen::InsensitiveStr::Ascii("kved"),
        dictgen::InsensitiveStr::Ascii("kves"),
        dictgen::InsensitiveStr::Ascii("kving"),
        dictgen::InsensitiveStr::Ascii("lantary"),
        dictgen::InsensitiveStr::Ascii("led"),
        dictgen::InsensitiveStr::Ascii("lentary"),
        dictgen::InsensitiveStr::Ascii("lintary"),
        dictgen::InsensitiveStr::Ascii("lnerable"),
        dictgen::InsensitiveStr::Ascii("lontary"),
        dictgen::InsensitiveStr::Ascii("ltue"),
        dictgen::InsensitiveStr::Ascii("ltued"),
        dictgen::InsensitiveStr::Ascii("ltues"),
        dictgen::InsensitiveStr::Ascii("lunary"),
        dictgen::InsensitiveStr::Ascii("lunatry"),
        dictgen::InsensitiveStr::Ascii("luntairy"),
        dictgen::InsensitiveStr::Ascii("luntarely"),
        dictgen::InsensitiveStr::Ascii("luntarity"),
        dictgen::InsensitiveStr::Ascii("luntarly"),
        dictgen::InsensitiveStr::Ascii("lvment"),
        dictgen::InsensitiveStr::Ascii("nvenient"),
        dictgen::InsensitiveStr::Ascii("vle"),
        dictgen::InsensitiveStr::Ascii("vled"),
        dictgen::InsensitiveStr::Ascii("vles"),
        dictgen::InsensitiveStr::Ascii("vling"),
    ],
    values: &[
        &["invocation"],
        &["invoker"],
        &["invocable"],
        &["invocation"],
        &["invocations"],
        &["invoked", "invoke"],
        &["invoke"],
        &["invoked"],
        &["invokes"],
        &["invoking"],
        &["involuntary"],
        &["involved"],
        &["involuntary"],
        &["involuntary"],
        &["invulnerable"],
        &["involuntary"],
        &["involute"],
        &["involuted"],
        &["involutes"],
        &["involuntary"],
        &["involuntary"],
        &["involuntary"],
        &["involuntary"],
        &["involuntary"],
        &["involuntary"],
        &["involvement"],
        &["inconvenient"],
        &["involve"],
        &["involved"],
        &["involves"],
        &["involving"],
    ],
    range: 3..=9,
};

static WORD_INVL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INVL_CHILDREN),
    value: None,
};

pub static WORD_INVL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aid"),
        dictgen::InsensitiveStr::Ascii("id"),
        dictgen::InsensitiveStr::Ascii("isible"),
        dictgen::InsensitiveStr::Ascii("ove"),
        dictgen::InsensitiveStr::Ascii("oved"),
        dictgen::InsensitiveStr::Ascii("oves"),
        dictgen::InsensitiveStr::Ascii("oving"),
        dictgen::InsensitiveStr::Ascii("unerable"),
    ],
    values: &[
        &["invalid"],
        &["invalid"],
        &["invisible"],
        &["involve"],
        &["involved"],
        &["involves"],
        &["involving"],
        &["invulnerable"],
    ],
    range: 2..=8,
};

static WORD_INVI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INVI_CHILDREN),
    value: None,
};

pub static WORD_INVI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ation"),
        dictgen::InsensitiveStr::Ascii("cibility"),
        dictgen::InsensitiveStr::Ascii("cinble"),
        dictgen::InsensitiveStr::Ascii("didual"),
        dictgen::InsensitiveStr::Ascii("didually"),
        dictgen::InsensitiveStr::Ascii("divual"),
        dictgen::InsensitiveStr::Ascii("dual"),
        dictgen::InsensitiveStr::Ascii("dually"),
        dictgen::InsensitiveStr::Ascii("ncable"),
        dictgen::InsensitiveStr::Ascii("nceble"),
        dictgen::InsensitiveStr::Ascii("ncibe"),
        dictgen::InsensitiveStr::Ascii("ncibile"),
        dictgen::InsensitiveStr::Ascii("ncil"),
        dictgen::InsensitiveStr::Ascii("ncinble"),
        dictgen::InsensitiveStr::Ascii("nicble"),
        dictgen::InsensitiveStr::Ascii("nsible"),
        dictgen::InsensitiveStr::Ascii("nvible"),
        dictgen::InsensitiveStr::Ascii("rant"),
        dictgen::InsensitiveStr::Ascii("rants"),
        dictgen::InsensitiveStr::Ascii("sble"),
        dictgen::InsensitiveStr::Ascii("sblity"),
        dictgen::InsensitiveStr::Ascii("siable"),
        dictgen::InsensitiveStr::Ascii("sibiity"),
        dictgen::InsensitiveStr::Ascii("sibile"),
        dictgen::InsensitiveStr::Ascii("sibiliy"),
        dictgen::InsensitiveStr::Ascii("sibillity"),
        dictgen::InsensitiveStr::Ascii("sibiltiy"),
        dictgen::InsensitiveStr::Ascii("sibily"),
        dictgen::InsensitiveStr::Ascii("silibity"),
        dictgen::InsensitiveStr::Ascii("sivble"),
        dictgen::InsensitiveStr::Ascii("sivility"),
        dictgen::InsensitiveStr::Ascii("tacion"),
        dictgen::InsensitiveStr::Ascii("taion"),
        dictgen::InsensitiveStr::Ascii("tating"),
        dictgen::InsensitiveStr::Ascii("tato"),
    ],
    values: &[
        &["invitation"],
        &["invisibility"],
        &["invincible"],
        &["individual"],
        &["individually"],
        &["individual"],
        &["individual"],
        &["individually"],
        &["invincible"],
        &["invincible"],
        &["invincible"],
        &["invincible"],
        &["invincible"],
        &["invincible"],
        &["invincible"],
        &["invincible"],
        &["invincible"],
        &["invariant"],
        &["invariants"],
        &["invisible"],
        &["invisibility"],
        &["invisible"],
        &["invisibility"],
        &["invisible"],
        &["invisibility"],
        &["invisibility"],
        &["invisibility"],
        &["invisibility"],
        &["invisibility"],
        &["invisible"],
        &["invisibility"],
        &["invitation"],
        &["invitation"],
        &["invitation"],
        &["invitation"],
    ],
    range: 4..=9,
};

static WORD_INVE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_INVE_CHILDREN),
    value: None,
};

static WORD_INVE_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_INVEI_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_INVEN_NODE),
    None,
    None,
    None,
    Some(&WORD_INVER_NODE),
    Some(&WORD_INVES_NODE),
    Some(&WORD_INVET_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_INVET_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INVET_CHILDREN),
    value: None,
};

pub static WORD_INVET_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("ory"),
    ],
    values: &[&["inverting"], &["inventory"]],
    range: 3..=3,
};

static WORD_INVES_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INVES_CHILDREN),
    value: None,
};

pub static WORD_INVES_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("itgate"),
        dictgen::InsensitiveStr::Ascii("itgated"),
        dictgen::InsensitiveStr::Ascii("itgating"),
        dictgen::InsensitiveStr::Ascii("itgation"),
        dictgen::InsensitiveStr::Ascii("itgations"),
        dictgen::InsensitiveStr::Ascii("itgative"),
        dictgen::InsensitiveStr::Ascii("itgators"),
        dictgen::InsensitiveStr::Ascii("re"),
        dictgen::InsensitiveStr::Ascii("rse"),
        dictgen::InsensitiveStr::Ascii("tagate"),
        dictgen::InsensitiveStr::Ascii("tagated"),
        dictgen::InsensitiveStr::Ascii("tagator"),
        dictgen::InsensitiveStr::Ascii("tagators"),
        dictgen::InsensitiveStr::Ascii("tegated"),
        dictgen::InsensitiveStr::Ascii("tegating"),
        dictgen::InsensitiveStr::Ascii("tegator"),
        dictgen::InsensitiveStr::Ascii("tegators"),
        dictgen::InsensitiveStr::Ascii("temnt"),
        dictgen::InsensitiveStr::Ascii("tiage"),
        dictgen::InsensitiveStr::Ascii("tiagte"),
        dictgen::InsensitiveStr::Ascii("tiagtion"),
        dictgen::InsensitiveStr::Ascii("tiagtions"),
        dictgen::InsensitiveStr::Ascii("tiagtive"),
        dictgen::InsensitiveStr::Ascii("tigacion"),
        dictgen::InsensitiveStr::Ascii("tigaiton"),
        dictgen::InsensitiveStr::Ascii("tigare"),
        dictgen::InsensitiveStr::Ascii("tigaron"),
        dictgen::InsensitiveStr::Ascii("tigater"),
        dictgen::InsensitiveStr::Ascii("tigaters"),
        dictgen::InsensitiveStr::Ascii("tigatie"),
        dictgen::InsensitiveStr::Ascii("tigatin"),
        dictgen::InsensitiveStr::Ascii("tigatio"),
        dictgen::InsensitiveStr::Ascii("tigationes"),
        dictgen::InsensitiveStr::Ascii("tigatiors"),
        dictgen::InsensitiveStr::Ascii("tigativo"),
        dictgen::InsensitiveStr::Ascii("tigativos"),
        dictgen::InsensitiveStr::Ascii("tigaton"),
        dictgen::InsensitiveStr::Ascii("tigatons"),
        dictgen::InsensitiveStr::Ascii("tige"),
        dictgen::InsensitiveStr::Ascii("tigsting"),
        dictgen::InsensitiveStr::Ascii("tigstion"),
        dictgen::InsensitiveStr::Ascii("tigstions"),
        dictgen::InsensitiveStr::Ascii("tingate"),
        dictgen::InsensitiveStr::Ascii("tions"),
        dictgen::InsensitiveStr::Ascii("tirat"),
        dictgen::InsensitiveStr::Ascii("tmens"),
        dictgen::InsensitiveStr::Ascii("tmet"),
        dictgen::InsensitiveStr::Ascii("togator"),
        dictgen::InsensitiveStr::Ascii("togators"),
    ],
    values: &[
        &["investigate"],
        &["investigated"],
        &["investigating"],
        &["investigation"],
        &["investigations"],
        &["investigative"],
        &["investigators"],
        &["inverse"],
        &["inverse"],
        &["investigate"],
        &["investigated"],
        &["investigator"],
        &["investigators"],
        &["investigated"],
        &["investigating"],
        &["investigator"],
        &["investigators"],
        &["investments"],
        &["investigate"],
        &["investigate"],
        &["investigation"],
        &["investigations"],
        &["investigative"],
        &["investigation"],
        &["investigations"],
        &["investigate"],
        &["investigator"],
        &["investigator"],
        &["investigators"],
        &["investigative"],
        &["investigation"],
        &["investigator"],
        &["investigations"],
        &["investigations"],
        &["investigation"],
        &["investigations"],
        &["investigation"],
        &["investigations"],
        &["investigate"],
        &["investigating"],
        &["investigations"],
        &["investigations"],
        &["investigate"],
        &["inventions"],
        &["investigator"],
        &["investments"],
        &["investments"],
        &["investigator"],
        &["investigators"],
    ],
    range: 2..=10,
};

static WORD_INVER_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INVER_CHILDREN),
    value: None,
};

pub static WORD_INVER_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("al"),
        dictgen::InsensitiveStr::Ascii("als"),
        dictgen::InsensitiveStr::Ascii("ded"),
        dictgen::InsensitiveStr::Ascii("ion"),
        dictgen::InsensitiveStr::Ascii("ions"),
        dictgen::InsensitiveStr::Ascii("s"),
        dictgen::InsensitiveStr::Ascii("tedd"),
        dictgen::InsensitiveStr::Ascii("tendo"),
        dictgen::InsensitiveStr::Ascii("terad"),
        dictgen::InsensitiveStr::Ascii("tes"),
        dictgen::InsensitiveStr::Ascii("tibrates"),
        dictgen::InsensitiveStr::Ascii("tion"),
        dictgen::InsensitiveStr::Ascii("tions"),
        dictgen::InsensitiveStr::Ascii("val"),
        dictgen::InsensitiveStr::Ascii("vention"),
        dictgen::InsensitiveStr::Ascii("yed"),
    ],
    values: &[
        &["interval"],
        &["intervals"],
        &["inverted"],
        &["inversion"],
        &["inversions"],
        &["inverse", "invert"],
        &["inverted"],
        &["inverted"],
        &["inverted"],
        &["inverse"],
        &["invertebrates"],
        &["inversion"],
        &["inventions", "inversions"],
        &["interval"],
        &["intervention"],
        &["inverted"],
    ],
    range: 1..=8,
};

static WORD_INVEN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INVEN_CHILDREN),
    value: None,
};

pub static WORD_INVEN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("sions"),
        dictgen::InsensitiveStr::Ascii("tario"),
        dictgen::InsensitiveStr::Ascii("tarlo"),
        dictgen::InsensitiveStr::Ascii("taron"),
        dictgen::InsensitiveStr::Ascii("ter"),
        dictgen::InsensitiveStr::Ascii("tings"),
        dictgen::InsensitiveStr::Ascii("tiones"),
        dictgen::InsensitiveStr::Ascii("tios"),
        dictgen::InsensitiveStr::Ascii("tivos"),
    ],
    values: &[
        &["inventions"],
        &["inventor"],
        &["inventor"],
        &["inventor"],
        &["inventor"],
        &["inventions"],
        &["inventions"],
        &["inventions"],
        &["inventions"],
    ],
    range: 3..=6,
};

static WORD_INVEI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INVEI_CHILDREN),
    value: None,
};

pub static WORD_INVEI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("table"),
        dictgen::InsensitiveStr::Ascii("tably"),
    ],
    values: &[&["inevitable"], &["inevitably"]],
    range: 5..=5,
};

static WORD_INVA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INVA_CHILDREN),
    value: None,
};

pub static WORD_INVA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("deras"),
        dictgen::InsensitiveStr::Ascii("derats"),
        dictgen::InsensitiveStr::Ascii("id"),
        dictgen::InsensitiveStr::Ascii("ild"),
        dictgen::InsensitiveStr::Ascii("ildate"),
        dictgen::InsensitiveStr::Ascii("ilid"),
        dictgen::InsensitiveStr::Ascii("irably"),
        dictgen::InsensitiveStr::Ascii("laid"),
        dictgen::InsensitiveStr::Ascii("ld"),
        dictgen::InsensitiveStr::Ascii("ldates"),
        dictgen::InsensitiveStr::Ascii("lde"),
        dictgen::InsensitiveStr::Ascii("ldiate"),
        dictgen::InsensitiveStr::Ascii("ldiates"),
        dictgen::InsensitiveStr::Ascii("lidade"),
        dictgen::InsensitiveStr::Ascii("lidades"),
        dictgen::InsensitiveStr::Ascii("lidante"),
        dictgen::InsensitiveStr::Ascii("lidare"),
        dictgen::InsensitiveStr::Ascii("lidas"),
        dictgen::InsensitiveStr::Ascii("lidatiopn"),
        dictgen::InsensitiveStr::Ascii("lide"),
        dictgen::InsensitiveStr::Ascii("lidiate"),
        dictgen::InsensitiveStr::Ascii("lidte"),
        dictgen::InsensitiveStr::Ascii("lidted"),
        dictgen::InsensitiveStr::Ascii("lidtes"),
        dictgen::InsensitiveStr::Ascii("lidting"),
        dictgen::InsensitiveStr::Ascii("lidtion"),
        dictgen::InsensitiveStr::Ascii("lied"),
        dictgen::InsensitiveStr::Ascii("lis"),
        dictgen::InsensitiveStr::Ascii("lubale"),
        dictgen::InsensitiveStr::Ascii("lud"),
        dictgen::InsensitiveStr::Ascii("lueble"),
        dictgen::InsensitiveStr::Ascii("raibly"),
        dictgen::InsensitiveStr::Ascii("riabil"),
        dictgen::InsensitiveStr::Ascii("riabley"),
        dictgen::InsensitiveStr::Ascii("riablly"),
        dictgen::InsensitiveStr::Ascii("ribaly"),
        dictgen::InsensitiveStr::Ascii("rient"),
        dictgen::InsensitiveStr::Ascii("rients"),
        dictgen::InsensitiveStr::Ascii("rinat"),
        dictgen::InsensitiveStr::Ascii("rinats"),
        dictgen::InsensitiveStr::Ascii("ulable"),
    ],
    values: &[
        &["invaders"],
        &["invaders"],
        &["invalid"],
        &["invalid"],
        &["invalidates", "invalidate"],
        &["invalid"],
        &["invariably"],
        &["invalid"],
        &["invalid"],
        &["invalidates"],
        &["invalid"],
        &["invalidates"],
        &["invalidates"],
        &["invalidate"],
        &["invalidates"],
        &["invalidate"],
        &["invalidate"],
        &["invalidates"],
        &["invalidation"],
        &["invalid"],
        &["invalidate"],
        &["invalidate"],
        &["invalidated"],
        &["invalidates"],
        &["invalidating"],
        &["invalidation"],
        &["invalid"],
        &["invalid"],
        &["invaluable"],
        &["invalid"],
        &["invaluable"],
        &["invariably"],
        &["invariably"],
        &["invariably"],
        &["invariably"],
        &["invariably"],
        &["invariant"],
        &["invariants"],
        &["invariant"],
        &["invariants"],
        &["invaluable"],
    ],
    range: 2..=9,
};

static WORD_INU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INU_CHILDREN),
    value: None,
};

pub static WORD_INU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("dstry"),
        dictgen::InsensitiveStr::Ascii("merable"),
        dictgen::InsensitiveStr::Ascii("srgency"),
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("tition"),
        dictgen::InsensitiveStr::Ascii("titive"),
        dictgen::InsensitiveStr::Ascii("titively"),
    ],
    values: &[
        &["industry"],
        &["enumerable", "innumerable"],
        &["insurgency"],
        &["input"],
        &["intuition"],
        &["intuitive"],
        &["intuitively"],
    ],
    range: 1..=8,
};

static WORD_INT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_INT_CHILDREN),
    value: None,
};

static WORD_INT_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_INTA_NODE),
    None,
    None,
    None,
    Some(&WORD_INTE_NODE),
    None,
    Some(&WORD_INTG_NODE),
    None,
    Some(&WORD_INTI_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_INTO_NODE),
    Some(&WORD_INTP_NODE),
    Some(&WORD_INTQ_NODE),
    Some(&WORD_INTR_NODE),
    Some(&WORD_INTS_NODE),
    Some(&WORD_INTT_NODE),
    Some(&WORD_INTU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_INTU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INTU_CHILDREN),
    value: None,
};

pub static WORD_INTU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ative"),
        dictgen::InsensitiveStr::Ascii("atively"),
        dictgen::InsensitiveStr::Ascii("itevely"),
        dictgen::InsensitiveStr::Ascii("itevly"),
        dictgen::InsensitiveStr::Ascii("itivelly"),
        dictgen::InsensitiveStr::Ascii("itivley"),
        dictgen::InsensitiveStr::Ascii("itivly"),
        dictgen::InsensitiveStr::Ascii("itivno"),
        dictgen::InsensitiveStr::Ascii("ituvely"),
        dictgen::InsensitiveStr::Ascii("rpratasion"),
        dictgen::InsensitiveStr::Ascii("rpratation"),
        dictgen::InsensitiveStr::Ascii("rprett"),
        dictgen::InsensitiveStr::Ascii("rrupting"),
        dictgen::InsensitiveStr::Ascii("tive"),
        dictgen::InsensitiveStr::Ascii("tively"),
    ],
    values: &[
        &["intuitive"],
        &["intuitively"],
        &["intuitively"],
        &["intuitively"],
        &["intuitively"],
        &["intuitively"],
        &["intuitively"],
        &["intuition"],
        &["intuitively"],
        &["interpretation"],
        &["interpretation"],
        &["interpret"],
        &["interrupting"],
        &["intuitive"],
        &["intuitively"],
    ],
    range: 4..=10,
};

static WORD_INTT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INTT_CHILDREN),
    value: None,
};

pub static WORD_INTT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("errupt"),
        dictgen::InsensitiveStr::Ascii("erupt"),
        dictgen::InsensitiveStr::Ascii("erupted"),
        dictgen::InsensitiveStr::Ascii("erupting"),
        dictgen::InsensitiveStr::Ascii("erupts"),
    ],
    values: &[
        &["interrupt"],
        &["interrupt"],
        &["interrupted"],
        &["interrupting"],
        &["interrupts"],
    ],
    range: 5..=8,
};

static WORD_INTS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INTS_CHILDREN),
    value: None,
};

pub static WORD_INTS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("all"),
        dictgen::InsensitiveStr::Ascii("alled"),
        dictgen::InsensitiveStr::Ascii("alling"),
        dictgen::InsensitiveStr::Ascii("alls"),
        dictgen::InsensitiveStr::Ascii("rumental"),
        dictgen::InsensitiveStr::Ascii("tead"),
        dictgen::InsensitiveStr::Ascii("tructed"),
        dictgen::InsensitiveStr::Ascii("tructer"),
        dictgen::InsensitiveStr::Ascii("tructing"),
        dictgen::InsensitiveStr::Ascii("truction"),
        dictgen::InsensitiveStr::Ascii("tructional"),
        dictgen::InsensitiveStr::Ascii("tructions"),
        dictgen::InsensitiveStr::Ascii("tructor"),
        dictgen::InsensitiveStr::Ascii("tructs"),
    ],
    values: &[
        &["install"],
        &["installed"],
        &["installing"],
        &["installs"],
        &["instrumental"],
        &["instead"],
        &["instructed"],
        &["instructor"],
        &["instructing"],
        &["instruction"],
        &["instructional"],
        &["instructions"],
        &["instructor"],
        &["instructs"],
    ],
    range: 3..=10,
};

static WORD_INTR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_INTR_CHILDREN),
    value: None,
};

static WORD_INTR_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_INTRA_NODE),
    None,
    None,
    Some(&WORD_INTRD_NODE),
    Some(&WORD_INTRE_NODE),
    None,
    None,
    None,
    Some(&WORD_INTRI_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_INTRO_NODE),
    None,
    None,
    Some(&WORD_INTRR_NODE),
    None,
    None,
    Some(&WORD_INTRU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_INTRU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INTRU_CHILDREN),
    value: None,
};

pub static WORD_INTRU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ction"),
        dictgen::InsensitiveStr::Ascii("ctional"),
        dictgen::InsensitiveStr::Ascii("ctions"),
        dictgen::InsensitiveStr::Ascii("duced"),
        dictgen::InsensitiveStr::Ascii("duces"),
        dictgen::InsensitiveStr::Ascii("ducing"),
        dictgen::InsensitiveStr::Ascii("duction"),
        dictgen::InsensitiveStr::Ascii("ductory"),
        dictgen::InsensitiveStr::Ascii("ige"),
        dictgen::InsensitiveStr::Ascii("iged"),
        dictgen::InsensitiveStr::Ascii("iging"),
        dictgen::InsensitiveStr::Ascii("ment"),
        dictgen::InsensitiveStr::Ascii("mental"),
        dictgen::InsensitiveStr::Ascii("mented"),
        dictgen::InsensitiveStr::Ascii("menting"),
        dictgen::InsensitiveStr::Ascii("ments"),
    ],
    values: &[
        &["instruction"],
        &["instructional"],
        &["instructions"],
        &["introduced"],
        &["introduces"],
        &["introducing"],
        &["introduction"],
        &["introductory"],
        &["intrigue"],
        &["intrigued"],
        &["intriguing"],
        &["instrument"],
        &["instrumental"],
        &["instrumented"],
        &["instrumenting"],
        &["instruments"],
    ],
    range: 3..=7,
};

static WORD_INTRR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INTRR_CHILDREN),
    value: None,
};

pub static WORD_INTRR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("upt"),
        dictgen::InsensitiveStr::Ascii("upted"),
        dictgen::InsensitiveStr::Ascii("upting"),
        dictgen::InsensitiveStr::Ascii("upts"),
    ],
    values: &[
        &["interrupt"],
        &["interrupted"],
        &["interrupting"],
        &["interrupts"],
    ],
    range: 3..=6,
};

static WORD_INTRO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INTRO_CHILDREN),
    value: None,
};

pub static WORD_INTRO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("decks"),
        dictgen::InsensitiveStr::Ascii("diction"),
        dictgen::InsensitiveStr::Ascii("duccion"),
        dictgen::InsensitiveStr::Ascii("duceras"),
        dictgen::InsensitiveStr::Ascii("duceres"),
        dictgen::InsensitiveStr::Ascii("ducinc"),
        dictgen::InsensitiveStr::Ascii("ducion"),
        dictgen::InsensitiveStr::Ascii("duciton"),
        dictgen::InsensitiveStr::Ascii("ductary"),
        dictgen::InsensitiveStr::Ascii("ducted"),
        dictgen::InsensitiveStr::Ascii("ductie"),
        dictgen::InsensitiveStr::Ascii("ducting"),
        dictgen::InsensitiveStr::Ascii("ductionary"),
        dictgen::InsensitiveStr::Ascii("ductiory"),
        dictgen::InsensitiveStr::Ascii("ductury"),
        dictgen::InsensitiveStr::Ascii("due"),
        dictgen::InsensitiveStr::Ascii("dued"),
        dictgen::InsensitiveStr::Ascii("duktion"),
        dictgen::InsensitiveStr::Ascii("dus"),
        dictgen::InsensitiveStr::Ascii("duse"),
        dictgen::InsensitiveStr::Ascii("dused"),
        dictgen::InsensitiveStr::Ascii("duses"),
        dictgen::InsensitiveStr::Ascii("dusing"),
        dictgen::InsensitiveStr::Ascii("sepectable"),
        dictgen::InsensitiveStr::Ascii("sepection"),
        dictgen::InsensitiveStr::Ascii("speccion"),
        dictgen::InsensitiveStr::Ascii("spectin"),
        dictgen::InsensitiveStr::Ascii("spectivo"),
        dictgen::InsensitiveStr::Ascii("spektion"),
        dictgen::InsensitiveStr::Ascii("vents"),
        dictgen::InsensitiveStr::Ascii("vered"),
        dictgen::InsensitiveStr::Ascii("vers"),
        dictgen::InsensitiveStr::Ascii("versa"),
        dictgen::InsensitiveStr::Ascii("verse"),
        dictgen::InsensitiveStr::Ascii("versi"),
        dictgen::InsensitiveStr::Ascii("verso"),
        dictgen::InsensitiveStr::Ascii("versy"),
        dictgen::InsensitiveStr::Ascii("vertie"),
        dictgen::InsensitiveStr::Ascii("vertis"),
        dictgen::InsensitiveStr::Ascii("vet"),
        dictgen::InsensitiveStr::Ascii("veted"),
    ],
    values: &[
        &["introduces"],
        &["introduction"],
        &["introduction"],
        &["introduces"],
        &["introduces"],
        &["introducing"],
        &["introduction"],
        &["introduction"],
        &["introductory"],
        &["introduced"],
        &["introduce"],
        &["introduction"],
        &["introductory"],
        &["introductory"],
        &["introductory"],
        &["introduces"],
        &["introduced"],
        &["introduction"],
        &["introduces"],
        &["introduces", "introduce"],
        &["introduces", "introduced"],
        &["introduces"],
        &["introducing"],
        &["introspectable"],
        &["introspection"],
        &["introspection"],
        &["introspection"],
        &["introspection"],
        &["introspection"],
        &["introverts"],
        &["introverted"],
        &["introverts"],
        &["introverts"],
        &["introverts"],
        &["introverts"],
        &["introverts"],
        &["introverts"],
        &["introverted"],
        &["introverts"],
        &["introvert"],
        &["introverted"],
    ],
    range: 3..=10,
};

static WORD_INTRI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INTRI_CHILDREN),
    value: None,
};

pub static WORD_INTRI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("caces"),
        dictgen::InsensitiveStr::Ascii("casies"),
        dictgen::InsensitiveStr::Ascii("cicies"),
        dictgen::InsensitiveStr::Ascii("duce"),
        dictgen::InsensitiveStr::Ascii("duced"),
        dictgen::InsensitiveStr::Ascii("duction"),
        dictgen::InsensitiveStr::Ascii("ge"),
        dictgen::InsensitiveStr::Ascii("gueing"),
        dictgen::InsensitiveStr::Ascii("guied"),
        dictgen::InsensitiveStr::Ascii("gured"),
        dictgen::InsensitiveStr::Ascii("nisc"),
        dictgen::InsensitiveStr::Ascii("niscally"),
        dictgen::InsensitiveStr::Ascii("nsecally"),
        dictgen::InsensitiveStr::Ascii("nseci"),
        dictgen::InsensitiveStr::Ascii("nsicaly"),
        dictgen::InsensitiveStr::Ascii("nsict"),
        dictgen::InsensitiveStr::Ascii("nsinc"),
        dictgen::InsensitiveStr::Ascii("nsisch"),
        dictgen::InsensitiveStr::Ascii("quing"),
        dictgen::InsensitiveStr::Ascii("sinc"),
        dictgen::InsensitiveStr::Ascii("sincally"),
        dictgen::InsensitiveStr::Ascii("sincs"),
        dictgen::InsensitiveStr::Ascii("snic"),
        dictgen::InsensitiveStr::Ascii("stically"),
        dictgen::InsensitiveStr::Ascii("uge"),
        dictgen::InsensitiveStr::Ascii("uged"),
        dictgen::InsensitiveStr::Ascii("uging"),
    ],
    values: &[
        &["intricacies"],
        &["intricacies"],
        &["intricacies"],
        &["introduce"],
        &["introduced"],
        &["introduction"],
        &["intrigue"],
        &["intriguing"],
        &["intrigue"],
        &["intrigue"],
        &["intrinsic"],
        &["intrinsically"],
        &["intrinsically"],
        &["intrinsic"],
        &["intrinsically"],
        &["intrinsic"],
        &["intrinsic"],
        &["intrinsic"],
        &["intriguing"],
        &["intrinsic"],
        &["intrinsically"],
        &["intrinsics"],
        &["intrinsic"],
        &["intrinsically"],
        &["intrigue"],
        &["intrigued"],
        &["intriguing"],
    ],
    range: 2..=8,
};

static WORD_INTRE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INTRE_CHILDREN),
    value: None,
};

pub static WORD_INTRE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cacies"),
        dictgen::InsensitiveStr::Ascii("eg"),
        dictgen::InsensitiveStr::Ascii("eged"),
        dictgen::InsensitiveStr::Ascii("eging"),
        dictgen::InsensitiveStr::Ascii("egued"),
        dictgen::InsensitiveStr::Ascii("eguing"),
        dictgen::InsensitiveStr::Ascii("face"),
        dictgen::InsensitiveStr::Ascii("gal"),
        dictgen::InsensitiveStr::Ascii("gity"),
        dictgen::InsensitiveStr::Ascii("gral"),
        dictgen::InsensitiveStr::Ascii("guing"),
        dictgen::InsensitiveStr::Ascii("nets"),
        dictgen::InsensitiveStr::Ascii("nsically"),
        dictgen::InsensitiveStr::Ascii("pret"),
        dictgen::InsensitiveStr::Ascii("pretation"),
        dictgen::InsensitiveStr::Ascii("pretations"),
        dictgen::InsensitiveStr::Ascii("preted"),
        dictgen::InsensitiveStr::Ascii("preter"),
        dictgen::InsensitiveStr::Ascii("preting"),
        dictgen::InsensitiveStr::Ascii("rrupt"),
        dictgen::InsensitiveStr::Ascii("rupt"),
        dictgen::InsensitiveStr::Ascii("rupted"),
        dictgen::InsensitiveStr::Ascii("sst"),
        dictgen::InsensitiveStr::Ascii("ssted"),
        dictgen::InsensitiveStr::Ascii("ssting"),
        dictgen::InsensitiveStr::Ascii("st"),
        dictgen::InsensitiveStr::Ascii("sted"),
        dictgen::InsensitiveStr::Ascii("sting"),
        dictgen::InsensitiveStr::Ascii("webs"),
    ],
    values: &[
        &["intricacies"],
        &["intrigue"],
        &["intrigued"],
        &["intriguing"],
        &["intrigued"],
        &["intriguing"],
        &["interface"],
        &["integral"],
        &["integrity"],
        &["integral"],
        &["intriguing"],
        &["internets"],
        &["intrinsically"],
        &["interpret"],
        &["interpretation"],
        &["interpretations"],
        &["interpreted"],
        &["interpreter"],
        &["interpreting"],
        &["interrupt"],
        &["interrupt"],
        &["interrupted"],
        &["interest"],
        &["interested"],
        &["interesting"],
        &["interest", "insert"],
        &["interested"],
        &["interesting"],
        &["interwebs"],
    ],
    range: 2..=10,
};

static WORD_INTRD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INTRD_CHILDREN),
    value: None,
};

pub static WORD_INTRD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("uced")],
    values: &[&["introduced"]],
    range: 4..=4,
};

static WORD_INTRA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INTRA_CHILDREN),
    value: None,
};

pub static WORD_INTRA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cacies"),
        dictgen::InsensitiveStr::Ascii("cicies"),
        dictgen::InsensitiveStr::Ascii("cite"),
        dictgen::InsensitiveStr::Ascii("spection"),
        dictgen::InsensitiveStr::Ascii("version"),
        dictgen::InsensitiveStr::Ascii("vert"),
        dictgen::InsensitiveStr::Ascii("verted"),
        dictgen::InsensitiveStr::Ascii("verts"),
    ],
    values: &[
        &["intricacies"],
        &["intricacies"],
        &["intricate"],
        &["introspection"],
        &["introversion"],
        &["introvert"],
        &["introverted"],
        &["introverts"],
    ],
    range: 4..=8,
};

static WORD_INTQ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INTQ_CHILDREN),
    value: None,
};

pub static WORD_INTQ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("uire"),
        dictgen::InsensitiveStr::Ascii("uired"),
        dictgen::InsensitiveStr::Ascii("uires"),
        dictgen::InsensitiveStr::Ascii("uiries"),
        dictgen::InsensitiveStr::Ascii("uiry"),
    ],
    values: &[
        &["inquire"],
        &["inquired"],
        &["inquires"],
        &["inquiries"],
        &["inquiry"],
    ],
    range: 4..=6,
};

static WORD_INTP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INTP_CHILDREN),
    value: None,
};

pub static WORD_INTP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("reter"),
        dictgen::InsensitiveStr::Ascii("ut"),
        dictgen::InsensitiveStr::Ascii("uts"),
    ],
    values: &[&["interpreter"], &["input"], &["inputs"]],
    range: 2..=5,
};

static WORD_INTO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INTO_CHILDREN),
    value: None,
};

pub static WORD_INTO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("larant"),
        dictgen::InsensitiveStr::Ascii("lerace"),
        dictgen::InsensitiveStr::Ascii("leranse"),
        dictgen::InsensitiveStr::Ascii("lerante"),
        dictgen::InsensitiveStr::Ascii("lerate"),
        dictgen::InsensitiveStr::Ascii("lerence"),
        dictgen::InsensitiveStr::Ascii("lerent"),
        dictgen::InsensitiveStr::Ascii("lernace"),
        dictgen::InsensitiveStr::Ascii("lorance"),
        dictgen::InsensitiveStr::Ascii("lorant"),
        dictgen::InsensitiveStr::Ascii("lorence"),
        dictgen::InsensitiveStr::Ascii("lorent"),
        dictgen::InsensitiveStr::Ascii("rduce"),
        dictgen::InsensitiveStr::Ascii("rduced"),
        dictgen::InsensitiveStr::Ascii("rduces"),
        dictgen::InsensitiveStr::Ascii("rducing"),
        dictgen::InsensitiveStr::Ascii("rduction"),
        dictgen::InsensitiveStr::Ascii("rductory"),
        dictgen::InsensitiveStr::Ascii("rvert"),
        dictgen::InsensitiveStr::Ascii("rverted"),
        dictgen::InsensitiveStr::Ascii("rverts"),
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("to"),
        dictgen::InsensitiveStr::Ascii("xicacion"),
        dictgen::InsensitiveStr::Ascii("xicatin"),
        dictgen::InsensitiveStr::Ascii("xicaton"),
        dictgen::InsensitiveStr::Ascii("xicted"),
        dictgen::InsensitiveStr::Ascii("xinated"),
        dictgen::InsensitiveStr::Ascii("xination"),
        dictgen::InsensitiveStr::Ascii("xocated"),
    ],
    values: &[
        &["intolerant"],
        &["intolerance"],
        &["intolerance"],
        &["intolerance"],
        &["intolerant"],
        &["intolerance"],
        &["intolerant"],
        &["intolerance"],
        &["intolerance"],
        &["intolerant"],
        &["intolerance"],
        &["intolerant"],
        &["introduce"],
        &["introduced"],
        &["introduces"],
        &["introducing"],
        &["introduction"],
        &["introductory"],
        &["introvert"],
        &["introverted"],
        &["introverts"],
        &["into"],
        &["into"],
        &["intoxication"],
        &["intoxication"],
        &["intoxication"],
        &["intoxicated"],
        &["intoxicated"],
        &["intoxication"],
        &["intoxicated"],
    ],
    range: 1..=8,
};

static WORD_INTI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_INTI_CHILDREN),
    value: None,
};

static WORD_INTI_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_INTIA_NODE),
    None,
    Some(&WORD_INTIC_NODE),
    Some(&WORD_INTID_NODE),
    None,
    None,
    Some(&WORD_INTIG_NODE),
    None,
    Some(&WORD_INTII_NODE),
    None,
    None,
    Some(&WORD_INTIL_NODE),
    Some(&WORD_INTIM_NODE),
    Some(&WORD_INTIN_NODE),
    None,
    None,
    None,
    Some(&WORD_INTIR_NODE),
    None,
    Some(&WORD_INTIT_NODE),
    Some(&WORD_INTIU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_INTIU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INTIU_CHILDREN),
    value: None,
};

pub static WORD_INTIU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("tion"),
        dictgen::InsensitiveStr::Ascii("tive"),
        dictgen::InsensitiveStr::Ascii("tively"),
    ],
    values: &[&["intuition"], &["intuitive"], &["intuitively"]],
    range: 4..=6,
};

static WORD_INTIT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INTIT_CHILDREN),
    value: None,
};

pub static WORD_INTIT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ial"),
        dictgen::InsensitiveStr::Ascii("ialization"),
        dictgen::InsensitiveStr::Ascii("ialize"),
        dictgen::InsensitiveStr::Ascii("ialized"),
        dictgen::InsensitiveStr::Ascii("ials"),
        dictgen::InsensitiveStr::Ascii("y"),
    ],
    values: &[
        &["initial"],
        &["initialization"],
        &["initialize"],
        &["initialized"],
        &["initials"],
        &["entity"],
    ],
    range: 1..=10,
};

static WORD_INTIR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INTIR_CHILDREN),
    value: None,
};

pub static WORD_INTIR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("cate")],
    values: &[&["intricate"]],
    range: 4..=4,
};

static WORD_INTIN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INTIN_CHILDREN),
    value: None,
};

pub static WORD_INTIN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ite")],
    values: &[&["infinite"]],
    range: 3..=3,
};

static WORD_INTIM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INTIM_CHILDREN),
    value: None,
};

pub static WORD_INTIM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("adate"),
        dictgen::InsensitiveStr::Ascii("adated"),
        dictgen::InsensitiveStr::Ascii("atley"),
        dictgen::InsensitiveStr::Ascii("aty"),
        dictgen::InsensitiveStr::Ascii("iated"),
        dictgen::InsensitiveStr::Ascii("idacion"),
        dictgen::InsensitiveStr::Ascii("idad"),
        dictgen::InsensitiveStr::Ascii("idade"),
        dictgen::InsensitiveStr::Ascii("idades"),
        dictgen::InsensitiveStr::Ascii("idant"),
        dictgen::InsensitiveStr::Ascii("idante"),
        dictgen::InsensitiveStr::Ascii("idare"),
        dictgen::InsensitiveStr::Ascii("idatie"),
        dictgen::InsensitiveStr::Ascii("idatin"),
        dictgen::InsensitiveStr::Ascii("idative"),
        dictgen::InsensitiveStr::Ascii("idaton"),
        dictgen::InsensitiveStr::Ascii("ide"),
        dictgen::InsensitiveStr::Ascii("idiate"),
        dictgen::InsensitiveStr::Ascii("inated"),
        dictgen::InsensitiveStr::Ascii("itade"),
        dictgen::InsensitiveStr::Ascii("itaded"),
        dictgen::InsensitiveStr::Ascii("itading"),
        dictgen::InsensitiveStr::Ascii("italy"),
        dictgen::InsensitiveStr::Ascii("itate"),
        dictgen::InsensitiveStr::Ascii("itated"),
        dictgen::InsensitiveStr::Ascii("itating"),
        dictgen::InsensitiveStr::Ascii("itation"),
        dictgen::InsensitiveStr::Ascii("ite"),
        dictgen::InsensitiveStr::Ascii("itely"),
    ],
    values: &[
        &["intimidate"],
        &["intimidated"],
        &["intimately"],
        &["intimately"],
        &["intimidate"],
        &["intimidation"],
        &["intimidated"],
        &["intimidated"],
        &["intimidated"],
        &["intimidate"],
        &["intimidate"],
        &["intimidate"],
        &["intimidated"],
        &["intimidation"],
        &["intimidate"],
        &["intimidation"],
        &["intimidate"],
        &["intimidate"],
        &["intimidated"],
        &["intimidated"],
        &["intimidated"],
        &["intimidating"],
        &["intimately"],
        &["intimidate"],
        &["intimidated"],
        &["intimidating"],
        &["intimidation"],
        &["intimate"],
        &["intimately"],
    ],
    range: 3..=7,
};

static WORD_INTIL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INTIL_CHILDREN),
    value: None,
};

pub static WORD_INTIL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ising"),
        dictgen::InsensitiveStr::Ascii("izing"),
        dictgen::InsensitiveStr::Ascii("lectual"),
        dictgen::InsensitiveStr::Ascii("lectually"),
        dictgen::InsensitiveStr::Ascii("lectuals"),
    ],
    values: &[
        &["initialising"],
        &["initializing"],
        &["intellectual"],
        &["intellectually"],
        &["intellectuals"],
    ],
    range: 5..=9,
};

static WORD_INTII_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INTII_CHILDREN),
    value: None,
};

pub static WORD_INTII_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("al"),
        dictgen::InsensitiveStr::Ascii("alise"),
        dictgen::InsensitiveStr::Ascii("alize"),
        dictgen::InsensitiveStr::Ascii("als"),
    ],
    values: &[
        &["initial"],
        &["initialise"],
        &["initialize"],
        &["initials"],
    ],
    range: 2..=5,
};

static WORD_INTIG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INTIG_CHILDREN),
    value: None,
};

pub static WORD_INTIG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("er")],
    values: &[&["integer"]],
    range: 2..=2,
};

static WORD_INTID_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INTID_CHILDREN),
    value: None,
};

pub static WORD_INTID_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("imate"),
        dictgen::InsensitiveStr::Ascii("imation"),
    ],
    values: &[&["intimidate"], &["intimidation"]],
    range: 5..=7,
};

static WORD_INTIC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INTIC_CHILDREN),
    value: None,
};

pub static WORD_INTIC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ement"),
        dictgen::InsensitiveStr::Ascii("racies"),
        dictgen::InsensitiveStr::Ascii("rate"),
    ],
    values: &[&["enticement"], &["intricacies"], &["intricate"]],
    range: 4..=6,
};

static WORD_INTIA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INTIA_CHILDREN),
    value: None,
};

pub static WORD_INTIA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ilise"),
        dictgen::InsensitiveStr::Ascii("ilised"),
        dictgen::InsensitiveStr::Ascii("iliseing"),
        dictgen::InsensitiveStr::Ascii("iliser"),
        dictgen::InsensitiveStr::Ascii("ilises"),
        dictgen::InsensitiveStr::Ascii("ilising"),
        dictgen::InsensitiveStr::Ascii("ilize"),
        dictgen::InsensitiveStr::Ascii("ilized"),
        dictgen::InsensitiveStr::Ascii("ilizeing"),
        dictgen::InsensitiveStr::Ascii("ilizer"),
        dictgen::InsensitiveStr::Ascii("ilizes"),
        dictgen::InsensitiveStr::Ascii("ilizing"),
        dictgen::InsensitiveStr::Ascii("l"),
        dictgen::InsensitiveStr::Ascii("le"),
        dictgen::InsensitiveStr::Ascii("lisation"),
        dictgen::InsensitiveStr::Ascii("lise"),
        dictgen::InsensitiveStr::Ascii("lised"),
        dictgen::InsensitiveStr::Ascii("liser"),
        dictgen::InsensitiveStr::Ascii("lisers"),
        dictgen::InsensitiveStr::Ascii("lises"),
        dictgen::InsensitiveStr::Ascii("lising"),
        dictgen::InsensitiveStr::Ascii("listion"),
        dictgen::InsensitiveStr::Ascii("lizating"),
        dictgen::InsensitiveStr::Ascii("lization"),
        dictgen::InsensitiveStr::Ascii("lizations"),
        dictgen::InsensitiveStr::Ascii("lizaze"),
        dictgen::InsensitiveStr::Ascii("lize"),
        dictgen::InsensitiveStr::Ascii("lized"),
        dictgen::InsensitiveStr::Ascii("lizer"),
        dictgen::InsensitiveStr::Ascii("lizers"),
        dictgen::InsensitiveStr::Ascii("lizes"),
        dictgen::InsensitiveStr::Ascii("lizing"),
        dictgen::InsensitiveStr::Ascii("liztion"),
        dictgen::InsensitiveStr::Ascii("lled"),
        dictgen::InsensitiveStr::Ascii("llisation"),
        dictgen::InsensitiveStr::Ascii("llisations"),
        dictgen::InsensitiveStr::Ascii("llised"),
        dictgen::InsensitiveStr::Ascii("llization"),
        dictgen::InsensitiveStr::Ascii("llizations"),
        dictgen::InsensitiveStr::Ascii("llized"),
        dictgen::InsensitiveStr::Ascii("llly"),
        dictgen::InsensitiveStr::Ascii("lly"),
        dictgen::InsensitiveStr::Ascii("ls"),
        dictgen::InsensitiveStr::Ascii("lse"),
        dictgen::InsensitiveStr::Ascii("lsed"),
        dictgen::InsensitiveStr::Ascii("lsing"),
        dictgen::InsensitiveStr::Ascii("lte"),
        dictgen::InsensitiveStr::Ascii("ly"),
        dictgen::InsensitiveStr::Ascii("lze"),
        dictgen::InsensitiveStr::Ascii("lzed"),
        dictgen::InsensitiveStr::Ascii("lzing"),
    ],
    values: &[
        &["initialise"],
        &["initialised"],
        &["initialising"],
        &["initialiser"],
        &["initialises"],
        &["initialising"],
        &["initialize"],
        &["initialized"],
        &["initializing"],
        &["initializer"],
        &["initializes"],
        &["initializing"],
        &["initial"],
        &["initial"],
        &["initialisation"],
        &["initialise"],
        &["initialised"],
        &["initialiser"],
        &["initialisers"],
        &["initialises"],
        &["initialising"],
        &["initialisation"],
        &["initializing"],
        &["initialization"],
        &["initializations"],
        &["initialize"],
        &["initialize"],
        &["initialized"],
        &["initializer"],
        &["initializers"],
        &["initializes"],
        &["initializing"],
        &["initialization"],
        &["initialled"],
        &["initialisation"],
        &["initialisations"],
        &["initialised"],
        &["initialization"],
        &["initializations"],
        &["initialized"],
        &["initially"],
        &["initially"],
        &["initials"],
        &["initialise"],
        &["initialised"],
        &["initialising"],
        &["initialise"],
        &["initially"],
        &["initialize"],
        &["initialized"],
        &["initializing"],
    ],
    range: 1..=10,
};

static WORD_INTG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INTG_CHILDREN),
    value: None,
};

pub static WORD_INTG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("er"),
        dictgen::InsensitiveStr::Ascii("ers"),
        dictgen::InsensitiveStr::Ascii("ral"),
    ],
    values: &[&["integer"], &["integers"], &["integral"]],
    range: 2..=3,
};

static WORD_INTE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_INTE_CHILDREN),
    value: None,
};

static WORD_INTE_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_INTEA_NODE),
    None,
    None,
    Some(&WORD_INTED_NODE),
    None,
    Some(&WORD_INTEF_NODE),
    Some(&WORD_INTEG_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_INTEL_NODE),
    Some(&WORD_INTEM_NODE),
    Some(&WORD_INTEN_NODE),
    None,
    Some(&WORD_INTEP_NODE),
    None,
    Some(&WORD_INTER_NODE),
    Some(&WORD_INTES_NODE),
    None,
    None,
    Some(&WORD_INTEV_NODE),
    None,
    None,
    None,
    None,
];

static WORD_INTEV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INTEV_CHILDREN),
    value: None,
};

pub static WORD_INTEV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("al"),
        dictgen::InsensitiveStr::Ascii("als"),
        dictgen::InsensitiveStr::Ascii("ene"),
    ],
    values: &[&["interval"], &["intervals"], &["intervene"]],
    range: 2..=3,
};

static WORD_INTES_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INTES_CHILDREN),
    value: None,
};

pub static WORD_INTES_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ection"),
        dictgen::InsensitiveStr::Ascii("ity"),
        dictgen::InsensitiveStr::Ascii("nely"),
        dictgen::InsensitiveStr::Ascii("nity"),
        dictgen::InsensitiveStr::Ascii("ted"),
        dictgen::InsensitiveStr::Ascii("tents"),
        dictgen::InsensitiveStr::Ascii("tinas"),
        dictgen::InsensitiveStr::Ascii("tinces"),
        dictgen::InsensitiveStr::Ascii("tinos"),
        dictgen::InsensitiveStr::Ascii("tins"),
        dictgen::InsensitiveStr::Ascii("tions"),
    ],
    values: &[
        &["intersection"],
        &["intensity"],
        &["intensely"],
        &["intensity"],
        &["interested"],
        &["intestines"],
        &["intestines"],
        &["intestines"],
        &["intestines"],
        &["intestines"],
        &["intestines"],
    ],
    range: 3..=6,
};

static WORD_INTER_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_INTER_CHILDREN),
    value: None,
};

static WORD_INTER_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_INTERA_NODE),
    Some(&WORD_INTERB_NODE),
    Some(&WORD_INTERC_NODE),
    Some(&WORD_INTERD_NODE),
    Some(&WORD_INTERE_NODE),
    Some(&WORD_INTERF_NODE),
    Some(&WORD_INTERG_NODE),
    None,
    Some(&WORD_INTERI_NODE),
    None,
    None,
    Some(&WORD_INTERL_NODE),
    Some(&WORD_INTERM_NODE),
    Some(&WORD_INTERN_NODE),
    Some(&WORD_INTERO_NODE),
    Some(&WORD_INTERP_NODE),
    None,
    Some(&WORD_INTERR_NODE),
    Some(&WORD_INTERS_NODE),
    Some(&WORD_INTERT_NODE),
    Some(&WORD_INTERU_NODE),
    Some(&WORD_INTERV_NODE),
    Some(&WORD_INTERW_NODE),
    None,
    None,
    None,
];

static WORD_INTERW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INTERW_CHILDREN),
    value: None,
};

pub static WORD_INTERW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ebbs"),
        dictgen::InsensitiveStr::Ascii("ebers"),
        dictgen::InsensitiveStr::Ascii("iever"),
    ],
    values: &[&["interwebs"], &["interwebs"], &["interviewer"]],
    range: 4..=5,
};

static WORD_INTERV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INTERV_CHILDREN),
    value: None,
};

pub static WORD_INTERV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("all"),
        dictgen::InsensitiveStr::Ascii("alles"),
        dictgen::InsensitiveStr::Ascii("alls"),
        dictgen::InsensitiveStr::Ascii("alos"),
        dictgen::InsensitiveStr::Ascii("ation"),
        dictgen::InsensitiveStr::Ascii("een"),
        dictgen::InsensitiveStr::Ascii("eening"),
        dictgen::InsensitiveStr::Ascii("eign"),
        dictgen::InsensitiveStr::Ascii("eing"),
        dictgen::InsensitiveStr::Ascii("eiwed"),
        dictgen::InsensitiveStr::Ascii("eiwer"),
        dictgen::InsensitiveStr::Ascii("eiwing"),
        dictgen::InsensitiveStr::Ascii("eiws"),
        dictgen::InsensitiveStr::Ascii("encion"),
        dictgen::InsensitiveStr::Ascii("eneing"),
        dictgen::InsensitiveStr::Ascii("enion"),
        dictgen::InsensitiveStr::Ascii("enire"),
        dictgen::InsensitiveStr::Ascii("ension"),
        dictgen::InsensitiveStr::Ascii("entie"),
        dictgen::InsensitiveStr::Ascii("ento"),
        dictgen::InsensitiveStr::Ascii("enue"),
        dictgen::InsensitiveStr::Ascii("eres"),
        dictgen::InsensitiveStr::Ascii("ewing"),
        dictgen::InsensitiveStr::Ascii("ied"),
        dictgen::InsensitiveStr::Ascii("iened"),
        dictgen::InsensitiveStr::Ascii("ieni"),
        dictgen::InsensitiveStr::Ascii("iening"),
        dictgen::InsensitiveStr::Ascii("ier"),
        dictgen::InsensitiveStr::Ascii("ies"),
        dictgen::InsensitiveStr::Ascii("ieuw"),
        dictgen::InsensitiveStr::Ascii("iewd"),
        dictgen::InsensitiveStr::Ascii("iewes"),
        dictgen::InsensitiveStr::Ascii("iewie"),
        dictgen::InsensitiveStr::Ascii("iewr"),
        dictgen::InsensitiveStr::Ascii("ines"),
        dictgen::InsensitiveStr::Ascii("ining"),
        dictgen::InsensitiveStr::Ascii("iwed"),
        dictgen::InsensitiveStr::Ascii("iwer"),
    ],
    values: &[
        &["interval"],
        &["intervals"],
        &["intervals"],
        &["intervals"],
        &["integration"],
        &["intervene"],
        &["intervening"],
        &["intervening"],
        &["intervening"],
        &["interviewed"],
        &["interviewer"],
        &["interviewing"],
        &["interviews"],
        &["intervention"],
        &["intervening"],
        &["intervening"],
        &["intervene"],
        &["intervention"],
        &["intervene"],
        &["intervention"],
        &["intervene"],
        &["interferes"],
        &["intervening"],
        &["interviewed"],
        &["interviewed"],
        &["interviewing"],
        &["interviewing"],
        &["interviewer"],
        &["interviews"],
        &["interviews"],
        &["interviewed"],
        &["interviews"],
        &["interviewer"],
        &["interviewer"],
        &["intervenes"],
        &["intervening"],
        &["interviewed"],
        &["interviewer"],
    ],
    range: 3..=6,
};

static WORD_INTERU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INTERU_CHILDREN),
    value: None,
};

pub static WORD_INTERU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("pt"),
        dictgen::InsensitiveStr::Ascii("pted"),
        dictgen::InsensitiveStr::Ascii("pting"),
        dictgen::InsensitiveStr::Ascii("pts"),
        dictgen::InsensitiveStr::Ascii("upt"),
    ],
    values: &[
        &["interrupt"],
        &["interrupted"],
        &["interrupting"],
        &["interrupts"],
        &["interrupt"],
    ],
    range: 2..=5,
};

static WORD_INTERT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INTERT_CHILDREN),
    value: None,
};

pub static WORD_INTERT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ained"),
        dictgen::InsensitiveStr::Ascii("aining"),
        dictgen::InsensitiveStr::Ascii("ainment"),
        dictgen::InsensitiveStr::Ascii("ia"),
        dictgen::InsensitiveStr::Ascii("ial"),
        dictgen::InsensitiveStr::Ascii("vined"),
        dictgen::InsensitiveStr::Ascii("winded"),
        dictgen::InsensitiveStr::Ascii("winned"),
        dictgen::InsensitiveStr::Ascii("wyned"),
    ],
    values: &[
        &["intertwined"],
        &["entertaining"],
        &["entertainment"],
        &["inertia"],
        &["inertial"],
        &["intertwined"],
        &["intertwined"],
        &["intertwined"],
        &["intertwined"],
    ],
    range: 2..=7,
};

static WORD_INTERS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INTERS_CHILDREN),
    value: None,
};

pub static WORD_INTERS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cetion"),
        dictgen::InsensitiveStr::Ascii("eccion"),
        dictgen::InsensitiveStr::Ascii("ecct"),
        dictgen::InsensitiveStr::Ascii("eccted"),
        dictgen::InsensitiveStr::Ascii("eccting"),
        dictgen::InsensitiveStr::Ascii("ecction"),
        dictgen::InsensitiveStr::Ascii("eccts"),
        dictgen::InsensitiveStr::Ascii("eciton"),
        dictgen::InsensitiveStr::Ascii("ecrion"),
        dictgen::InsensitiveStr::Ascii("ectionals"),
        dictgen::InsensitiveStr::Ascii("ecton"),
        dictgen::InsensitiveStr::Ascii("ectons"),
        dictgen::InsensitiveStr::Ascii("eption"),
        dictgen::InsensitiveStr::Ascii("epts"),
        dictgen::InsensitiveStr::Ascii("etllar"),
        dictgen::InsensitiveStr::Ascii("parsed"),
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("tae"),
        dictgen::InsensitiveStr::Ascii("tallar"),
        dictgen::InsensitiveStr::Ascii("taller"),
        dictgen::InsensitiveStr::Ascii("te"),
        dictgen::InsensitiveStr::Ascii("ted"),
        dictgen::InsensitiveStr::Ascii("tela"),
        dictgen::InsensitiveStr::Ascii("telar"),
        dictgen::InsensitiveStr::Ascii("tellaire"),
        dictgen::InsensitiveStr::Ascii("teller"),
        dictgen::InsensitiveStr::Ascii("tellor"),
        dictgen::InsensitiveStr::Ascii("ting"),
        dictgen::InsensitiveStr::Ascii("ts"),
    ],
    values: &[
        &["intersection"],
        &["intersection"],
        &["intersect"],
        &["intersected"],
        &["intersecting"],
        &["intersection"],
        &["intersects"],
        &["intersections"],
        &["intersection"],
        &["intersections"],
        &["intersection"],
        &["intersections"],
        &["interception"],
        &["intercepts", "intersteps"],
        &["interstellar"],
        &["interspersed"],
        &["interest"],
        &["interstate"],
        &["interstellar"],
        &["interstellar"],
        &["interstate"],
        &["interested"],
        &["interstellar"],
        &["interstellar"],
        &["interstellar"],
        &["interstellar"],
        &["interstellar"],
        &["interesting"],
        &["interests"],
    ],
    range: 1..=9,
};

static WORD_INTERR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INTERR_CHILDREN),
    value: None,
};

pub static WORD_INTERR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("accial"),
        dictgen::InsensitiveStr::Ascii("act"),
        dictgen::InsensitiveStr::Ascii("actial"),
        dictgen::InsensitiveStr::Ascii("acting"),
        dictgen::InsensitiveStr::Ascii("active"),
        dictgen::InsensitiveStr::Ascii("acts"),
        dictgen::InsensitiveStr::Ascii("agation"),
        dictgen::InsensitiveStr::Ascii("atial"),
        dictgen::InsensitiveStr::Ascii("egation"),
        dictgen::InsensitiveStr::Ascii("esing"),
        dictgen::InsensitiveStr::Ascii("est"),
        dictgen::InsensitiveStr::Ascii("ested"),
        dictgen::InsensitiveStr::Ascii("esting"),
        dictgen::InsensitiveStr::Ascii("face"),
        dictgen::InsensitiveStr::Ascii("igation"),
        dictgen::InsensitiveStr::Ascii("im"),
        dictgen::InsensitiveStr::Ascii("ipt"),
        dictgen::InsensitiveStr::Ascii("o"),
        dictgen::InsensitiveStr::Ascii("ogacion"),
        dictgen::InsensitiveStr::Ascii("ogatin"),
        dictgen::InsensitiveStr::Ascii("ogativo"),
        dictgen::InsensitiveStr::Ascii("ogato"),
        dictgen::InsensitiveStr::Ascii("put"),
        dictgen::InsensitiveStr::Ascii("puted"),
        dictgen::InsensitiveStr::Ascii("rupt"),
        dictgen::InsensitiveStr::Ascii("rupted"),
        dictgen::InsensitiveStr::Ascii("rupting"),
        dictgen::InsensitiveStr::Ascii("rupts"),
        dictgen::InsensitiveStr::Ascii("tups"),
        dictgen::InsensitiveStr::Ascii("ugum"),
        dictgen::InsensitiveStr::Ascii("um"),
        dictgen::InsensitiveStr::Ascii("umping"),
        dictgen::InsensitiveStr::Ascii("up"),
        dictgen::InsensitiveStr::Ascii("uped"),
        dictgen::InsensitiveStr::Ascii("uping"),
        dictgen::InsensitiveStr::Ascii("ups"),
        dictgen::InsensitiveStr::Ascii("uptable"),
        dictgen::InsensitiveStr::Ascii("upteds"),
        dictgen::InsensitiveStr::Ascii("uptes"),
        dictgen::InsensitiveStr::Ascii("uptis"),
        dictgen::InsensitiveStr::Ascii("uptors"),
        dictgen::InsensitiveStr::Ascii("uptted"),
        dictgen::InsensitiveStr::Ascii("ut"),
        dictgen::InsensitiveStr::Ascii("utps"),
    ],
    values: &[
        &["interracial"],
        &["interact"],
        &["interracial"],
        &["interacting"],
        &["interactive"],
        &["interacts"],
        &["interrogation"],
        &["interracial"],
        &["interrogation"],
        &["interfering"],
        &["interest"],
        &["interested"],
        &["interesting"],
        &["interface"],
        &["interrogation"],
        &["interim"],
        &["interrupt"],
        &["interior"],
        &["interrogation"],
        &["interrogation"],
        &["interrogation"],
        &["interrogation"],
        &["interrupt"],
        &["interrupted"],
        &["interrupt"],
        &["interrupted"],
        &["interrupting"],
        &["interrupts"],
        &["interrupts"],
        &["interregnum"],
        &["interim"],
        &["interrupting"],
        &["interrupt"],
        &["interrupted"],
        &["interrupting"],
        &["interrupts"],
        &["interruptible"],
        &["interrupts"],
        &["interrupts"],
        &["interrupts"],
        &["interrupts", "interrupters"],
        &["interrupted"],
        &["interrupt"],
        &["interrupts"],
    ],
    range: 1..=7,
};

static WORD_INTERP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_INTERP_CHILDREN),
    value: None,
};

static WORD_INTERP_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    None,
    None,
    Some(&WORD_INTERPE_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_INTERPL_NODE),
    None,
    None,
    Some(&WORD_INTERPO_NODE),
    None,
    None,
    Some(&WORD_INTERPR_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_INTERPR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INTERPR_CHILDREN),
    value: None,
};

pub static WORD_INTERPR_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("atation"),
            dictgen::InsensitiveStr::Ascii("atations"),
            dictgen::InsensitiveStr::Ascii("ate"),
            dictgen::InsensitiveStr::Ascii("ated"),
            dictgen::InsensitiveStr::Ascii("ating"),
            dictgen::InsensitiveStr::Ascii("eation"),
            dictgen::InsensitiveStr::Ascii("ered"),
            dictgen::InsensitiveStr::Ascii("erter"),
            dictgen::InsensitiveStr::Ascii("esonal"),
            dictgen::InsensitiveStr::Ascii("etacion"),
            dictgen::InsensitiveStr::Ascii("etaciones"),
            dictgen::InsensitiveStr::Ascii("etaion"),
            dictgen::InsensitiveStr::Ascii("etaiton"),
            dictgen::InsensitiveStr::Ascii("etare"),
            dictgen::InsensitiveStr::Ascii("etarea"),
            dictgen::InsensitiveStr::Ascii("etarem"),
            dictgen::InsensitiveStr::Ascii("etares"),
            dictgen::InsensitiveStr::Ascii("etarse"),
            dictgen::InsensitiveStr::Ascii("etarte"),
            dictgen::InsensitiveStr::Ascii("etated"),
            dictgen::InsensitiveStr::Ascii("etatin"),
            dictgen::InsensitiveStr::Ascii("etating"),
            dictgen::InsensitiveStr::Ascii("etationen"),
            dictgen::InsensitiveStr::Ascii("etato"),
            dictgen::InsensitiveStr::Ascii("etaton"),
            dictgen::InsensitiveStr::Ascii("etatons"),
            dictgen::InsensitiveStr::Ascii("ete"),
            dictgen::InsensitiveStr::Ascii("eteer"),
            dictgen::InsensitiveStr::Ascii("eteert"),
            dictgen::InsensitiveStr::Ascii("etes"),
            dictgen::InsensitiveStr::Ascii("etet"),
            dictgen::InsensitiveStr::Ascii("etier"),
            dictgen::InsensitiveStr::Ascii("etion"),
            dictgen::InsensitiveStr::Ascii("etions"),
            dictgen::InsensitiveStr::Ascii("ett"),
            dictgen::InsensitiveStr::Ascii("etted"),
            dictgen::InsensitiveStr::Ascii("etter"),
            dictgen::InsensitiveStr::Ascii("etting"),
            dictgen::InsensitiveStr::Ascii("itation"),
            dictgen::InsensitiveStr::Ascii("itations"),
            dictgen::InsensitiveStr::Ascii("iting"),
            dictgen::InsensitiveStr::Ascii("ut"),
        ],
        values: &[
            &["interpretation"],
            &["interpretations"],
            &["interpret"],
            &["interpreted"],
            &["interpreting"],
            &["interpretation"],
            &["interpreter"],
            &["interpreter"],
            &["interpersonal"],
            &["interpretation"],
            &["interpretations"],
            &["interpretation"],
            &["interpretations"],
            &["interpreter"],
            &["interpreter"],
            &["interpreter"],
            &["interpreter"],
            &["interpreter"],
            &["interpreter"],
            &["interpreted"],
            &["interpretations"],
            &["interpretation"],
            &["interpretations"],
            &["interpretation"],
            &["interpretation"],
            &["interpretations"],
            &["interpret"],
            &["interpreter"],
            &["interpreter"],
            &["interprets"],
            &["interpreted"],
            &["interpreter"],
            &["interpreting", "interpretation"],
            &["interpretations"],
            &["interpret"],
            &["interpreted"],
            &["interpreter"],
            &["interpreting"],
            &["interpretation"],
            &["interpretations"],
            &["interpreting"],
            &["interrupt"],
        ],
        range: 2..=9,
    };

static WORD_INTERPO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INTERPO_CHILDREN),
    value: None,
};

pub static WORD_INTERPO_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("laed"),
            dictgen::InsensitiveStr::Ascii("laion"),
            dictgen::InsensitiveStr::Ascii("laiton"),
            dictgen::InsensitiveStr::Ascii("lar"),
            dictgen::InsensitiveStr::Ascii("laton"),
            dictgen::InsensitiveStr::Ascii("layed"),
            dictgen::InsensitiveStr::Ascii("loate"),
            dictgen::InsensitiveStr::Ascii("loated"),
            dictgen::InsensitiveStr::Ascii("loates"),
            dictgen::InsensitiveStr::Ascii("loating"),
            dictgen::InsensitiveStr::Ascii("loation"),
            dictgen::InsensitiveStr::Ascii("loations"),
            dictgen::InsensitiveStr::Ascii("rated"),
            dictgen::InsensitiveStr::Ascii("ration"),
            dictgen::InsensitiveStr::Ascii("rations"),
        ],
        values: &[
            &["interpolated"],
            &["interpolation"],
            &["interpolation"],
            &["interpolator"],
            &["interpolation"],
            &["interpolated"],
            &["interpolate"],
            &["interpolated"],
            &["interpolates"],
            &["interpolating"],
            &["interpolation"],
            &["interpolations"],
            &["interpolated", "interpreted"],
            &["interpolation"],
            &["interpolations"],
        ],
        range: 3..=8,
    };

static WORD_INTERPL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INTERPL_CHILDREN),
    value: None,
};

pub static WORD_INTERPL_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("oate"),
            dictgen::InsensitiveStr::Ascii("oated"),
            dictgen::InsensitiveStr::Ascii("oates"),
            dictgen::InsensitiveStr::Ascii("oatin"),
            dictgen::InsensitiveStr::Ascii("oation"),
        ],
        values: &[
            &["interpolate"],
            &["interpolated"],
            &["interpolates"],
            &["interpolating"],
            &["interpolation"],
        ],
        range: 4..=6,
    };

static WORD_INTERPE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INTERPE_CHILDREN),
    value: None,
};

pub static WORD_INTERPE_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("rated"),
            dictgen::InsensitiveStr::Ascii("rsonel"),
            dictgen::InsensitiveStr::Ascii("rsonnal"),
            dictgen::InsensitiveStr::Ascii("rt"),
            dictgen::InsensitiveStr::Ascii("rtation"),
            dictgen::InsensitiveStr::Ascii("rtations"),
            dictgen::InsensitiveStr::Ascii("rted"),
            dictgen::InsensitiveStr::Ascii("rter"),
            dictgen::InsensitiveStr::Ascii("rters"),
            dictgen::InsensitiveStr::Ascii("rting"),
            dictgen::InsensitiveStr::Ascii("rtive"),
            dictgen::InsensitiveStr::Ascii("rts"),
            dictgen::InsensitiveStr::Ascii("t"),
            dictgen::InsensitiveStr::Ascii("tation"),
            dictgen::InsensitiveStr::Ascii("ted"),
            dictgen::InsensitiveStr::Ascii("ter"),
            dictgen::InsensitiveStr::Ascii("ters"),
            dictgen::InsensitiveStr::Ascii("ting"),
            dictgen::InsensitiveStr::Ascii("ts"),
        ],
        values: &[
            &["interpreted"],
            &["interpersonal"],
            &["interpersonal"],
            &["interpret"],
            &["interpretation"],
            &["interpretations"],
            &["interpreted"],
            &["interpreter"],
            &["interpreter", "interpreters"],
            &["interpreting"],
            &["interpretive"],
            &["interprets"],
            &["interpret"],
            &["interpretation"],
            &["interpreted"],
            &["interpreter"],
            &["interpreters"],
            &["interpreting"],
            &["interprets"],
        ],
        range: 1..=8,
    };

static WORD_INTERO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INTERO_CHILDREN),
    value: None,
};

pub static WORD_INTERO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("gators"),
        dictgen::InsensitiveStr::Ascii("peable"),
        dictgen::InsensitiveStr::Ascii("prability"),
    ],
    values: &[
        &["interrogators"],
        &["interoperable"],
        &["interoperability"],
    ],
    range: 6..=9,
};

static WORD_INTERN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INTERN_CHILDREN),
    value: None,
};

pub static WORD_INTERN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("acional"),
        dictgen::InsensitiveStr::Ascii("all"),
        dictgen::InsensitiveStr::Ascii("aly"),
        dictgen::InsensitiveStr::Ascii("atinal"),
        dictgen::InsensitiveStr::Ascii("atinalism"),
        dictgen::InsensitiveStr::Ascii("atinalist"),
        dictgen::InsensitiveStr::Ascii("atinalists"),
        dictgen::InsensitiveStr::Ascii("atinally"),
        dictgen::InsensitiveStr::Ascii("atioanl"),
        dictgen::InsensitiveStr::Ascii("atioanlism"),
        dictgen::InsensitiveStr::Ascii("atioanlist"),
        dictgen::InsensitiveStr::Ascii("atioanlists"),
        dictgen::InsensitiveStr::Ascii("atioanlly"),
        dictgen::InsensitiveStr::Ascii("ation"),
        dictgen::InsensitiveStr::Ascii("ationaal"),
        dictgen::InsensitiveStr::Ascii("ationaly"),
        dictgen::InsensitiveStr::Ascii("ationl"),
        dictgen::InsensitiveStr::Ascii("ationnal"),
        dictgen::InsensitiveStr::Ascii("ationnally"),
        dictgen::InsensitiveStr::Ascii("ations"),
        dictgen::InsensitiveStr::Ascii("ediate"),
        dictgen::InsensitiveStr::Ascii("el"),
        dictgen::InsensitiveStr::Ascii("elized"),
        dictgen::InsensitiveStr::Ascii("els"),
        dictgen::InsensitiveStr::Ascii("est"),
        dictgen::InsensitiveStr::Ascii("etbs"),
        dictgen::InsensitiveStr::Ascii("eters"),
        dictgen::InsensitiveStr::Ascii("etes"),
        dictgen::InsensitiveStr::Ascii("etese"),
        dictgen::InsensitiveStr::Ascii("etest"),
        dictgen::InsensitiveStr::Ascii("eting"),
        dictgen::InsensitiveStr::Ascii("etis"),
        dictgen::InsensitiveStr::Ascii("etors"),
        dictgen::InsensitiveStr::Ascii("ettes"),
        dictgen::InsensitiveStr::Ascii("etts"),
        dictgen::InsensitiveStr::Ascii("etus"),
        dictgen::InsensitiveStr::Ascii("face"),
        dictgen::InsensitiveStr::Ascii("ilized"),
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("ts"),
        dictgen::InsensitiveStr::Ascii("us"),
    ],
    values: &[
        &["international"],
        &["internal", "internally"],
        &["internally"],
        &["international"],
        &["internationalism"],
        &["internationalist"],
        &["internationalists"],
        &["internationally"],
        &["international"],
        &["internationalism"],
        &["internationalist"],
        &["internationalists"],
        &["internationally"],
        &["international"],
        &["international"],
        &["internationally"],
        &["international"],
        &["international"],
        &["internationally"],
        &["interactions"],
        &["intermediate"],
        &["internal"],
        &["internalized"],
        &["internals"],
        &["internets"],
        &["internets"],
        &["internets"],
        &["internets"],
        &["internets"],
        &["internets"],
        &["interesting"],
        &["internets"],
        &["internets"],
        &["internets"],
        &["internets"],
        &["internets"],
        &["interface"],
        &["internalized"],
        &["internet"],
        &["interns"],
        &["interns"],
    ],
    range: 1..=11,
};

static WORD_INTERM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INTERM_CHILDREN),
    value: Some(&["interim", "intern"]),
};

pub static WORD_INTERM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("edate"),
        dictgen::InsensitiveStr::Ascii("ediare"),
        dictgen::InsensitiveStr::Ascii("ediat"),
        dictgen::InsensitiveStr::Ascii("edie"),
        dictgen::InsensitiveStr::Ascii("ediete"),
        dictgen::InsensitiveStr::Ascii("edite"),
        dictgen::InsensitiveStr::Ascii("eidate"),
        dictgen::InsensitiveStr::Ascii("ettent"),
        dictgen::InsensitiveStr::Ascii("ideate"),
        dictgen::InsensitiveStr::Ascii("idiate"),
        dictgen::InsensitiveStr::Ascii("idiery"),
        dictgen::InsensitiveStr::Ascii("itent"),
        dictgen::InsensitiveStr::Ascii("ittant"),
        dictgen::InsensitiveStr::Ascii("ittient"),
        dictgen::InsensitiveStr::Ascii("ittment"),
        dictgen::InsensitiveStr::Ascii("perance"),
    ],
    values: &[
        &["intermediate"],
        &["intermediate"],
        &["intermediate"],
        &["intermediate"],
        &["intermediate"],
        &["intermediate"],
        &["intermediate"],
        &["intermittent"],
        &["intermediate"],
        &["intermediate"],
        &["intermediary"],
        &["intermittent"],
        &["intermittent"],
        &["intermittent"],
        &["intermittent"],
        &["intemperance"],
    ],
    range: 4..=7,
};

static WORD_INTERL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INTERL_CHILDREN),
    value: None,
};

pub static WORD_INTERL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eaed"),
        dictgen::InsensitiveStr::Ascii("ectual"),
        dictgen::InsensitiveStr::Ascii("ectually"),
        dictgen::InsensitiveStr::Ascii("ectuals"),
        dictgen::InsensitiveStr::Ascii("eiive"),
        dictgen::InsensitiveStr::Ascii("eive"),
        dictgen::InsensitiveStr::Ascii("iveing"),
        dictgen::InsensitiveStr::Ascii("ly"),
    ],
    values: &[
        &["interleaved"],
        &["intellectual"],
        &["intellectually"],
        &["intellectuals"],
        &["interleave"],
        &["interleave"],
        &["interleaving"],
        &["internally"],
    ],
    range: 2..=8,
};

static WORD_INTERI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INTERI_CHILDREN),
    value: None,
};

pub static WORD_INTERI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("oara"),
        dictgen::InsensitiveStr::Ascii("oare"),
        dictgen::InsensitiveStr::Ascii("our"),
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("tance"),
        dictgen::InsensitiveStr::Ascii("ted"),
        dictgen::InsensitiveStr::Ascii("ting"),
        dictgen::InsensitiveStr::Ascii("ts"),
    ],
    values: &[
        &["interior"],
        &["interior"],
        &["interior"],
        &["inherit"],
        &["inheritance"],
        &["inherited"],
        &["inheriting"],
        &["inherits"],
    ],
    range: 1..=5,
};

static WORD_INTERG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INTERG_CHILDREN),
    value: None,
};

pub static WORD_INTERG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("al"),
        dictgen::InsensitiveStr::Ascii("ate"),
        dictgen::InsensitiveStr::Ascii("ated"),
        dictgen::InsensitiveStr::Ascii("ation"),
        dictgen::InsensitiveStr::Ascii("er"),
        dictgen::InsensitiveStr::Ascii("erated"),
        dictgen::InsensitiveStr::Ascii("ers"),
        dictgen::InsensitiveStr::Ascii("ity"),
        dictgen::InsensitiveStr::Ascii("rate"),
        dictgen::InsensitiveStr::Ascii("rated"),
        dictgen::InsensitiveStr::Ascii("rates"),
        dictgen::InsensitiveStr::Ascii("rating"),
        dictgen::InsensitiveStr::Ascii("ration"),
        dictgen::InsensitiveStr::Ascii("rations"),
    ],
    values: &[
        &["integral"],
        &["integrate"],
        &["integrated"],
        &["integration"],
        &["integer"],
        &["integrated"],
        &["integers"],
        &["integrity"],
        &["integrate"],
        &["integrated"],
        &["integrates"],
        &["integrating"],
        &["integration"],
        &["integrations"],
    ],
    range: 2..=7,
};

static WORD_INTERF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INTERF_CHILDREN),
    value: None,
};

pub static WORD_INTERF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("acce"),
        dictgen::InsensitiveStr::Ascii("act"),
        dictgen::InsensitiveStr::Ascii("al"),
        dictgen::InsensitiveStr::Ascii("als"),
        dictgen::InsensitiveStr::Ascii("ase"),
        dictgen::InsensitiveStr::Ascii("ave"),
        dictgen::InsensitiveStr::Ascii("aves"),
        dictgen::InsensitiveStr::Ascii("cae"),
        dictgen::InsensitiveStr::Ascii("caes"),
        dictgen::InsensitiveStr::Ascii("ce"),
        dictgen::InsensitiveStr::Ascii("ear"),
        dictgen::InsensitiveStr::Ascii("earence"),
        dictgen::InsensitiveStr::Ascii("earnce"),
        dictgen::InsensitiveStr::Ascii("ears"),
        dictgen::InsensitiveStr::Ascii("eer"),
        dictgen::InsensitiveStr::Ascii("eers"),
        dictgen::InsensitiveStr::Ascii("er"),
        dictgen::InsensitiveStr::Ascii("erance"),
        dictgen::InsensitiveStr::Ascii("erce"),
        dictgen::InsensitiveStr::Ascii("erd"),
        dictgen::InsensitiveStr::Ascii("erece"),
        dictgen::InsensitiveStr::Ascii("ereing"),
        dictgen::InsensitiveStr::Ascii("erens"),
        dictgen::InsensitiveStr::Ascii("erire"),
        dictgen::InsensitiveStr::Ascii("erisce"),
        dictgen::InsensitiveStr::Ascii("erisse"),
        dictgen::InsensitiveStr::Ascii("ernce"),
        dictgen::InsensitiveStr::Ascii("erre"),
        dictgen::InsensitiveStr::Ascii("erred"),
        dictgen::InsensitiveStr::Ascii("erres"),
        dictgen::InsensitiveStr::Ascii("erring"),
        dictgen::InsensitiveStr::Ascii("ers"),
    ],
    values: &[
        &["interfaces"],
        &["interact", "interface"],
        &["interval"],
        &["intervals"],
        &["interfaces"],
        &["interface"],
        &["interfaces"],
        &["interface"],
        &["interfaces"],
        &["interface"],
        &["interfere"],
        &["interference"],
        &["interference"],
        &["interferes"],
        &["interfere"],
        &["interferes"],
        &["interfere"],
        &["interference"],
        &["interferes"],
        &["interfered"],
        &["interference"],
        &["interfering"],
        &["interferes"],
        &["interfere"],
        &["interferes"],
        &["interferes"],
        &["interference"],
        &["interfere"],
        &["interfere", "interfered"],
        &["interferes"],
        &["interfering"],
        &["interferes"],
    ],
    range: 2..=7,
};

static WORD_INTERE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_INTERE_CHILDREN),
    value: None,
};

static WORD_INTERE_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_INTEREA_NODE),
    None,
    Some(&WORD_INTEREC_NODE),
    Some(&WORD_INTERED_NODE),
    Some(&WORD_INTEREE_NODE),
    Some(&WORD_INTEREF_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_INTEREL_NODE),
    None,
    Some(&WORD_INTEREN_NODE),
    None,
    Some(&WORD_INTEREP_NODE),
    None,
    Some(&WORD_INTERER_NODE),
    Some(&WORD_INTERES_NODE),
    Some(&WORD_INTERET_NODE),
    None,
    Some(&WORD_INTEREV_NODE),
    Some(&WORD_INTEREW_NODE),
    None,
    None,
    None,
];

static WORD_INTEREW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INTEREW_CHILDREN),
    value: None,
};

pub static WORD_INTEREW_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[dictgen::InsensitiveStr::Ascii("bs")],
        values: &[&["interwebs"]],
        range: 2..=2,
    };

static WORD_INTEREV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INTEREV_CHILDREN),
    value: None,
};

pub static WORD_INTEREV_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[dictgen::InsensitiveStr::Ascii("iew")],
        values: &[&["interview"]],
        range: 3..=3,
    };

static WORD_INTERET_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INTERET_CHILDREN),
    value: Some(&["interest"]),
};

pub static WORD_INTERET_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[],
        values: &[],
        range: 0..=0,
    };

static WORD_INTERES_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INTERES_CHILDREN),
    value: None,
};

pub static WORD_INTERES_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("ant"),
            dictgen::InsensitiveStr::Ascii("at"),
            dictgen::InsensitiveStr::Ascii("ct"),
            dictgen::InsensitiveStr::Ascii("cted"),
            dictgen::InsensitiveStr::Ascii("cting"),
            dictgen::InsensitiveStr::Ascii("ction"),
            dictgen::InsensitiveStr::Ascii("ctions"),
            dictgen::InsensitiveStr::Ascii("cts"),
            dictgen::InsensitiveStr::Ascii("e"),
            dictgen::InsensitiveStr::Ascii("ect"),
            dictgen::InsensitiveStr::Ascii("ected"),
            dictgen::InsensitiveStr::Ascii("ecting"),
            dictgen::InsensitiveStr::Ascii("ection"),
            dictgen::InsensitiveStr::Ascii("ections"),
            dictgen::InsensitiveStr::Ascii("ects"),
            dictgen::InsensitiveStr::Ascii("et"),
            dictgen::InsensitiveStr::Ascii("eted"),
            dictgen::InsensitiveStr::Ascii("eting"),
            dictgen::InsensitiveStr::Ascii("ing"),
            dictgen::InsensitiveStr::Ascii("persed"),
            dictgen::InsensitiveStr::Ascii("ring"),
            dictgen::InsensitiveStr::Ascii("seted"),
            dictgen::InsensitiveStr::Ascii("st"),
            dictgen::InsensitiveStr::Ascii("sted"),
            dictgen::InsensitiveStr::Ascii("sting"),
            dictgen::InsensitiveStr::Ascii("tes"),
            dictgen::InsensitiveStr::Ascii("tigly"),
            dictgen::InsensitiveStr::Ascii("tinly"),
        ],
        values: &[
            &["interest"],
            &["interest"],
            &["intersect"],
            &["intersected"],
            &["intersecting"],
            &["intersection"],
            &["intersections"],
            &["intersects"],
            &["interested"],
            &["intersect"],
            &["intersected"],
            &["intersecting"],
            &["intersection"],
            &["intersections"],
            &["intersects"],
            &["interest"],
            &["interested"],
            &["interesting"],
            &["interesting"],
            &["interspersed"],
            &["interfering"],
            &["interested"],
            &["interests", "interest"],
            &["interested"],
            &["interesting"],
            &["interests"],
            &["interestingly"],
            &["interestingly"],
        ],
        range: 1..=7,
    };

static WORD_INTERER_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INTERER_CHILDREN),
    value: None,
};

pub static WORD_INTERER_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("sted"),
            dictgen::InsensitiveStr::Ascii("sting"),
        ],
        values: &[&["interpreted"], &["interpreting"]],
        range: 4..=5,
    };

static WORD_INTEREP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INTEREP_CHILDREN),
    value: None,
};

pub static WORD_INTEREP_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("olate"),
            dictgen::InsensitiveStr::Ascii("olated"),
            dictgen::InsensitiveStr::Ascii("olates"),
            dictgen::InsensitiveStr::Ascii("olating"),
            dictgen::InsensitiveStr::Ascii("olation"),
            dictgen::InsensitiveStr::Ascii("ret"),
            dictgen::InsensitiveStr::Ascii("retation"),
            dictgen::InsensitiveStr::Ascii("retations"),
            dictgen::InsensitiveStr::Ascii("reted"),
            dictgen::InsensitiveStr::Ascii("reting"),
            dictgen::InsensitiveStr::Ascii("rets"),
            dictgen::InsensitiveStr::Ascii("t"),
        ],
        values: &[
            &["interpolate"],
            &["interpolated"],
            &["interpolates"],
            &["interpolating"],
            &["interpolation"],
            &["interpret"],
            &["interpretation"],
            &["interpretations"],
            &["interpreted"],
            &["interpreting"],
            &["interprets"],
            &["intercept"],
        ],
        range: 1..=9,
    };

static WORD_INTEREN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INTEREN_CHILDREN),
    value: None,
};

pub static WORD_INTEREN_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("t"),
            dictgen::InsensitiveStr::Ascii("ts"),
        ],
        values: &[&["internet"], &["internets"]],
        range: 1..=2,
    };

static WORD_INTEREL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INTEREL_CHILDREN),
    value: None,
};

pub static WORD_INTEREL_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("ated"),
            dictgen::InsensitiveStr::Ascii("aved"),
        ],
        values: &[&["interrelated"], &["interleaved"]],
        range: 4..=4,
    };

static WORD_INTEREF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INTEREF_CHILDREN),
    value: None,
};

pub static WORD_INTEREF_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("erence"),
            dictgen::InsensitiveStr::Ascii("erences"),
            dictgen::InsensitiveStr::Ascii("ers"),
        ],
        values: &[&["interference"], &["interferences"], &["interferes"]],
        range: 3..=7,
    };

static WORD_INTEREE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INTEREE_CHILDREN),
    value: None,
};

pub static WORD_INTEREE_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[dictgen::InsensitiveStr::Ascii("sted")],
        values: &[&["interested"]],
        range: 4..=4,
    };

static WORD_INTERED_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INTERED_CHILDREN),
    value: Some(&["interred", "interned"]),
};

pub static WORD_INTERED_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[],
        values: &[],
        range: 0..=0,
    };

static WORD_INTEREC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INTEREC_CHILDREN),
    value: None,
};

pub static WORD_INTEREC_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("ptor"),
            dictgen::InsensitiveStr::Ascii("t"),
            dictgen::InsensitiveStr::Ascii("ted"),
            dictgen::InsensitiveStr::Ascii("ting"),
            dictgen::InsensitiveStr::Ascii("tion"),
            dictgen::InsensitiveStr::Ascii("tioned"),
            dictgen::InsensitiveStr::Ascii("tions"),
            dictgen::InsensitiveStr::Ascii("ts"),
        ],
        values: &[
            &["interceptor"],
            &["interacted", "interact", "intersect"],
            &["interacted", "intersected"],
            &["interacting", "intersecting"],
            &["interaction", "intersection"],
            &["interaction", "intersection"],
            &["interactions", "intersections"],
            &["interacts", "intersects"],
        ],
        range: 1..=6,
    };

static WORD_INTEREA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INTEREA_CHILDREN),
    value: None,
};

pub static WORD_INTEREA_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("ction"),
            dictgen::InsensitiveStr::Ascii("ctions"),
            dictgen::InsensitiveStr::Ascii("cts"),
        ],
        values: &[&["intersection"], &["intersections"], &["interfaces"]],
        range: 3..=6,
    };

static WORD_INTERD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INTERD_CHILDREN),
    value: None,
};

pub static WORD_INTERD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ependant")],
    values: &[&["interdependent"]],
    range: 8..=8,
};

static WORD_INTERC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INTERC_CHILDREN),
    value: None,
};

pub static WORD_INTERC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ahnge"),
        dictgen::InsensitiveStr::Ascii("ahnged"),
        dictgen::InsensitiveStr::Ascii("ation"),
        dictgen::InsensitiveStr::Ascii("ection"),
        dictgen::InsensitiveStr::Ascii("epcion"),
        dictgen::InsensitiveStr::Ascii("epticons"),
        dictgen::InsensitiveStr::Ascii("eptin"),
        dictgen::InsensitiveStr::Ascii("epto"),
        dictgen::InsensitiveStr::Ascii("eptons"),
        dictgen::InsensitiveStr::Ascii("hage"),
        dictgen::InsensitiveStr::Ascii("hangable"),
        dictgen::InsensitiveStr::Ascii("hangabley"),
        dictgen::InsensitiveStr::Ascii("hangably"),
        dictgen::InsensitiveStr::Ascii("hangeablely"),
        dictgen::InsensitiveStr::Ascii("hangeabley"),
        dictgen::InsensitiveStr::Ascii("hangeablity"),
        dictgen::InsensitiveStr::Ascii("hangebale"),
        dictgen::InsensitiveStr::Ascii("hangeble"),
        dictgen::InsensitiveStr::Ascii("hangebly"),
        dictgen::InsensitiveStr::Ascii("oarse"),
        dictgen::InsensitiveStr::Ascii("ollegate"),
        dictgen::InsensitiveStr::Ascii("ontinential"),
        dictgen::InsensitiveStr::Ascii("ontinetal"),
        dictgen::InsensitiveStr::Ascii("orse"),
        dictgen::InsensitiveStr::Ascii("ource"),
        dictgen::InsensitiveStr::Ascii("ouse"),
    ],
    values: &[
        &["interchange"],
        &["interchanged"],
        &["integration", "interaction"],
        &["interception"],
        &["interception"],
        &["interceptions"],
        &["interception"],
        &["interception"],
        &["interceptions"],
        &["interchange"],
        &["interchangeable"],
        &["interchangeably"],
        &["interchangeably"],
        &["interchangeably"],
        &["interchangeably"],
        &["interchangeably"],
        &["interchangeable"],
        &["interchangeable"],
        &["interchangeably"],
        &["intercourse"],
        &["intercollegiate"],
        &["intercontinental"],
        &["intercontinental"],
        &["intercourse"],
        &["intercourse"],
        &["intercourse"],
    ],
    range: 4..=11,
};

static WORD_INTERB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INTERB_CHILDREN),
    value: None,
};

pub static WORD_INTERB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("read")],
    values: &[&["interbreed", "interbred"]],
    range: 4..=4,
};

static WORD_INTERA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INTERA_CHILDREN),
    value: None,
};

pub static WORD_INTERA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ccion"),
        dictgen::InsensitiveStr::Ascii("ce"),
        dictgen::InsensitiveStr::Ascii("ces"),
        dictgen::InsensitiveStr::Ascii("cive"),
        dictgen::InsensitiveStr::Ascii("cively"),
        dictgen::InsensitiveStr::Ascii("cs"),
        dictgen::InsensitiveStr::Ascii("csion"),
        dictgen::InsensitiveStr::Ascii("csions"),
        dictgen::InsensitiveStr::Ascii("cte"),
        dictgen::InsensitiveStr::Ascii("ctes"),
        dictgen::InsensitiveStr::Ascii("cteve"),
        dictgen::InsensitiveStr::Ascii("ctevely"),
        dictgen::InsensitiveStr::Ascii("ctice"),
        dictgen::InsensitiveStr::Ascii("ctie"),
        dictgen::InsensitiveStr::Ascii("cties"),
        dictgen::InsensitiveStr::Ascii("ctifs"),
        dictgen::InsensitiveStr::Ascii("ctins"),
        dictgen::InsensitiveStr::Ascii("ctionn"),
        dictgen::InsensitiveStr::Ascii("ctionns"),
        dictgen::InsensitiveStr::Ascii("ctios"),
        dictgen::InsensitiveStr::Ascii("ctiv"),
        dictgen::InsensitiveStr::Ascii("ctivly"),
        dictgen::InsensitiveStr::Ascii("ctivo"),
        dictgen::InsensitiveStr::Ascii("ctons"),
        dictgen::InsensitiveStr::Ascii("ctuable"),
        dictgen::InsensitiveStr::Ascii("ctue"),
        dictgen::InsensitiveStr::Ascii("fce"),
        dictgen::InsensitiveStr::Ascii("kt"),
        dictgen::InsensitiveStr::Ascii("ktion"),
        dictgen::InsensitiveStr::Ascii("ktions"),
        dictgen::InsensitiveStr::Ascii("ktive"),
        dictgen::InsensitiveStr::Ascii("ktively"),
        dictgen::InsensitiveStr::Ascii("ktivly"),
        dictgen::InsensitiveStr::Ascii("l"),
        dictgen::InsensitiveStr::Ascii("lly"),
        dictgen::InsensitiveStr::Ascii("ls"),
        dictgen::InsensitiveStr::Ascii("ly"),
        dictgen::InsensitiveStr::Ascii("nl"),
        dictgen::InsensitiveStr::Ascii("nlly"),
        dictgen::InsensitiveStr::Ascii("sted"),
        dictgen::InsensitiveStr::Ascii("sting"),
        dictgen::InsensitiveStr::Ascii("te"),
        dictgen::InsensitiveStr::Ascii("ted"),
        dictgen::InsensitiveStr::Ascii("tellar"),
        dictgen::InsensitiveStr::Ascii("tes"),
        dictgen::InsensitiveStr::Ascii("ting"),
        dictgen::InsensitiveStr::Ascii("tion"),
        dictgen::InsensitiveStr::Ascii("tional"),
        dictgen::InsensitiveStr::Ascii("tionalism"),
        dictgen::InsensitiveStr::Ascii("tionalist"),
        dictgen::InsensitiveStr::Ascii("tionalists"),
        dictgen::InsensitiveStr::Ascii("tionally"),
        dictgen::InsensitiveStr::Ascii("tions"),
        dictgen::InsensitiveStr::Ascii("tive"),
        dictgen::InsensitiveStr::Ascii("tively"),
        dictgen::InsensitiveStr::Ascii("tor"),
        dictgen::InsensitiveStr::Ascii("tors"),
        dictgen::InsensitiveStr::Ascii("xction"),
        dictgen::InsensitiveStr::Ascii("xctions"),
        dictgen::InsensitiveStr::Ascii("xtion"),
        dictgen::InsensitiveStr::Ascii("xtions"),
    ],
    values: &[
        &["interaction"],
        &["interacted", "interface"],
        &["interfaces"],
        &["interactive"],
        &["interactively"],
        &["interacts"],
        &["interaction"],
        &["interactions"],
        &["interactive"],
        &["interacts"],
        &["interactive"],
        &["interactively"],
        &["interactive"],
        &["interactive"],
        &["interacts"],
        &["interacts"],
        &["interacts"],
        &["interaction"],
        &["interactions"],
        &["interacts"],
        &["interactive"],
        &["interactively"],
        &["interaction"],
        &["interacts"],
        &["interactive"],
        &["interacted"],
        &["interface"],
        &["interact"],
        &["interaction"],
        &["interactions"],
        &["interactive", "interactively"],
        &["interactively"],
        &["interactively"],
        &["internal", "interval", "integral"],
        &["internally", "integrally"],
        &["internals", "intervals", "integrals"],
        &["internally"],
        &["internal"],
        &["internally"],
        &["interacted"],
        &["interacting"],
        &["iterate"],
        &["iterated", "interacted", "integrated"],
        &["interstellar"],
        &["iterates", "interacts", "integrated"],
        &["iterating", "interacting", "integrating"],
        &["iteration", "interaction", "integration"],
        &["international"],
        &["internationalism"],
        &["internationalist"],
        &["internationalists"],
        &["internationally"],
        &["iterations", "interactions"],
        &["interactive"],
        &["interactively"],
        &["iterator"],
        &["iterators"],
        &["interaction"],
        &["interactions"],
        &["interaction"],
        &["interactions"],
    ],
    range: 1..=10,
};

static WORD_INTEP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INTEP_CHILDREN),
    value: None,
};

pub static WORD_INTEP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("olate"),
        dictgen::InsensitiveStr::Ascii("olated"),
        dictgen::InsensitiveStr::Ascii("olates"),
        dictgen::InsensitiveStr::Ascii("ret"),
        dictgen::InsensitiveStr::Ascii("retable"),
        dictgen::InsensitiveStr::Ascii("retation"),
        dictgen::InsensitiveStr::Ascii("retations"),
        dictgen::InsensitiveStr::Ascii("retator"),
        dictgen::InsensitiveStr::Ascii("retators"),
        dictgen::InsensitiveStr::Ascii("reted"),
        dictgen::InsensitiveStr::Ascii("reter"),
        dictgen::InsensitiveStr::Ascii("reters"),
        dictgen::InsensitiveStr::Ascii("retes"),
        dictgen::InsensitiveStr::Ascii("reting"),
        dictgen::InsensitiveStr::Ascii("retor"),
        dictgen::InsensitiveStr::Ascii("retors"),
        dictgen::InsensitiveStr::Ascii("rets"),
    ],
    values: &[
        &["interpolate"],
        &["interpolated"],
        &["interpolates"],
        &["interpret"],
        &["interpretable"],
        &["interpretation"],
        &["interpretations"],
        &["interpretor", "interpreter"],
        &["interpreters"],
        &["interpreted"],
        &["interpreter"],
        &["interpreters"],
        &["interprets"],
        &["interpreting"],
        &["interpreter"],
        &["interpreters"],
        &["interprets"],
    ],
    range: 3..=9,
};

static WORD_INTEN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INTEN_CHILDREN),
    value: None,
};

pub static WORD_INTEN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("al"),
        dictgen::InsensitiveStr::Ascii("ally"),
        dictgen::InsensitiveStr::Ascii("ational"),
        dictgen::InsensitiveStr::Ascii("ationalism"),
        dictgen::InsensitiveStr::Ascii("ationalist"),
        dictgen::InsensitiveStr::Ascii("ationalists"),
        dictgen::InsensitiveStr::Ascii("ationally"),
        dictgen::InsensitiveStr::Ascii("cional"),
        dictgen::InsensitiveStr::Ascii("des"),
        dictgen::InsensitiveStr::Ascii("det"),
        dictgen::InsensitiveStr::Ascii("dos"),
        dictgen::InsensitiveStr::Ascii("eded"),
        dictgen::InsensitiveStr::Ascii("isty"),
        dictgen::InsensitiveStr::Ascii("seley"),
        dictgen::InsensitiveStr::Ascii("sionaly"),
        dictgen::InsensitiveStr::Ascii("sitive"),
        dictgen::InsensitiveStr::Ascii("sitiy"),
        dictgen::InsensitiveStr::Ascii("sley"),
        dictgen::InsensitiveStr::Ascii("st"),
        dictgen::InsensitiveStr::Ascii("tas"),
        dictgen::InsensitiveStr::Ascii("tation"),
        dictgen::InsensitiveStr::Ascii("ted"),
        dictgen::InsensitiveStr::Ascii("tended"),
        dictgen::InsensitiveStr::Ascii("tially"),
        dictgen::InsensitiveStr::Ascii("tialy"),
        dictgen::InsensitiveStr::Ascii("tinal"),
        dictgen::InsensitiveStr::Ascii("tines"),
        dictgen::InsensitiveStr::Ascii("tionaly"),
        dictgen::InsensitiveStr::Ascii("tionly"),
        dictgen::InsensitiveStr::Ascii("tionnal"),
    ],
    values: &[
        &["internal"],
        &["internally"],
        &["international"],
        &["internationalism"],
        &["internationalist"],
        &["internationalists"],
        &["internationally"],
        &["intentional"],
        &["intends"],
        &["intended"],
        &["intends"],
        &["intended"],
        &["intensity"],
        &["intensely"],
        &["intentionally", "intensionally"],
        &["insensitive", "intensive"],
        &["intensity"],
        &["intensely"],
        &["intents"],
        &["intents"],
        &["indentation"],
        &["intended", "indented"],
        &["intended"],
        &["intentionally"],
        &["intentionally"],
        &["intentional"],
        &["intestines"],
        &["intentionally"],
        &["intentional", "intentionally"],
        &["intentional"],
    ],
    range: 2..=11,
};

static WORD_INTEM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INTEM_CHILDREN),
    value: None,
};

pub static WORD_INTEM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ediary")],
    values: &[&["intermediary"]],
    range: 6..=6,
};

static WORD_INTEL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INTEL_CHILDREN),
    value: None,
};

pub static WORD_INTEL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ectual"),
        dictgen::InsensitiveStr::Ascii("egence"),
        dictgen::InsensitiveStr::Ascii("egent"),
        dictgen::InsensitiveStr::Ascii("egently"),
        dictgen::InsensitiveStr::Ascii("elctual"),
        dictgen::InsensitiveStr::Ascii("elctuals"),
        dictgen::InsensitiveStr::Ascii("igability"),
        dictgen::InsensitiveStr::Ascii("igable"),
        dictgen::InsensitiveStr::Ascii("igance"),
        dictgen::InsensitiveStr::Ascii("igantly"),
        dictgen::InsensitiveStr::Ascii("igence"),
        dictgen::InsensitiveStr::Ascii("igent"),
        dictgen::InsensitiveStr::Ascii("isense"),
        dictgen::InsensitiveStr::Ascii("lectals"),
        dictgen::InsensitiveStr::Ascii("lectaul"),
        dictgen::InsensitiveStr::Ascii("lectualis"),
        dictgen::InsensitiveStr::Ascii("lectualisme"),
        dictgen::InsensitiveStr::Ascii("lectualls"),
        dictgen::InsensitiveStr::Ascii("lectualy"),
        dictgen::InsensitiveStr::Ascii("lectuel"),
        dictgen::InsensitiveStr::Ascii("lectuels"),
        dictgen::InsensitiveStr::Ascii("lectul"),
        dictgen::InsensitiveStr::Ascii("lectus"),
        dictgen::InsensitiveStr::Ascii("lecual"),
        dictgen::InsensitiveStr::Ascii("lecutal"),
        dictgen::InsensitiveStr::Ascii("lecutally"),
        dictgen::InsensitiveStr::Ascii("lecutals"),
        dictgen::InsensitiveStr::Ascii("legent"),
        dictgen::InsensitiveStr::Ascii("legently"),
        dictgen::InsensitiveStr::Ascii("ligable"),
        dictgen::InsensitiveStr::Ascii("ligance"),
        dictgen::InsensitiveStr::Ascii("ligant"),
        dictgen::InsensitiveStr::Ascii("ligenly"),
        dictgen::InsensitiveStr::Ascii("ligente"),
        dictgen::InsensitiveStr::Ascii("ligenty"),
        dictgen::InsensitiveStr::Ascii("ligient"),
        dictgen::InsensitiveStr::Ascii("luctuals"),
    ],
    values: &[
        &["intellectual"],
        &["intelligence"],
        &["intelligent"],
        &["intelligently"],
        &["intellectuals"],
        &["intellectuals"],
        &["intelligibility"],
        &["intelligible"],
        &["intelligence"],
        &["intelligently"],
        &["intelligence"],
        &["intelligent"],
        &["intellisense"],
        &["intellectuals"],
        &["intellectuals"],
        &["intellectuals"],
        &["intellectuals"],
        &["intellectuals"],
        &["intellectually"],
        &["intellectual"],
        &["intellectuals"],
        &["intellectuals"],
        &["intellectuals"],
        &["intellectual"],
        &["intellectual"],
        &["intellectually"],
        &["intellectuals"],
        &["intelligent"],
        &["intelligently"],
        &["intelligible"],
        &["intelligence"],
        &["intelligent"],
        &["intelligently"],
        &["intelligence"],
        &["intelligently"],
        &["intelligent"],
        &["intellectuals"],
    ],
    range: 5..=11,
};

static WORD_INTEG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INTEG_CHILDREN),
    value: None,
};

pub static WORD_INTEG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("arte"),
        dictgen::InsensitiveStr::Ascii("arted"),
        dictgen::InsensitiveStr::Ascii("artes"),
        dictgen::InsensitiveStr::Ascii("ate"),
        dictgen::InsensitiveStr::Ascii("ated"),
        dictgen::InsensitiveStr::Ascii("ates"),
        dictgen::InsensitiveStr::Ascii("ating"),
        dictgen::InsensitiveStr::Ascii("ation"),
        dictgen::InsensitiveStr::Ascii("ations"),
        dictgen::InsensitiveStr::Ascii("eral"),
        dictgen::InsensitiveStr::Ascii("ere"),
        dictgen::InsensitiveStr::Ascii("irty"),
        dictgen::InsensitiveStr::Ascii("raal"),
        dictgen::InsensitiveStr::Ascii("racion"),
        dictgen::InsensitiveStr::Ascii("rade"),
        dictgen::InsensitiveStr::Ascii("raded"),
        dictgen::InsensitiveStr::Ascii("rarla"),
        dictgen::InsensitiveStr::Ascii("rarlo"),
        dictgen::InsensitiveStr::Ascii("rat"),
        dictgen::InsensitiveStr::Ascii("ratie"),
        dictgen::InsensitiveStr::Ascii("ratione"),
        dictgen::InsensitiveStr::Ascii("rato"),
        dictgen::InsensitiveStr::Ascii("ratron"),
        dictgen::InsensitiveStr::Ascii("reated"),
        dictgen::InsensitiveStr::Ascii("reres"),
        dictgen::InsensitiveStr::Ascii("rering"),
        dictgen::InsensitiveStr::Ascii("reted"),
        dictgen::InsensitiveStr::Ascii("rety"),
        dictgen::InsensitiveStr::Ascii("rey"),
    ],
    values: &[
        &["integrate"],
        &["integrated"],
        &["integrates"],
        &["integrate"],
        &["integrated"],
        &["integrates"],
        &["integrating"],
        &["integration"],
        &["integrations"],
        &["integral"],
        &["integer"],
        &["integrity"],
        &["integral"],
        &["integration"],
        &["integrated"],
        &["integrated"],
        &["integral"],
        &["integral"],
        &["integral", "integrate"],
        &["integrated"],
        &["integration"],
        &["integration"],
        &["integration"],
        &["integrated"],
        &["interferes"],
        &["interfering"],
        &["integrated"],
        &["integrity"],
        &["integrity"],
    ],
    range: 3..=7,
};

static WORD_INTEF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INTEF_CHILDREN),
    value: None,
};

pub static WORD_INTEF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ace"),
        dictgen::InsensitiveStr::Ascii("ere"),
        dictgen::InsensitiveStr::Ascii("ered"),
        dictgen::InsensitiveStr::Ascii("erence"),
        dictgen::InsensitiveStr::Ascii("erring"),
        dictgen::InsensitiveStr::Ascii("race"),
    ],
    values: &[
        &["interface"],
        &["interfere"],
        &["interfered"],
        &["interference"],
        &["interfering"],
        &["interface"],
    ],
    range: 3..=6,
};

static WORD_INTED_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INTED_CHILDREN),
    value: Some(&["inetd", "intend"]),
};

pub static WORD_INTED_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("ned"),
    ],
    values: &[&["intended"], &["intended"]],
    range: 2..=3,
};

static WORD_INTEA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INTEA_CHILDREN),
    value: None,
};

pub static WORD_INTEA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ction"),
        dictgen::InsensitiveStr::Ascii("d"),
    ],
    values: &[&["interaction"], &["instead"]],
    range: 1..=5,
};

static WORD_INTA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INTA_CHILDREN),
    value: None,
};

pub static WORD_INTA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ces"),
        dictgen::InsensitiveStr::Ascii("ck"),
        dictgen::InsensitiveStr::Ascii("ll"),
        dictgen::InsensitiveStr::Ascii("llation"),
        dictgen::InsensitiveStr::Ascii("llationpath"),
        dictgen::InsensitiveStr::Ascii("llations"),
        dictgen::InsensitiveStr::Ascii("lled"),
        dictgen::InsensitiveStr::Ascii("lleing"),
        dictgen::InsensitiveStr::Ascii("ller"),
        dictgen::InsensitiveStr::Ascii("lles"),
        dictgen::InsensitiveStr::Ascii("lling"),
        dictgen::InsensitiveStr::Ascii("lls"),
        dictgen::InsensitiveStr::Ascii("micy"),
        dictgen::InsensitiveStr::Ascii("mite"),
        dictgen::InsensitiveStr::Ascii("nce"),
        dictgen::InsensitiveStr::Ascii("nces"),
        dictgen::InsensitiveStr::Ascii("ngable"),
        dictgen::InsensitiveStr::Ascii("ngeble"),
        dictgen::InsensitiveStr::Ascii("ngiable"),
        dictgen::InsensitiveStr::Ascii("ngibil"),
        dictgen::InsensitiveStr::Ascii("ngibile"),
        dictgen::InsensitiveStr::Ascii("njible"),
        dictgen::InsensitiveStr::Ascii("ntiate"),
        dictgen::InsensitiveStr::Ascii("ntiating"),
        dictgen::InsensitiveStr::Ascii("xication"),
    ],
    values: &[
        &["instance"],
        &["intact"],
        &["install"],
        &["installation"],
        &["installationpath"],
        &["installations"],
        &["installed"],
        &["installing"],
        &["installer"],
        &["installs"],
        &["installing"],
        &["installs"],
        &["intimacy"],
        &["intimate"],
        &["instance", "intense"],
        &["instances"],
        &["intangible"],
        &["intangible"],
        &["intangible"],
        &["intangible"],
        &["intangible"],
        &["intangible"],
        &["instantiate"],
        &["instantiating"],
        &["intoxication"],
    ],
    range: 2..=11,
};

static WORD_INS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_INS_CHILDREN),
    value: None,
};

static WORD_INS_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_INSA_NODE),
    None,
    Some(&WORD_INSC_NODE),
    Some(&WORD_INSD_NODE),
    Some(&WORD_INSE_NODE),
    None,
    None,
    None,
    Some(&WORD_INSI_NODE),
    None,
    None,
    Some(&WORD_INSL_NODE),
    Some(&WORD_INSM_NODE),
    None,
    Some(&WORD_INSO_NODE),
    Some(&WORD_INSP_NODE),
    None,
    Some(&WORD_INSR_NODE),
    None,
    Some(&WORD_INST_NODE),
    Some(&WORD_INSU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_INSU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INSU_CHILDREN),
    value: None,
};

pub static WORD_INSU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("alted"),
        dictgen::InsensitiveStr::Ascii("bstantiated"),
        dictgen::InsensitiveStr::Ascii("ccessful"),
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("ffciency"),
        dictgen::InsensitiveStr::Ascii("ffcient"),
        dictgen::InsensitiveStr::Ascii("ffciently"),
        dictgen::InsensitiveStr::Ascii("fficency"),
        dictgen::InsensitiveStr::Ascii("fficent"),
        dictgen::InsensitiveStr::Ascii("fficently"),
        dictgen::InsensitiveStr::Ascii("fficiant"),
        dictgen::InsensitiveStr::Ascii("ffiency"),
        dictgen::InsensitiveStr::Ascii("ffient"),
        dictgen::InsensitiveStr::Ascii("ffiently"),
        dictgen::InsensitiveStr::Ascii("ffucient"),
        dictgen::InsensitiveStr::Ascii("ficiency"),
        dictgen::InsensitiveStr::Ascii("ficient"),
        dictgen::InsensitiveStr::Ascii("inating"),
        dictgen::InsensitiveStr::Ascii("ltas"),
        dictgen::InsensitiveStr::Ascii("ltes"),
        dictgen::InsensitiveStr::Ascii("ltos"),
        dictgen::InsensitiveStr::Ascii("niating"),
        dictgen::InsensitiveStr::Ascii("rasnce"),
        dictgen::InsensitiveStr::Ascii("rence"),
        dictgen::InsensitiveStr::Ascii("rgance"),
        dictgen::InsensitiveStr::Ascii("rgancy"),
        dictgen::InsensitiveStr::Ascii("rgencey"),
        dictgen::InsensitiveStr::Ascii("rgeny"),
        dictgen::InsensitiveStr::Ascii("specting"),
        dictgen::InsensitiveStr::Ascii("stainable"),
    ],
    values: &[
        &["insulated"],
        &["unsubstantiated"],
        &["unsuccessful"],
        &["ensue", "insure"],
        &["insufficiency"],
        &["insufficient"],
        &["insufficiently"],
        &["insufficiency"],
        &["insufficient"],
        &["insufficiently"],
        &["insufficient"],
        &["insufficiency"],
        &["insufficient"],
        &["insufficiently"],
        &["insufficient"],
        &["insufficiency"],
        &["insufficient"],
        &["insinuating"],
        &["insults"],
        &["insults"],
        &["insults"],
        &["insinuating"],
        &["insurance"],
        &["insurance"],
        &["insurgency"],
        &["insurgency"],
        &["insurgency"],
        &["insurgency"],
        &["unsuspecting"],
        &["unsustainable"],
    ],
    range: 1..=11,
};

static WORD_INST_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_INST_CHILDREN),
    value: None,
};

static WORD_INST_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_INSTA_NODE),
    None,
    None,
    None,
    Some(&WORD_INSTE_NODE),
    None,
    None,
    None,
    Some(&WORD_INSTI_NODE),
    None,
    None,
    Some(&WORD_INSTL_NODE),
    None,
    Some(&WORD_INSTN_NODE),
    None,
    None,
    None,
    Some(&WORD_INSTR_NODE),
    Some(&WORD_INSTS_NODE),
    None,
    Some(&WORD_INSTU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_INSTU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INSTU_CHILDREN),
    value: None,
};

pub static WORD_INSTU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ction"),
        dictgen::InsensitiveStr::Ascii("ctional"),
        dictgen::InsensitiveStr::Ascii("ctions"),
        dictgen::InsensitiveStr::Ascii("ments"),
        dictgen::InsensitiveStr::Ascii("rcted"),
        dictgen::InsensitiveStr::Ascii("rction"),
        dictgen::InsensitiveStr::Ascii("rctor"),
        dictgen::InsensitiveStr::Ascii("rctors"),
        dictgen::InsensitiveStr::Ascii("rment"),
        dictgen::InsensitiveStr::Ascii("rmental"),
        dictgen::InsensitiveStr::Ascii("rmentals"),
        dictgen::InsensitiveStr::Ascii("rments"),
        dictgen::InsensitiveStr::Ascii("tionalized"),
        dictgen::InsensitiveStr::Ascii("tions"),
        dictgen::InsensitiveStr::Ascii("tition"),
        dictgen::InsensitiveStr::Ascii("titional"),
        dictgen::InsensitiveStr::Ascii("titionalized"),
        dictgen::InsensitiveStr::Ascii("titions"),
        dictgen::InsensitiveStr::Ascii("tuted"),
        dictgen::InsensitiveStr::Ascii("tution"),
        dictgen::InsensitiveStr::Ascii("tutionalized"),
    ],
    values: &[
        &["instruction"],
        &["instructional"],
        &["instructions"],
        &["instruments"],
        &["instructed"],
        &["instruction"],
        &["instructor"],
        &["instructors"],
        &["instrument"],
        &["instrumental"],
        &["instrumental"],
        &["instruments"],
        &["institutionalized"],
        &["intuitions", "institutions"],
        &["institution"],
        &["institutional"],
        &["institutionalized"],
        &["institutions"],
        &["instituted"],
        &["institution"],
        &["institutionalized"],
    ],
    range: 5..=12,
};

static WORD_INSTS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INSTS_CHILDREN),
    value: None,
};

pub static WORD_INSTS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("all"),
        dictgen::InsensitiveStr::Ascii("allation"),
        dictgen::InsensitiveStr::Ascii("allations"),
        dictgen::InsensitiveStr::Ascii("alled"),
        dictgen::InsensitiveStr::Ascii("alls"),
    ],
    values: &[
        &["install"],
        &["installation"],
        &["installations"],
        &["installed"],
        &["installs"],
    ],
    range: 3..=9,
};

static WORD_INSTR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INSTR_CHILDREN),
    value: None,
};

pub static WORD_INSTR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ace"),
        dictgen::InsensitiveStr::Ascii("all"),
        dictgen::InsensitiveStr::Ascii("alled"),
        dictgen::InsensitiveStr::Ascii("alling"),
        dictgen::InsensitiveStr::Ascii("alls"),
        dictgen::InsensitiveStr::Ascii("ament"),
        dictgen::InsensitiveStr::Ascii("amental"),
        dictgen::InsensitiveStr::Ascii("aments"),
        dictgen::InsensitiveStr::Ascii("ction"),
        dictgen::InsensitiveStr::Ascii("ctional"),
        dictgen::InsensitiveStr::Ascii("ctions"),
        dictgen::InsensitiveStr::Ascii("cut"),
        dictgen::InsensitiveStr::Ascii("cutino"),
        dictgen::InsensitiveStr::Ascii("cutinoal"),
        dictgen::InsensitiveStr::Ascii("cutinos"),
        dictgen::InsensitiveStr::Ascii("cution"),
        dictgen::InsensitiveStr::Ascii("cutional"),
        dictgen::InsensitiveStr::Ascii("cutions"),
        dictgen::InsensitiveStr::Ascii("cutor"),
        dictgen::InsensitiveStr::Ascii("cuts"),
        dictgen::InsensitiveStr::Ascii("ead"),
        dictgen::InsensitiveStr::Ascii("inics"),
        dictgen::InsensitiveStr::Ascii("insic"),
        dictgen::InsensitiveStr::Ascii("insics"),
        dictgen::InsensitiveStr::Ascii("ospection"),
        dictgen::InsensitiveStr::Ascii("uccion"),
        dictgen::InsensitiveStr::Ascii("uccional"),
        dictgen::InsensitiveStr::Ascii("uccions"),
        dictgen::InsensitiveStr::Ascii("ucion"),
        dictgen::InsensitiveStr::Ascii("ucional"),
        dictgen::InsensitiveStr::Ascii("ucions"),
        dictgen::InsensitiveStr::Ascii("uciton"),
        dictgen::InsensitiveStr::Ascii("ucitonal"),
        dictgen::InsensitiveStr::Ascii("ucitons"),
        dictgen::InsensitiveStr::Ascii("ucter"),
        dictgen::InsensitiveStr::Ascii("ucters"),
        dictgen::InsensitiveStr::Ascii("uctie"),
        dictgen::InsensitiveStr::Ascii("uctioin"),
        dictgen::InsensitiveStr::Ascii("uctioins"),
        dictgen::InsensitiveStr::Ascii("uctior"),
        dictgen::InsensitiveStr::Ascii("uctios"),
        dictgen::InsensitiveStr::Ascii("uctiosn"),
        dictgen::InsensitiveStr::Ascii("uctivo"),
        dictgen::InsensitiveStr::Ascii("uctons"),
        dictgen::InsensitiveStr::Ascii("uctores"),
        dictgen::InsensitiveStr::Ascii("uktion"),
        dictgen::InsensitiveStr::Ascii("uktor"),
        dictgen::InsensitiveStr::Ascii("umenal"),
        dictgen::InsensitiveStr::Ascii("umenet"),
        dictgen::InsensitiveStr::Ascii("umenetation"),
        dictgen::InsensitiveStr::Ascii("umenetd"),
        dictgen::InsensitiveStr::Ascii("umeneted"),
        dictgen::InsensitiveStr::Ascii("umentaion"),
        dictgen::InsensitiveStr::Ascii("umentaiton"),
        dictgen::InsensitiveStr::Ascii("umentos"),
        dictgen::InsensitiveStr::Ascii("umentul"),
        dictgen::InsensitiveStr::Ascii("umetal"),
        dictgen::InsensitiveStr::Ascii("umnet"),
        dictgen::InsensitiveStr::Ascii("umnets"),
        dictgen::InsensitiveStr::Ascii("ution"),
        dictgen::InsensitiveStr::Ascii("utions"),
    ],
    values: &[
        &["instance"],
        &["install"],
        &["installed"],
        &["installing"],
        &["installs"],
        &["instrument"],
        &["instrumental"],
        &["instruments"],
        &["instruction"],
        &["instructional"],
        &["instructions"],
        &["instruct"],
        &["instruction"],
        &["instructional"],
        &["instructions"],
        &["instruction"],
        &["instructional"],
        &["instruction", "instructions"],
        &["instructors"],
        &["instructs"],
        &["instead"],
        &["intrinsics"],
        &["intrinsic"],
        &["intrinsics"],
        &["introspection"],
        &["instruction"],
        &["instructional"],
        &["instructions"],
        &["instruction"],
        &["instructional"],
        &["instructions"],
        &["instruction"],
        &["instructional"],
        &["instruction", "instructions"],
        &["instructor"],
        &["instructors"],
        &["instructed"],
        &["instruction"],
        &["instructions"],
        &["instructor"],
        &["instructors"],
        &["instruction"],
        &["instruction"],
        &["instructors"],
        &["instructors"],
        &["instruction"],
        &["instructor"],
        &["instrumental"],
        &["instrument"],
        &["instrumentation"],
        &["instrumented"],
        &["instrumented"],
        &["instrumentation"],
        &["instrumentation"],
        &["instruments"],
        &["instrumental"],
        &["instrumental"],
        &["instrument"],
        &["instruments"],
        &["instruction"],
        &["instructions"],
    ],
    range: 3..=11,
};

static WORD_INSTN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INSTN_CHILDREN),
    value: None,
};

pub static WORD_INSTN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ace"),
        dictgen::InsensitiveStr::Ascii("aces"),
        dictgen::InsensitiveStr::Ascii("ance"),
        dictgen::InsensitiveStr::Ascii("ances"),
        dictgen::InsensitiveStr::Ascii("at"),
        dictgen::InsensitiveStr::Ascii("atiated"),
        dictgen::InsensitiveStr::Ascii("atiation"),
        dictgen::InsensitiveStr::Ascii("atiations"),
        dictgen::InsensitiveStr::Ascii("ce"),
        dictgen::InsensitiveStr::Ascii("ces"),
        dictgen::InsensitiveStr::Ascii("siated"),
        dictgen::InsensitiveStr::Ascii("siation"),
        dictgen::InsensitiveStr::Ascii("siations"),
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("tly"),
    ],
    values: &[
        &["instance"],
        &["instances"],
        &["instance"],
        &["instances"],
        &["instant"],
        &["instantiated"],
        &["instantiation"],
        &["instantiations"],
        &["instance"],
        &["instances"],
        &["instantiated"],
        &["instantiation"],
        &["instantiations"],
        &["instant"],
        &["instantly"],
    ],
    range: 1..=9,
};

static WORD_INSTL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INSTL_CHILDREN),
    value: None,
};

pub static WORD_INSTL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("al"),
        dictgen::InsensitiveStr::Ascii("alation"),
        dictgen::InsensitiveStr::Ascii("alations"),
        dictgen::InsensitiveStr::Ascii("aled"),
        dictgen::InsensitiveStr::Ascii("aler"),
        dictgen::InsensitiveStr::Ascii("aling"),
        dictgen::InsensitiveStr::Ascii("als"),
        dictgen::InsensitiveStr::Ascii("l"),
        dictgen::InsensitiveStr::Ascii("lation"),
        dictgen::InsensitiveStr::Ascii("lations"),
        dictgen::InsensitiveStr::Ascii("led"),
        dictgen::InsensitiveStr::Ascii("ler"),
        dictgen::InsensitiveStr::Ascii("ling"),
        dictgen::InsensitiveStr::Ascii("ls"),
    ],
    values: &[
        &["instal"],
        &["installation"],
        &["installations"],
        &["installed"],
        &["installer"],
        &["installing"],
        &["instals"],
        &["install", "instill"],
        &["installation", "instillation"],
        &["installations", "instillations"],
        &["installed", "instilled"],
        &["installer"],
        &["installing", "instilling"],
        &["installs", "instills"],
    ],
    range: 1..=8,
};

static WORD_INSTI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INSTI_CHILDREN),
    value: None,
};

pub static WORD_INSTI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cnt"),
        dictgen::InsensitiveStr::Ascii("cnts"),
        dictgen::InsensitiveStr::Ascii("ncitvely"),
        dictgen::InsensitiveStr::Ascii("ncs"),
        dictgen::InsensitiveStr::Ascii("nctivelly"),
        dictgen::InsensitiveStr::Ascii("nctivley"),
        dictgen::InsensitiveStr::Ascii("nctivly"),
        dictgen::InsensitiveStr::Ascii("nt"),
        dictgen::InsensitiveStr::Ascii("titional"),
        dictgen::InsensitiveStr::Ascii("tucion"),
        dictgen::InsensitiveStr::Ascii("tucionalized"),
        dictgen::InsensitiveStr::Ascii("tude"),
        dictgen::InsensitiveStr::Ascii("tuded"),
        dictgen::InsensitiveStr::Ascii("tue"),
        dictgen::InsensitiveStr::Ascii("tuion"),
        dictgen::InsensitiveStr::Ascii("tutie"),
        dictgen::InsensitiveStr::Ascii("tutiei"),
        dictgen::InsensitiveStr::Ascii("tutionale"),
        dictgen::InsensitiveStr::Ascii("tutionals"),
        dictgen::InsensitiveStr::Ascii("tutionel"),
        dictgen::InsensitiveStr::Ascii("tutionella"),
        dictgen::InsensitiveStr::Ascii("tutionilized"),
        dictgen::InsensitiveStr::Ascii("tutionlized"),
        dictgen::InsensitiveStr::Ascii("tutionnal"),
        dictgen::InsensitiveStr::Ascii("tutionnels"),
        dictgen::InsensitiveStr::Ascii("tuto"),
        dictgen::InsensitiveStr::Ascii("tuttet"),
        dictgen::InsensitiveStr::Ascii("tutue"),
        dictgen::InsensitiveStr::Ascii("tutuion"),
    ],
    values: &[
        &["instinct"],
        &["instincts"],
        &["instinctively"],
        &["instincts"],
        &["instinctively"],
        &["instinctively"],
        &["instinctively"],
        &["instinct"],
        &["institutional"],
        &["institution"],
        &["institutionalized"],
        &["instituted"],
        &["instituted"],
        &["institute"],
        &["institution"],
        &["institute"],
        &["institute"],
        &["institutionalized"],
        &["institutions"],
        &["institutional"],
        &["institutional"],
        &["institutionalized"],
        &["institutionalized"],
        &["institutional"],
        &["institutions"],
        &["institution"],
        &["institute"],
        &["instituted"],
        &["institution"],
    ],
    range: 2..=12,
};

static WORD_INSTE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INSTE_CHILDREN),
    value: None,
};

pub static WORD_INSTE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("alled"),
        dictgen::InsensitiveStr::Ascii("ance"),
        dictgen::InsensitiveStr::Ascii("d"),
        dictgen::InsensitiveStr::Ascii("ead"),
        dictgen::InsensitiveStr::Ascii("lling"),
        dictgen::InsensitiveStr::Ascii("r"),
        dictgen::InsensitiveStr::Ascii("rad"),
        dictgen::InsensitiveStr::Ascii("red"),
        dictgen::InsensitiveStr::Ascii("ring"),
        dictgen::InsensitiveStr::Ascii("rrupts"),
        dictgen::InsensitiveStr::Ascii("rsction"),
        dictgen::InsensitiveStr::Ascii("rsctions"),
        dictgen::InsensitiveStr::Ascii("rsection"),
        dictgen::InsensitiveStr::Ascii("rsectional"),
        dictgen::InsensitiveStr::Ascii("rsectionality"),
        dictgen::InsensitiveStr::Ascii("rsectioned"),
        dictgen::InsensitiveStr::Ascii("rsections"),
        dictgen::InsensitiveStr::Ascii("rt"),
        dictgen::InsensitiveStr::Ascii("rted"),
        dictgen::InsensitiveStr::Ascii("rtion"),
    ],
    values: &[
        &["installed"],
        &["instance"],
        &["instead"],
        &["instead"],
        &["installing"],
        &["insert"],
        &["instead"],
        &["inserted"],
        &["inserting"],
        &["interrupts"],
        &["intersection"],
        &["intersections"],
        &["intersection"],
        &["intersectional"],
        &["intersectionality"],
        &["intersection"],
        &["intersections"],
        &["insert"],
        &["inserted"],
        &["insertion"],
    ],
    range: 1..=13,
};

static WORD_INSTA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_INSTA_CHILDREN),
    value: None,
};

static WORD_INSTA_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_INSTAA_NODE),
    Some(&WORD_INSTAB_NODE),
    Some(&WORD_INSTAC_NODE),
    Some(&WORD_INSTAD_NODE),
    Some(&WORD_INSTAE_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_INSTAL_NODE),
    None,
    Some(&WORD_INSTAN_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_INSTAT_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_INSTAT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INSTAT_CHILDREN),
    value: None,
};

pub static WORD_INSTAT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ance"),
        dictgen::InsensitiveStr::Ascii("iate"),
        dictgen::InsensitiveStr::Ascii("iating"),
        dictgen::InsensitiveStr::Ascii("iation"),
        dictgen::InsensitiveStr::Ascii("iations"),
        dictgen::InsensitiveStr::Ascii("utionalized"),
    ],
    values: &[
        &["instance"],
        &["instantiate"],
        &["instantiating"],
        &["instantiation"],
        &["instantiations"],
        &["institutionalized"],
    ],
    range: 4..=11,
};

static WORD_INSTAN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INSTAN_CHILDREN),
    value: None,
};

pub static WORD_INSTAN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("atiation"),
        dictgen::InsensitiveStr::Ascii("cd"),
        dictgen::InsensitiveStr::Ascii("ciate"),
        dictgen::InsensitiveStr::Ascii("ciated"),
        dictgen::InsensitiveStr::Ascii("ciates"),
        dictgen::InsensitiveStr::Ascii("ciating"),
        dictgen::InsensitiveStr::Ascii("ciation"),
        dictgen::InsensitiveStr::Ascii("ciations"),
        dictgen::InsensitiveStr::Ascii("ct"),
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("se"),
        dictgen::InsensitiveStr::Ascii("seation"),
        dictgen::InsensitiveStr::Ascii("siate"),
        dictgen::InsensitiveStr::Ascii("siated"),
        dictgen::InsensitiveStr::Ascii("siates"),
        dictgen::InsensitiveStr::Ascii("siation"),
        dictgen::InsensitiveStr::Ascii("taenous"),
        dictgen::InsensitiveStr::Ascii("taneos"),
        dictgen::InsensitiveStr::Ascii("taneoulsy"),
        dictgen::InsensitiveStr::Ascii("taneu"),
        dictgen::InsensitiveStr::Ascii("taneus"),
        dictgen::InsensitiveStr::Ascii("tanious"),
        dictgen::InsensitiveStr::Ascii("tanous"),
        dictgen::InsensitiveStr::Ascii("tate"),
        dictgen::InsensitiveStr::Ascii("tating"),
        dictgen::InsensitiveStr::Ascii("tation"),
        dictgen::InsensitiveStr::Ascii("tations"),
        dictgen::InsensitiveStr::Ascii("teneous"),
        dictgen::InsensitiveStr::Ascii("tenious"),
        dictgen::InsensitiveStr::Ascii("tialed"),
        dictgen::InsensitiveStr::Ascii("tiaties"),
        dictgen::InsensitiveStr::Ascii("tiatoins"),
        dictgen::InsensitiveStr::Ascii("ty"),
        dictgen::InsensitiveStr::Ascii("ze"),
    ],
    values: &[
        &["instantiation"],
        &["instance"],
        &["instantiate"],
        &["instantiated"],
        &["instantiates"],
        &["instantiating"],
        &["instantiation"],
        &["instantiations"],
        &["instance"],
        &["instance"],
        &["instances"],
        &["instances"],
        &["instantiation"],
        &["instantiate"],
        &["instantiated"],
        &["instantiates"],
        &["instantiation"],
        &["instantaneous"],
        &["instantaneous"],
        &["instantaneous"],
        &["instantaneous"],
        &["instantaneous"],
        &["instantaneous"],
        &["instantaneous"],
        &["instantiate"],
        &["instantiating"],
        &["instantiation"],
        &["instantiations"],
        &["instantaneous"],
        &["instantaneous"],
        &["instantiated"],
        &["instantiates"],
        &["instantiations"],
        &["instantly"],
        &["instance"],
    ],
    range: 1..=9,
};

static WORD_INSTAL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INSTAL_CHILDREN),
    value: None,
};

pub static WORD_INSTAL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("altion"),
        dictgen::InsensitiveStr::Ascii("ation"),
        dictgen::InsensitiveStr::Ascii("ations"),
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("ement"),
        dictgen::InsensitiveStr::Ascii("er"),
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("laion"),
        dictgen::InsensitiveStr::Ascii("laiton"),
        dictgen::InsensitiveStr::Ascii("laitons"),
        dictgen::InsensitiveStr::Ascii("lataion"),
        dictgen::InsensitiveStr::Ascii("lataions"),
        dictgen::InsensitiveStr::Ascii("latation"),
        dictgen::InsensitiveStr::Ascii("latin"),
        dictgen::InsensitiveStr::Ascii("lating"),
        dictgen::InsensitiveStr::Ascii("lationa"),
        dictgen::InsensitiveStr::Ascii("latons"),
        dictgen::InsensitiveStr::Ascii("latron"),
        dictgen::InsensitiveStr::Ascii("le"),
        dictgen::InsensitiveStr::Ascii("leer"),
        dictgen::InsensitiveStr::Ascii("leert"),
        dictgen::InsensitiveStr::Ascii("lemnt"),
        dictgen::InsensitiveStr::Ascii("lent"),
        dictgen::InsensitiveStr::Ascii("les"),
        dictgen::InsensitiveStr::Ascii("lesd"),
        dictgen::InsensitiveStr::Ascii("lion"),
        dictgen::InsensitiveStr::Ascii("ll"),
        dictgen::InsensitiveStr::Ascii("lling"),
        dictgen::InsensitiveStr::Ascii("lmant"),
        dictgen::InsensitiveStr::Ascii("ltion"),
        dictgen::InsensitiveStr::Ascii("lus"),
    ],
    values: &[
        &["installations"],
        &["installation"],
        &["installations"],
        &["install"],
        &["installed"],
        &["installment"],
        &["installer"],
        &["installs"],
        &["installing"],
        &["installation"],
        &["installation"],
        &["installations"],
        &["installation"],
        &["installations"],
        &["installation"],
        &["installations"],
        &["installation"],
        &["installation"],
        &["installations"],
        &["installation"],
        &["installer", "installed", "install"],
        &["installer"],
        &["installer"],
        &["installment"],
        &["installment"],
        &["installs"],
        &["installs"],
        &["installing", "installation"],
        &["install"],
        &["installing"],
        &["installment"],
        &["installation"],
        &["installs"],
    ],
    range: 1..=8,
};

static WORD_INSTAE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INSTAE_CHILDREN),
    value: None,
};

pub static WORD_INSTAE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ad"),
        dictgen::InsensitiveStr::Ascii("d"),
    ],
    values: &[&["instead"], &["instead"]],
    range: 1..=2,
};

static WORD_INSTAD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INSTAD_CHILDREN),
    value: Some(&["instead"]),
};

pub static WORD_INSTAD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("e")],
    values: &[&["instead"]],
    range: 1..=1,
};

static WORD_INSTAC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INSTAC_CHILDREN),
    value: None,
};

pub static WORD_INSTAC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("iate"),
    ],
    values: &[&["instance"], &["instances"], &["instantiate"]],
    range: 1..=4,
};

static WORD_INSTAB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INSTAB_CHILDREN),
    value: None,
};

pub static WORD_INSTAB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ce"),
        dictgen::InsensitiveStr::Ascii("iliy"),
        dictgen::InsensitiveStr::Ascii("illity"),
        dictgen::InsensitiveStr::Ascii("ilt"),
        dictgen::InsensitiveStr::Ascii("ilty"),
    ],
    values: &[
        &["instance"],
        &["instability"],
        &["instability"],
        &["instability"],
        &["instability"],
    ],
    range: 2..=6,
};

static WORD_INSTAA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INSTAA_CHILDREN),
    value: None,
};

pub static WORD_INSTAA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("nce")],
    values: &[&["instance"]],
    range: 3..=3,
};

static WORD_INSR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INSR_CHILDREN),
    value: None,
};

pub static WORD_INSR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ugency")],
    values: &[&["insurgency"]],
    range: 6..=6,
};

static WORD_INSP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INSP_CHILDREN),
    value: None,
};

pub static WORD_INSP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aration"),
        dictgen::InsensitiveStr::Ascii("eccion"),
        dictgen::InsensitiveStr::Ascii("eciton"),
        dictgen::InsensitiveStr::Ascii("ecticon"),
        dictgen::InsensitiveStr::Ascii("ectin"),
        dictgen::InsensitiveStr::Ascii("ectons"),
        dictgen::InsensitiveStr::Ascii("ectoras"),
        dictgen::InsensitiveStr::Ascii("ectres"),
        dictgen::InsensitiveStr::Ascii("ektion"),
        dictgen::InsensitiveStr::Ascii("ektors"),
        dictgen::InsensitiveStr::Ascii("eration"),
        dictgen::InsensitiveStr::Ascii("erational"),
        dictgen::InsensitiveStr::Ascii("iracion"),
        dictgen::InsensitiveStr::Ascii("iraste"),
        dictgen::InsensitiveStr::Ascii("irating"),
        dictgen::InsensitiveStr::Ascii("irationnal"),
        dictgen::InsensitiveStr::Ascii("iraton"),
        dictgen::InsensitiveStr::Ascii("irerad"),
        dictgen::InsensitiveStr::Ascii("ireras"),
        dictgen::InsensitiveStr::Ascii("iritional"),
        dictgen::InsensitiveStr::Ascii("ite"),
        dictgen::InsensitiveStr::Ascii("riation"),
        dictgen::InsensitiveStr::Ascii("riational"),
        dictgen::InsensitiveStr::Ascii("ried"),
        dictgen::InsensitiveStr::Ascii("ries"),
    ],
    values: &[
        &["inspiration"],
        &["inspection"],
        &["inspections"],
        &["inspection"],
        &["inspection"],
        &["inspections"],
        &["inspectors"],
        &["inspectors"],
        &["inspection"],
        &["inspectors"],
        &["inspiration"],
        &["inspirational"],
        &["inspiration"],
        &["inspires"],
        &["inspiration"],
        &["inspirational"],
        &["inspiration"],
        &["inspired"],
        &["inspires"],
        &["inspirational"],
        &["inspire"],
        &["inspiration"],
        &["inspirational"],
        &["inspired"],
        &["inspires"],
    ],
    range: 3..=10,
};

static WORD_INSO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INSO_CHILDREN),
    value: None,
};

pub static WORD_INSO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("mina"),
        dictgen::InsensitiveStr::Ascii("nmia"),
        dictgen::InsensitiveStr::Ascii("nsistency"),
    ],
    values: &[&["insomnia"], &["insomnia"], &["inconsistency"]],
    range: 4..=9,
};

static WORD_INSM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INSM_CHILDREN),
    value: None,
};

pub static WORD_INSM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("onia")],
    values: &[&["insomnia"]],
    range: 4..=4,
};

static WORD_INSL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INSL_CHILDREN),
    value: None,
};

pub static WORD_INSL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("uated"),
        dictgen::InsensitiveStr::Ascii("uts"),
    ],
    values: &[&["insulated"], &["insults"]],
    range: 3..=5,
};

static WORD_INSI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INSI_CHILDREN),
    value: None,
};

pub static WORD_INSI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("d"),
        dictgen::InsensitiveStr::Ascii("dde"),
        dictgen::InsensitiveStr::Ascii("ddes"),
        dictgen::InsensitiveStr::Ascii("ded"),
        dictgen::InsensitiveStr::Ascii("dios"),
        dictgen::InsensitiveStr::Ascii("diuos"),
        dictgen::InsensitiveStr::Ascii("ginficant"),
        dictgen::InsensitiveStr::Ascii("ginifcant"),
        dictgen::InsensitiveStr::Ascii("gnifacnt"),
        dictgen::InsensitiveStr::Ascii("gnifiant"),
        dictgen::InsensitiveStr::Ascii("gnificat"),
        dictgen::InsensitiveStr::Ascii("gnificatly"),
        dictgen::InsensitiveStr::Ascii("gnificent"),
        dictgen::InsensitiveStr::Ascii("gnificunt"),
        dictgen::InsensitiveStr::Ascii("gnifigant"),
        dictgen::InsensitiveStr::Ascii("gt"),
        dictgen::InsensitiveStr::Ascii("gth"),
        dictgen::InsensitiveStr::Ascii("gths"),
        dictgen::InsensitiveStr::Ascii("gts"),
        dictgen::InsensitiveStr::Ascii("nuationg"),
        dictgen::InsensitiveStr::Ascii("pration"),
        dictgen::InsensitiveStr::Ascii("prational"),
        dictgen::InsensitiveStr::Ascii("pre"),
        dictgen::InsensitiveStr::Ascii("pred"),
        dictgen::InsensitiveStr::Ascii("pres"),
        dictgen::InsensitiveStr::Ascii("pring"),
        dictgen::InsensitiveStr::Ascii("stance"),
        dictgen::InsensitiveStr::Ascii("stas"),
        dictgen::InsensitiveStr::Ascii("stente"),
        dictgen::InsensitiveStr::Ascii("stenze"),
        dictgen::InsensitiveStr::Ascii("stes"),
        dictgen::InsensitiveStr::Ascii("stince"),
        dictgen::InsensitiveStr::Ascii("stis"),
        dictgen::InsensitiveStr::Ascii("titute"),
        dictgen::InsensitiveStr::Ascii("tution"),
        dictgen::InsensitiveStr::Ascii("tutions"),
    ],
    values: &[
        &["inside"],
        &["inside"],
        &["insides"],
        &["inside"],
        &["insidious"],
        &["insidious"],
        &["insignificant"],
        &["insignificant"],
        &["insignificant"],
        &["insignificant"],
        &["insignificant"],
        &["insignificantly"],
        &["insignificant"],
        &["insignificant"],
        &["insignificant"],
        &["insight"],
        &["insight"],
        &["insights"],
        &["insights"],
        &["insinuating"],
        &["inspiration"],
        &["inspirational"],
        &["inspire"],
        &["inspired"],
        &["inspires"],
        &["inspiring"],
        &["insistence"],
        &["insists"],
        &["insistence"],
        &["insistence"],
        &["insists"],
        &["insistence"],
        &["insists"],
        &["institute"],
        &["institution"],
        &["institutions"],
    ],
    range: 1..=10,
};

static WORD_INSE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INSE_CHILDREN),
    value: None,
};

pub static WORD_INSE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ad"),
        dictgen::InsensitiveStr::Ascii("ctes"),
        dictgen::InsensitiveStr::Ascii("ctiverous"),
        dictgen::InsensitiveStr::Ascii("ctos"),
        dictgen::InsensitiveStr::Ascii("curites"),
        dictgen::InsensitiveStr::Ascii("curitites"),
        dictgen::InsensitiveStr::Ascii("nsative"),
        dictgen::InsensitiveStr::Ascii("nsetive"),
        dictgen::InsensitiveStr::Ascii("nsistive"),
        dictgen::InsensitiveStr::Ascii("nsistively"),
        dictgen::InsensitiveStr::Ascii("nsitiv"),
        dictgen::InsensitiveStr::Ascii("nsitivy"),
        dictgen::InsensitiveStr::Ascii("nsitve"),
        dictgen::InsensitiveStr::Ascii("nstive"),
        dictgen::InsensitiveStr::Ascii("nstively"),
        dictgen::InsensitiveStr::Ascii("ntitive"),
        dictgen::InsensitiveStr::Ascii("ntive"),
        dictgen::InsensitiveStr::Ascii("ntives"),
        dictgen::InsensitiveStr::Ascii("ntivised"),
        dictgen::InsensitiveStr::Ascii("ntivises"),
        dictgen::InsensitiveStr::Ascii("ntivite"),
        dictgen::InsensitiveStr::Ascii("pct"),
        dictgen::InsensitiveStr::Ascii("pction"),
        dictgen::InsensitiveStr::Ascii("pctions"),
        dictgen::InsensitiveStr::Ascii("pctor"),
        dictgen::InsensitiveStr::Ascii("pect"),
        dictgen::InsensitiveStr::Ascii("pected"),
        dictgen::InsensitiveStr::Ascii("pection"),
        dictgen::InsensitiveStr::Ascii("pects"),
        dictgen::InsensitiveStr::Ascii("pendent"),
        dictgen::InsensitiveStr::Ascii("perable"),
        dictgen::InsensitiveStr::Ascii("psion"),
        dictgen::InsensitiveStr::Ascii("r"),
        dictgen::InsensitiveStr::Ascii("red"),
        dictgen::InsensitiveStr::Ascii("ring"),
        dictgen::InsensitiveStr::Ascii("rsect"),
        dictgen::InsensitiveStr::Ascii("rsected"),
        dictgen::InsensitiveStr::Ascii("rsecting"),
        dictgen::InsensitiveStr::Ascii("rsects"),
        dictgen::InsensitiveStr::Ascii("rst"),
        dictgen::InsensitiveStr::Ascii("rsted"),
        dictgen::InsensitiveStr::Ascii("rster"),
        dictgen::InsensitiveStr::Ascii("rsting"),
        dictgen::InsensitiveStr::Ascii("rstor"),
        dictgen::InsensitiveStr::Ascii("rsts"),
        dictgen::InsensitiveStr::Ascii("rtas"),
        dictgen::InsensitiveStr::Ascii("rtes"),
        dictgen::InsensitiveStr::Ascii("rtin"),
        dictgen::InsensitiveStr::Ascii("rtino"),
        dictgen::InsensitiveStr::Ascii("rtos"),
        dictgen::InsensitiveStr::Ascii("sitive"),
        dictgen::InsensitiveStr::Ascii("sitively"),
        dictgen::InsensitiveStr::Ascii("sitiveness"),
        dictgen::InsensitiveStr::Ascii("sitivity"),
        dictgen::InsensitiveStr::Ascii("tad"),
        dictgen::InsensitiveStr::Ascii("tead"),
        dictgen::InsensitiveStr::Ascii("ted"),
        dictgen::InsensitiveStr::Ascii("tion"),
    ],
    values: &[
        &["instead"],
        &["insects"],
        &["insectivorous"],
        &["insects"],
        &["insecurities"],
        &["insecurities"],
        &["insensitive"],
        &["insensitive"],
        &["insensitive"],
        &["insensitively"],
        &["insensitive"],
        &["insensitivity"],
        &["insensitive"],
        &["insensitive"],
        &["insensitively"],
        &["insensitive"],
        &["incentive", "insensitive"],
        &["incentives"],
        &["insensitive"],
        &["insensitive"],
        &["insensitive"],
        &["inspect"],
        &["inspection"],
        &["inspections"],
        &["inspector"],
        &["inspect"],
        &["inspected"],
        &["inspection"],
        &["inspects"],
        &["independent"],
        &["inseparable"],
        &["inception"],
        &["insert"],
        &["inserted"],
        &["inserting"],
        &["intersect"],
        &["intersected"],
        &["intersecting"],
        &["intersects"],
        &["insert"],
        &["inserted"],
        &["inserter"],
        &["inserting"],
        &["inserter"],
        &["inserts"],
        &["inserts"],
        &["inserts"],
        &["inserting"],
        &["inserting"],
        &["inserts"],
        &["insensitive"],
        &["insensitively"],
        &["insensitiveness"],
        &["insensitivity"],
        &["instead"],
        &["instead"],
        &["inserted"],
        &["insertion", "insection"],
    ],
    range: 1..=10,
};

static WORD_INSD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INSD_CHILDREN),
    value: None,
};

pub static WORD_INSD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("e")],
    values: &[&["inside"]],
    range: 1..=1,
};

static WORD_INSC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INSC_CHILDREN),
    value: None,
};

pub static WORD_INSC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ets"),
        dictgen::InsensitiveStr::Ascii("peting"),
        dictgen::InsensitiveStr::Ascii("tuction"),
        dictgen::InsensitiveStr::Ascii("tuctional"),
        dictgen::InsensitiveStr::Ascii("tuctions"),
    ],
    values: &[
        &["insects"],
        &["inspecting"],
        &["instruction"],
        &["instructional"],
        &["instructions"],
    ],
    range: 3..=9,
};

static WORD_INSA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INSA_CHILDREN),
    value: None,
};

pub static WORD_INSA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ll"),
        dictgen::InsensitiveStr::Ascii("llation"),
        dictgen::InsensitiveStr::Ascii("lled"),
        dictgen::InsensitiveStr::Ascii("lling"),
        dictgen::InsensitiveStr::Ascii("nce"),
        dictgen::InsensitiveStr::Ascii("nelly"),
        dictgen::InsensitiveStr::Ascii("ney"),
        dictgen::InsensitiveStr::Ascii("nley"),
        dictgen::InsensitiveStr::Ascii("tll"),
        dictgen::InsensitiveStr::Ascii("tlled"),
    ],
    values: &[
        &["install"],
        &["installation"],
        &["installed"],
        &["installing"],
        &["instance", "insane"],
        &["insanely"],
        &["insanely"],
        &["insanely"],
        &["install"],
        &["installed"],
    ],
    range: 2..=7,
};

static WORD_INR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INR_CHILDREN),
    value: None,
};

pub static WORD_INR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ement"),
        dictgen::InsensitiveStr::Ascii("ements"),
        dictgen::InsensitiveStr::Ascii("eractive"),
        dictgen::InsensitiveStr::Ascii("erface"),
        dictgen::InsensitiveStr::Ascii("esponsible"),
        dictgen::InsensitiveStr::Ascii("esponsive"),
        dictgen::InsensitiveStr::Ascii("ested"),
        dictgen::InsensitiveStr::Ascii("esting"),
        dictgen::InsensitiveStr::Ascii("o"),
    ],
    values: &[
        &["increment"],
        &["increments"],
        &["interactive"],
        &["interface"],
        &["irresponsible"],
        &["unresponsive"],
        &["inserted"],
        &["inserting"],
        &["into"],
    ],
    range: 1..=10,
};

static WORD_INQ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INQ_CHILDREN),
    value: None,
};

pub static WORD_INQ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("uier"),
        dictgen::InsensitiveStr::Ascii("uirey"),
        dictgen::InsensitiveStr::Ascii("uirie"),
        dictgen::InsensitiveStr::Ascii("uiriy"),
        dictgen::InsensitiveStr::Ascii("uisator"),
        dictgen::InsensitiveStr::Ascii("uisicion"),
        dictgen::InsensitiveStr::Ascii("uisidor"),
        dictgen::InsensitiveStr::Ascii("uisistor"),
        dictgen::InsensitiveStr::Ascii("uisiter"),
        dictgen::InsensitiveStr::Ascii("uisiting"),
        dictgen::InsensitiveStr::Ascii("uisitio"),
        dictgen::InsensitiveStr::Ascii("uisitior"),
        dictgen::InsensitiveStr::Ascii("uisitir"),
        dictgen::InsensitiveStr::Ascii("uisitivo"),
        dictgen::InsensitiveStr::Ascii("uisito"),
        dictgen::InsensitiveStr::Ascii("uisiton"),
        dictgen::InsensitiveStr::Ascii("uisitr"),
        dictgen::InsensitiveStr::Ascii("uistior"),
        dictgen::InsensitiveStr::Ascii("uizition"),
        dictgen::InsensitiveStr::Ascii("uizitor"),
        dictgen::InsensitiveStr::Ascii("uriy"),
        dictgen::InsensitiveStr::Ascii("usitior"),
    ],
    values: &[
        &["inquire"],
        &["inquiry"],
        &["inquire"],
        &["inquiry"],
        &["inquisitor"],
        &["inquisition"],
        &["inquisitor"],
        &["inquisitor"],
        &["inquisitor"],
        &["inquisition"],
        &["inquisitor"],
        &["inquisitor"],
        &["inquisitor"],
        &["inquisition"],
        &["inquisition"],
        &["inquisition"],
        &["inquisitor"],
        &["inquisitor"],
        &["inquisition"],
        &["inquisitor"],
        &["inquiry"],
        &["inquisitor"],
    ],
    range: 4..=8,
};

static WORD_INP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INP_CHILDREN),
    value: None,
};

pub static WORD_INP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("act"),
        dictgen::InsensitiveStr::Ascii("acted"),
        dictgen::InsensitiveStr::Ascii("acting"),
        dictgen::InsensitiveStr::Ascii("acts"),
        dictgen::InsensitiveStr::Ascii("each"),
        dictgen::InsensitiveStr::Ascii("ecting"),
        dictgen::InsensitiveStr::Ascii("ection"),
        dictgen::InsensitiveStr::Ascii("ections"),
        dictgen::InsensitiveStr::Ascii("ending"),
        dictgen::InsensitiveStr::Ascii("enetrable"),
        dictgen::InsensitiveStr::Ascii("erfections"),
        dictgen::InsensitiveStr::Ascii("ersonating"),
        dictgen::InsensitiveStr::Ascii("ired"),
        dictgen::InsensitiveStr::Ascii("lementation"),
        dictgen::InsensitiveStr::Ascii("lementations"),
        dictgen::InsensitiveStr::Ascii("lemented"),
        dictgen::InsensitiveStr::Ascii("lementing"),
        dictgen::InsensitiveStr::Ascii("lications"),
        dictgen::InsensitiveStr::Ascii("licit"),
        dictgen::InsensitiveStr::Ascii("licitly"),
        dictgen::InsensitiveStr::Ascii("olite"),
        dictgen::InsensitiveStr::Ascii("ort"),
        dictgen::InsensitiveStr::Ascii("ortant"),
        dictgen::InsensitiveStr::Ascii("osible"),
        dictgen::InsensitiveStr::Ascii("ossibility"),
        dictgen::InsensitiveStr::Ascii("ossible"),
        dictgen::InsensitiveStr::Ascii("out"),
        dictgen::InsensitiveStr::Ascii("outs"),
        dictgen::InsensitiveStr::Ascii("overished"),
        dictgen::InsensitiveStr::Ascii("ractical"),
        dictgen::InsensitiveStr::Ascii("racticality"),
        dictgen::InsensitiveStr::Ascii("ractically"),
        dictgen::InsensitiveStr::Ascii("redictable"),
        dictgen::InsensitiveStr::Ascii("risonment"),
        dictgen::InsensitiveStr::Ascii("roductive"),
        dictgen::InsensitiveStr::Ascii("roove"),
        dictgen::InsensitiveStr::Ascii("rooved"),
        dictgen::InsensitiveStr::Ascii("rooves"),
        dictgen::InsensitiveStr::Ascii("rooving"),
        dictgen::InsensitiveStr::Ascii("roovment"),
        dictgen::InsensitiveStr::Ascii("roovments"),
        dictgen::InsensitiveStr::Ascii("roper"),
        dictgen::InsensitiveStr::Ascii("roperly"),
        dictgen::InsensitiveStr::Ascii("rovements"),
        dictgen::InsensitiveStr::Ascii("roving"),
        dictgen::InsensitiveStr::Ascii("sect"),
        dictgen::InsensitiveStr::Ascii("section"),
        dictgen::InsensitiveStr::Ascii("sector"),
        dictgen::InsensitiveStr::Ascii("siration"),
        dictgen::InsensitiveStr::Ascii("sire"),
        dictgen::InsensitiveStr::Ascii("sired"),
        dictgen::InsensitiveStr::Ascii("siring"),
        dictgen::InsensitiveStr::Ascii("terpreter"),
        dictgen::InsensitiveStr::Ascii("u"),
        dictgen::InsensitiveStr::Ascii("ust"),
        dictgen::InsensitiveStr::Ascii("uted"),
        dictgen::InsensitiveStr::Ascii("utsream"),
        dictgen::InsensitiveStr::Ascii("uut"),
    ],
    values: &[
        &["impact"],
        &["impacted"],
        &["impacting"],
        &["impacts"],
        &["impeach"],
        &["inspecting"],
        &["inception", "inspection"],
        &["inspections"],
        &["impending"],
        &["impenetrable"],
        &["imperfections"],
        &["impersonating"],
        &["inspired"],
        &["implementation"],
        &["implementations"],
        &["implemented"],
        &["implementing"],
        &["implications"],
        &["implicit"],
        &["implicitly"],
        &["impolite"],
        &["import"],
        &["important"],
        &["impossible"],
        &["impossibility"],
        &["impossible"],
        &["input"],
        &["inputs"],
        &["impoverished"],
        &["impractical"],
        &["impracticality"],
        &["impractically"],
        &["unpredictable"],
        &["imprisonment"],
        &["unproductive"],
        &["improve"],
        &["improved"],
        &["improves"],
        &["improving"],
        &["improvement"],
        &["improvements"],
        &["improper"],
        &["improperly"],
        &["improvements"],
        &["improving"],
        &["inspect"],
        &["inspection"],
        &["inspector"],
        &["inspiration"],
        &["inspire"],
        &["inspired"],
        &["inspiring"],
        &["interpreter"],
        &["input"],
        &["input", "inputs"],
        &["inputted"],
        &["inputstream"],
        &["input"],
    ],
    range: 1..=12,
};

static WORD_INO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INO_CHILDREN),
    value: None,
};

pub static WORD_INO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cence"),
        dictgen::InsensitiveStr::Ascii("fficial"),
        dictgen::InsensitiveStr::Ascii("frmation"),
        dictgen::InsensitiveStr::Ascii("perant"),
        dictgen::InsensitiveStr::Ascii("quous"),
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("ut"),
        dictgen::InsensitiveStr::Ascii("uts"),
        dictgen::InsensitiveStr::Ascii("vker"),
    ],
    values: &[
        &["innocence"],
        &["unofficial"],
        &["information"],
        &["inoperative"],
        &["innocuous"],
        &["into"],
        &["input"],
        &["inputs"],
        &["invoker"],
    ],
    range: 1..=8,
};

static WORD_INN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INN_CHILDREN),
    value: None,
};

pub static WORD_INN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("active"),
        dictgen::InsensitiveStr::Ascii("acurate"),
        dictgen::InsensitiveStr::Ascii("acurately"),
        dictgen::InsensitiveStr::Ascii("appropriate"),
        dictgen::InsensitiveStr::Ascii("crement"),
        dictgen::InsensitiveStr::Ascii("crements"),
        dictgen::InsensitiveStr::Ascii("ecesarily"),
        dictgen::InsensitiveStr::Ascii("ecesary"),
        dictgen::InsensitiveStr::Ascii("ecessarily"),
        dictgen::InsensitiveStr::Ascii("ecessary"),
        dictgen::InsensitiveStr::Ascii("effectual"),
        dictgen::InsensitiveStr::Ascii("ersection"),
        dictgen::InsensitiveStr::Ascii("erstellar"),
        dictgen::InsensitiveStr::Ascii("itialize"),
        dictgen::InsensitiveStr::Ascii("oavtion"),
        dictgen::InsensitiveStr::Ascii("ocens"),
        dictgen::InsensitiveStr::Ascii("ocenters"),
        dictgen::InsensitiveStr::Ascii("ocentes"),
        dictgen::InsensitiveStr::Ascii("ocentius"),
        dictgen::InsensitiveStr::Ascii("ocous"),
        dictgen::InsensitiveStr::Ascii("oculate"),
        dictgen::InsensitiveStr::Ascii("oculated"),
        dictgen::InsensitiveStr::Ascii("ocuos"),
        dictgen::InsensitiveStr::Ascii("osense"),
        dictgen::InsensitiveStr::Ascii("otation"),
        dictgen::InsensitiveStr::Ascii("oucous"),
        dictgen::InsensitiveStr::Ascii("ovacion"),
        dictgen::InsensitiveStr::Ascii("ovaiton"),
        dictgen::InsensitiveStr::Ascii("ovatief"),
        dictgen::InsensitiveStr::Ascii("ovaties"),
        dictgen::InsensitiveStr::Ascii("ovatin"),
        dictgen::InsensitiveStr::Ascii("ovativo"),
        dictgen::InsensitiveStr::Ascii("ovatve"),
        dictgen::InsensitiveStr::Ascii("voate"),
        dictgen::InsensitiveStr::Ascii("voation"),
    ],
    values: &[
        &["inactive"],
        &["inaccurate"],
        &["inaccurately"],
        &["inappropriate"],
        &["increment"],
        &["increments"],
        &["unnecessarily"],
        &["unnecessary"],
        &["unnecessarily"],
        &["unnecessary"],
        &["ineffectual"],
        &["intersection"],
        &["interstellar"],
        &["initialize", "initializes"],
        &["innovations"],
        &["innocents"],
        &["innocents"],
        &["innocents"],
        &["innocents"],
        &["innocuous"],
        &["inoculate"],
        &["inoculated"],
        &["innocuous"],
        &["innocence"],
        &["innovation"],
        &["innocuous"],
        &["innovation"],
        &["innovations"],
        &["innovate"],
        &["innovate"],
        &["innovations"],
        &["innovation"],
        &["innovate"],
        &["innovate"],
        &["innovation"],
    ],
    range: 5..=11,
};

static WORD_INM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INM_CHILDREN),
    value: None,
};

pub static WORD_INM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ediate"),
        dictgen::InsensitiveStr::Ascii("ediatelly"),
        dictgen::InsensitiveStr::Ascii("ediately"),
        dictgen::InsensitiveStr::Ascii("ediatily"),
        dictgen::InsensitiveStr::Ascii("ediatly"),
        dictgen::InsensitiveStr::Ascii("ense"),
        dictgen::InsensitiveStr::Ascii("igrant"),
        dictgen::InsensitiveStr::Ascii("igrants"),
        dictgen::InsensitiveStr::Ascii("mediately"),
        dictgen::InsensitiveStr::Ascii("plementation"),
    ],
    values: &[
        &["immediate"],
        &["immediately"],
        &["immediately"],
        &["immediately"],
        &["immediately"],
        &["immense"],
        &["immigrant"],
        &["immigrants"],
        &["immediately"],
        &["implementation"],
    ],
    range: 4..=12,
};

static WORD_INL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INL_CHILDREN),
    value: None,
};

pub static WORD_INL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("alid"),
        dictgen::InsensitiveStr::Ascii("cine"),
        dictgen::InsensitiveStr::Ascii("clude"),
        dictgen::InsensitiveStr::Ascii("cluded"),
        dictgen::InsensitiveStr::Ascii("cludes"),
        dictgen::InsensitiveStr::Ascii("cluding"),
        dictgen::InsensitiveStr::Ascii("cludion"),
        dictgen::InsensitiveStr::Ascii("clusive"),
        dictgen::InsensitiveStr::Ascii("cude"),
        dictgen::InsensitiveStr::Ascii("cuded"),
        dictgen::InsensitiveStr::Ascii("cudes"),
        dictgen::InsensitiveStr::Ascii("cuding"),
        dictgen::InsensitiveStr::Ascii("cusion"),
        dictgen::InsensitiveStr::Ascii("cusive"),
        dictgen::InsensitiveStr::Ascii("ightening"),
        dictgen::InsensitiveStr::Ascii("in"),
        dictgen::InsensitiveStr::Ascii("ude"),
        dictgen::InsensitiveStr::Ascii("uded"),
        dictgen::InsensitiveStr::Ascii("udes"),
        dictgen::InsensitiveStr::Ascii("uding"),
        dictgen::InsensitiveStr::Ascii("udung"),
        dictgen::InsensitiveStr::Ascii("uence"),
        dictgen::InsensitiveStr::Ascii("usive"),
    ],
    values: &[
        &["invalid"],
        &["incline"],
        &["include"],
        &["included"],
        &["includes"],
        &["including"],
        &["inclusion"],
        &["inclusive"],
        &["include"],
        &["included"],
        &["includes"],
        &["including"],
        &["inclusion"],
        &["inclusive"],
        &["enlightening"],
        &["inline"],
        &["include"],
        &["included"],
        &["includes"],
        &["including"],
        &["including"],
        &["influence"],
        &["inclusive"],
    ],
    range: 2..=9,
};

static WORD_INK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INK_CHILDREN),
    value: None,
};

pub static WORD_INK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ompatible"),
        dictgen::InsensitiveStr::Ascii("ompetence"),
        dictgen::InsensitiveStr::Ascii("onsistent"),
    ],
    values: &[&["incompatible"], &["incompetence"], &["inconsistent"]],
    range: 9..=9,
};

static WORD_INJ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INJ_CHILDREN),
    value: None,
};

pub static WORD_INJ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ustaces"),
        dictgen::InsensitiveStr::Ascii("usticas"),
        dictgen::InsensitiveStr::Ascii("ustics"),
        dictgen::InsensitiveStr::Ascii("ustie"),
    ],
    values: &[
        &["injustices"],
        &["injustices"],
        &["injustices"],
        &["injustices"],
    ],
    range: 5..=7,
};

static WORD_INI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_INI_CHILDREN),
    value: None,
};

static WORD_INI_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_INIA_NODE),
    None,
    None,
    Some(&WORD_INID_NODE),
    Some(&WORD_INIE_NODE),
    Some(&WORD_INIF_NODE),
    None,
    None,
    Some(&WORD_INII_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_ININ_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_INIS_NODE),
    Some(&WORD_INIT_NODE),
    None,
    Some(&WORD_INIV_NODE),
    None,
    None,
    None,
    Some(&WORD_INIZ_NODE),
];

static WORD_INIZ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INIZ_CHILDREN),
    value: None,
};

pub static WORD_INIZ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ialize"),
        dictgen::InsensitiveStr::Ascii("ialized"),
        dictgen::InsensitiveStr::Ascii("ializes"),
    ],
    values: &[&["initialize"], &["initialized"], &["initializes"]],
    range: 6..=7,
};

static WORD_INIV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INIV_CHILDREN),
    value: None,
};

pub static WORD_INIV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("isible")],
    values: &[&["invisible"]],
    range: 6..=6,
};

static WORD_INIT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_INIT_CHILDREN),
    value: None,
};

static WORD_INIT_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_INITA_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_INITI_NODE),
    None,
    None,
    Some(&WORD_INITL_NODE),
    Some(&WORD_INITM_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_INITU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_INITU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INITU_CHILDREN),
    value: None,
};

pub static WORD_INITU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ialisation"),
        dictgen::InsensitiveStr::Ascii("ialization"),
        dictgen::InsensitiveStr::Ascii("ition"),
    ],
    values: &[&["initialisation"], &["initialization"], &["initiation"]],
    range: 5..=10,
};

static WORD_INITM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INITM_CHILDREN),
    value: None,
};

pub static WORD_INITM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("acy"),
        dictgen::InsensitiveStr::Ascii("ate"),
        dictgen::InsensitiveStr::Ascii("ately"),
        dictgen::InsensitiveStr::Ascii("idate"),
    ],
    values: &[
        &["intimacy"],
        &["intimate"],
        &["intimately"],
        &["intimidate"],
    ],
    range: 3..=5,
};

static WORD_INITL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INITL_CHILDREN),
    value: None,
};

pub static WORD_INITL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("iasation"),
        dictgen::InsensitiveStr::Ascii("iase"),
        dictgen::InsensitiveStr::Ascii("iased"),
        dictgen::InsensitiveStr::Ascii("iaser"),
        dictgen::InsensitiveStr::Ascii("iazation"),
        dictgen::InsensitiveStr::Ascii("iaze"),
        dictgen::InsensitiveStr::Ascii("iazed"),
        dictgen::InsensitiveStr::Ascii("iazer"),
    ],
    values: &[
        &["initialisation"],
        &["initialise"],
        &["initialised"],
        &["initialiser"],
        &["initialization"],
        &["initialize"],
        &["initialized"],
        &["initializer"],
    ],
    range: 4..=8,
};

static WORD_INITI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_INITI_CHILDREN),
    value: None,
};

static WORD_INITI_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_INITIA_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_INITII_NODE),
    None,
    None,
    Some(&WORD_INITIL_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_INITIS_NODE),
    Some(&WORD_INITIT_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_INITIT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INITIT_CHILDREN),
    value: None,
};

pub static WORD_INITIT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aive"),
        dictgen::InsensitiveStr::Ascii("alisation"),
        dictgen::InsensitiveStr::Ascii("alisations"),
        dictgen::InsensitiveStr::Ascii("alise"),
        dictgen::InsensitiveStr::Ascii("alised"),
        dictgen::InsensitiveStr::Ascii("aliser"),
        dictgen::InsensitiveStr::Ascii("alising"),
        dictgen::InsensitiveStr::Ascii("alization"),
        dictgen::InsensitiveStr::Ascii("alizations"),
        dictgen::InsensitiveStr::Ascii("alize"),
        dictgen::InsensitiveStr::Ascii("ate"),
        dictgen::InsensitiveStr::Ascii("ator"),
        dictgen::InsensitiveStr::Ascii("ialization"),
        dictgen::InsensitiveStr::Ascii("ializations"),
        dictgen::InsensitiveStr::Ascii("iave"),
        dictgen::InsensitiveStr::Ascii("iaves"),
    ],
    values: &[
        &["initiatives"],
        &["initialisation"],
        &["initialisations"],
        &["initialise"],
        &["initialised"],
        &["initialiser"],
        &["initialising"],
        &["initialization"],
        &["initializations"],
        &["initialize"],
        &["initiate"],
        &["initiator"],
        &["initialization"],
        &["initializations"],
        &["initiatives"],
        &["initiatives"],
    ],
    range: 3..=11,
};

static WORD_INITIS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INITIS_CHILDREN),
    value: None,
};

pub static WORD_INITIS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("l")],
    values: &[&["initials"]],
    range: 1..=1,
};

static WORD_INITIL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INITIL_CHILDREN),
    value: None,
};

pub static WORD_INITIL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("alize"),
        dictgen::InsensitiveStr::Ascii("ialised"),
        dictgen::InsensitiveStr::Ascii("ialization"),
        dictgen::InsensitiveStr::Ascii("ializations"),
        dictgen::InsensitiveStr::Ascii("ialize"),
        dictgen::InsensitiveStr::Ascii("ialized"),
        dictgen::InsensitiveStr::Ascii("ializes"),
        dictgen::InsensitiveStr::Ascii("ializing"),
        dictgen::InsensitiveStr::Ascii("iase"),
        dictgen::InsensitiveStr::Ascii("iased"),
        dictgen::InsensitiveStr::Ascii("iases"),
        dictgen::InsensitiveStr::Ascii("iasing"),
        dictgen::InsensitiveStr::Ascii("iaze"),
        dictgen::InsensitiveStr::Ascii("iazed"),
        dictgen::InsensitiveStr::Ascii("iazes"),
        dictgen::InsensitiveStr::Ascii("iazing"),
        dictgen::InsensitiveStr::Ascii("isation"),
        dictgen::InsensitiveStr::Ascii("isations"),
        dictgen::InsensitiveStr::Ascii("ise"),
        dictgen::InsensitiveStr::Ascii("ised"),
        dictgen::InsensitiveStr::Ascii("ises"),
        dictgen::InsensitiveStr::Ascii("ising"),
        dictgen::InsensitiveStr::Ascii("ization"),
        dictgen::InsensitiveStr::Ascii("izations"),
        dictgen::InsensitiveStr::Ascii("ize"),
        dictgen::InsensitiveStr::Ascii("ized"),
        dictgen::InsensitiveStr::Ascii("izer"),
        dictgen::InsensitiveStr::Ascii("izes"),
        dictgen::InsensitiveStr::Ascii("izing"),
    ],
    values: &[
        &["initialize"],
        &["initialised"],
        &["initialization"],
        &["initializations"],
        &["initialize"],
        &["initialized"],
        &["initializes"],
        &["initializing"],
        &["initialise"],
        &["initialised"],
        &["initialises"],
        &["initialising"],
        &["initialize"],
        &["initialized"],
        &["initializes"],
        &["initializing"],
        &["initialisation"],
        &["initialisations"],
        &["initialise"],
        &["initialised"],
        &["initialises"],
        &["initialising"],
        &["initialization"],
        &["initializations"],
        &["initialize"],
        &["initialized"],
        &["initializer"],
        &["initializes"],
        &["initializing"],
    ],
    range: 3..=11,
};

static WORD_INITII_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INITII_CHILDREN),
    value: None,
};

pub static WORD_INITII_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("alise"),
        dictgen::InsensitiveStr::Ascii("alize"),
    ],
    values: &[&["initialise"], &["initialize"]],
    range: 5..=5,
};

static WORD_INITIA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_INITIA_CHILDREN),
    value: None,
};

static WORD_INITIA_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_INITIAI_NODE),
    None,
    None,
    Some(&WORD_INITIAL_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_INITIAT_NODE),
    None,
    Some(&WORD_INITIAV_NODE),
    None,
    None,
    None,
    None,
];

static WORD_INITIAV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INITIAV_CHILDREN),
    value: None,
};

pub static WORD_INITIAV_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[dictgen::InsensitiveStr::Ascii("ite")],
        values: &[&["initiatives"]],
        range: 3..=3,
    };

static WORD_INITIAT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INITIAT_CHILDREN),
    value: None,
};

pub static WORD_INITIAT_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("iate"),
            dictgen::InsensitiveStr::Ascii("iated"),
            dictgen::InsensitiveStr::Ascii("iater"),
            dictgen::InsensitiveStr::Ascii("iating"),
            dictgen::InsensitiveStr::Ascii("iator"),
            dictgen::InsensitiveStr::Ascii("iats"),
            dictgen::InsensitiveStr::Ascii("ie"),
            dictgen::InsensitiveStr::Ascii("ied"),
            dictgen::InsensitiveStr::Ascii("ies"),
            dictgen::InsensitiveStr::Ascii("in"),
            dictgen::InsensitiveStr::Ascii("ivs"),
            dictgen::InsensitiveStr::Ascii("ve"),
            dictgen::InsensitiveStr::Ascii("ves"),
        ],
        values: &[
            &["initiate"],
            &["initiated"],
            &["initiator"],
            &["initiating"],
            &["initiator"],
            &["initiates"],
            &["initiatives", "initiate"],
            &["initiated"],
            &["initiatives", "initiates"],
            &["initiation"],
            &["initiatives"],
            &["initiate"],
            &["initiatives"],
        ],
        range: 2..=6,
    };

static WORD_INITIAL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_INITIAL_CHILDREN),
    value: None,
};

static WORD_INITIAL_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    None,
    None,
    Some(&WORD_INITIALE_NODE),
    None,
    None,
    None,
    Some(&WORD_INITIALI_NODE),
    None,
    None,
    Some(&WORD_INITIALL_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_INITIALS_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_INITIALY_NODE),
    Some(&WORD_INITIALZ_NODE),
];

static WORD_INITIALZ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INITIALZ_CHILDREN),
    value: None,
};

pub static WORD_INITIALZ_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("ation"),
            dictgen::InsensitiveStr::Ascii("e"),
            dictgen::InsensitiveStr::Ascii("ed"),
            dictgen::InsensitiveStr::Ascii("er"),
            dictgen::InsensitiveStr::Ascii("es"),
            dictgen::InsensitiveStr::Ascii("ie"),
            dictgen::InsensitiveStr::Ascii("ier"),
            dictgen::InsensitiveStr::Ascii("ing"),
        ],
        values: &[
            &["initialization"],
            &["initialize"],
            &["initialized"],
            &["initializer"],
            &["initializes"],
            &["initialize"],
            &["initializer"],
            &["initializing"],
        ],
        range: 1..=5,
    };

static WORD_INITIALY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INITIALY_CHILDREN),
    value: Some(&["initially"]),
};

pub static WORD_INITIALY_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("l"),
            dictgen::InsensitiveStr::Ascii("se"),
            dictgen::InsensitiveStr::Ascii("sed"),
            dictgen::InsensitiveStr::Ascii("ses"),
            dictgen::InsensitiveStr::Ascii("sing"),
            dictgen::InsensitiveStr::Ascii("ze"),
            dictgen::InsensitiveStr::Ascii("zed"),
            dictgen::InsensitiveStr::Ascii("zes"),
            dictgen::InsensitiveStr::Ascii("zing"),
        ],
        values: &[
            &["initially"],
            &["initialise"],
            &["initialised"],
            &["initialises"],
            &["initialising"],
            &["initialize"],
            &["initialized"],
            &["initializes"],
            &["initializing"],
        ],
        range: 1..=4,
    };

static WORD_INITIALS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INITIALS_CHILDREN),
    value: None,
};

pub static WORD_INITIALS_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("ation"),
            dictgen::InsensitiveStr::Ascii("e"),
            dictgen::InsensitiveStr::Ascii("ed"),
            dictgen::InsensitiveStr::Ascii("es"),
            dictgen::InsensitiveStr::Ascii("ing"),
        ],
        values: &[
            &["initialisation"],
            &["initialise"],
            &["initialised"],
            &["initialises"],
            &["initialising"],
        ],
        range: 1..=5,
    };

static WORD_INITIALL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INITIALL_CHILDREN),
    value: Some(&["initial", "initially"]),
};

pub static WORD_INITIALL_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[],
        values: &[],
        range: 0..=0,
    };

static WORD_INITIALI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INITIALI_CHILDREN),
    value: None,
};

pub static WORD_INITIALI_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("alise"),
            dictgen::InsensitiveStr::Ascii("alize"),
            dictgen::InsensitiveStr::Ascii("asation"),
            dictgen::InsensitiveStr::Ascii("ase"),
            dictgen::InsensitiveStr::Ascii("ased"),
            dictgen::InsensitiveStr::Ascii("ation"),
            dictgen::InsensitiveStr::Ascii("azation"),
            dictgen::InsensitiveStr::Ascii("aze"),
            dictgen::InsensitiveStr::Ascii("azed"),
            dictgen::InsensitiveStr::Ascii("ed"),
            dictgen::InsensitiveStr::Ascii("lsing"),
            dictgen::InsensitiveStr::Ascii("lzing"),
            dictgen::InsensitiveStr::Ascii("saing"),
            dictgen::InsensitiveStr::Ascii("saiton"),
            dictgen::InsensitiveStr::Ascii("sated"),
            dictgen::InsensitiveStr::Ascii("satin"),
            dictgen::InsensitiveStr::Ascii("sationg"),
            dictgen::InsensitiveStr::Ascii("saton"),
            dictgen::InsensitiveStr::Ascii("satons"),
            dictgen::InsensitiveStr::Ascii("seing"),
            dictgen::InsensitiveStr::Ascii("siation"),
            dictgen::InsensitiveStr::Ascii("siert"),
            dictgen::InsensitiveStr::Ascii("song"),
            dictgen::InsensitiveStr::Ascii("ss"),
            dictgen::InsensitiveStr::Ascii("ting"),
            dictgen::InsensitiveStr::Ascii("tse"),
            dictgen::InsensitiveStr::Ascii("tsing"),
            dictgen::InsensitiveStr::Ascii("tze"),
            dictgen::InsensitiveStr::Ascii("tzing"),
            dictgen::InsensitiveStr::Ascii("za"),
            dictgen::InsensitiveStr::Ascii("zad"),
            dictgen::InsensitiveStr::Ascii("zaed"),
            dictgen::InsensitiveStr::Ascii("zaing"),
            dictgen::InsensitiveStr::Ascii("zaion"),
            dictgen::InsensitiveStr::Ascii("zaiton"),
            dictgen::InsensitiveStr::Ascii("zate"),
            dictgen::InsensitiveStr::Ascii("zated"),
            dictgen::InsensitiveStr::Ascii("zates"),
            dictgen::InsensitiveStr::Ascii("zatin"),
            dictgen::InsensitiveStr::Ascii("zating"),
            dictgen::InsensitiveStr::Ascii("zationg"),
            dictgen::InsensitiveStr::Ascii("zaton"),
            dictgen::InsensitiveStr::Ascii("zatons"),
            dictgen::InsensitiveStr::Ascii("zedd"),
            dictgen::InsensitiveStr::Ascii("zeing"),
            dictgen::InsensitiveStr::Ascii("ziation"),
            dictgen::InsensitiveStr::Ascii("zong"),
            dictgen::InsensitiveStr::Ascii("zs"),
        ],
        values: &[
            &["initialise"],
            &["initialize"],
            &["initialisation"],
            &["initialise"],
            &["initialised"],
            &["initialization"],
            &["initialization"],
            &["initialize"],
            &["initialized"],
            &["initialized"],
            &["initialising"],
            &["initializing"],
            &["initialising"],
            &["initialisation"],
            &["initialised"],
            &["initialisation"],
            &["initialisation"],
            &["initialisation"],
            &["initialisations"],
            &["initialising"],
            &["initialisation"],
            &["initialised"],
            &["initialising"],
            &["initialise", "initialises"],
            &["initializing"],
            &["initialise"],
            &["initialising"],
            &["initialize"],
            &["initializing"],
            &["initialize"],
            &["initialized"],
            &["initialized"],
            &["initializing"],
            &["initialization"],
            &["initialization"],
            &["initialize"],
            &["initialized"],
            &["initializes"],
            &["initialization"],
            &["initializing"],
            &["initialization"],
            &["initialization"],
            &["initializations"],
            &["initialized"],
            &["initializing"],
            &["initialization"],
            &["initializing"],
            &["initialize", "initializes"],
        ],
        range: 2..=7,
    };

static WORD_INITIALE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INITIALE_CHILDREN),
    value: None,
};

pub static WORD_INITIALE_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[dictgen::InsensitiveStr::Ascii("s")],
        values: &[&["initials", "initialise", "initializes", "initialises"]],
        range: 1..=1,
    };

static WORD_INITIAI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INITIAI_CHILDREN),
    value: None,
};

pub static WORD_INITIAI_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("lize"),
            dictgen::InsensitiveStr::Ascii("lized"),
            dictgen::InsensitiveStr::Ascii("lizes"),
            dictgen::InsensitiveStr::Ascii("lizing"),
            dictgen::InsensitiveStr::Ascii("tive"),
            dictgen::InsensitiveStr::Ascii("tives"),
            dictgen::InsensitiveStr::Ascii("tve"),
        ],
        values: &[
            &["initialize"],
            &["initialized"],
            &["initializes"],
            &["initializing"],
            &["initiative"],
            &["initiatives"],
            &["initiatives"],
        ],
        range: 3..=6,
    };

static WORD_INITA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_INITA_CHILDREN),
    value: None,
};

static WORD_INITA_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_INITAI_NODE),
    None,
    None,
    Some(&WORD_INITAL_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_INITAT_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_INITAT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INITAT_CHILDREN),
    value: None,
};

pub static WORD_INITAT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("ion"),
        dictgen::InsensitiveStr::Ascii("ions"),
        dictgen::InsensitiveStr::Ascii("or"),
        dictgen::InsensitiveStr::Ascii("ors"),
    ],
    values: &[
        &["initiate", "imitate"],
        &["initiated", "imitated"],
        &["imitates", "initiates"],
        &["imitating", "initiating"],
        &["initiation", "imitation"],
        &["imitations", "initiations"],
        &["imitator", "initiator"],
        &["initiators", "imitators"],
    ],
    range: 1..=4,
};

static WORD_INITAL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INITAL_CHILDREN),
    value: Some(&["initial"]),
};

pub static WORD_INITAL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("ese"),
        dictgen::InsensitiveStr::Ascii("ialisation"),
        dictgen::InsensitiveStr::Ascii("ialization"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("isation"),
        dictgen::InsensitiveStr::Ascii("isations"),
        dictgen::InsensitiveStr::Ascii("ise"),
        dictgen::InsensitiveStr::Ascii("ised"),
        dictgen::InsensitiveStr::Ascii("iser"),
        dictgen::InsensitiveStr::Ascii("isers"),
        dictgen::InsensitiveStr::Ascii("ises"),
        dictgen::InsensitiveStr::Ascii("ising"),
        dictgen::InsensitiveStr::Ascii("ism"),
        dictgen::InsensitiveStr::Ascii("isms"),
        dictgen::InsensitiveStr::Ascii("izable"),
        dictgen::InsensitiveStr::Ascii("ization"),
        dictgen::InsensitiveStr::Ascii("izations"),
        dictgen::InsensitiveStr::Ascii("ize"),
        dictgen::InsensitiveStr::Ascii("ized"),
        dictgen::InsensitiveStr::Ascii("izer"),
        dictgen::InsensitiveStr::Ascii("izers"),
        dictgen::InsensitiveStr::Ascii("izes"),
        dictgen::InsensitiveStr::Ascii("izing"),
        dictgen::InsensitiveStr::Ascii("led"),
        dictgen::InsensitiveStr::Ascii("ling"),
        dictgen::InsensitiveStr::Ascii("ly"),
        dictgen::InsensitiveStr::Ascii("ness"),
        dictgen::InsensitiveStr::Ascii("s"),
    ],
    values: &[
        &["initialed"],
        &["initialese"],
        &["initialisation"],
        &["initialization"],
        &["initialing"],
        &["initialisation"],
        &["initialisations"],
        &["initialise"],
        &["initialised"],
        &["initialiser"],
        &["initialisers"],
        &["initialises"],
        &["initialising"],
        &["initialism"],
        &["initialisms"],
        &["initializable"],
        &["initialization"],
        &["initializations"],
        &["initialize"],
        &["initialized"],
        &["initializer"],
        &["initializers"],
        &["initializes"],
        &["initializing"],
        &["initialled"],
        &["initialling"],
        &["initially"],
        &["initialness"],
        &["initials"],
    ],
    range: 1..=10,
};

static WORD_INITAI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INITAI_CHILDREN),
    value: None,
};

pub static WORD_INITAI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("l"),
        dictgen::InsensitiveStr::Ascii("lisation"),
        dictgen::InsensitiveStr::Ascii("lise"),
        dictgen::InsensitiveStr::Ascii("lised"),
        dictgen::InsensitiveStr::Ascii("liser"),
        dictgen::InsensitiveStr::Ascii("lisers"),
        dictgen::InsensitiveStr::Ascii("lises"),
        dictgen::InsensitiveStr::Ascii("lising"),
        dictgen::InsensitiveStr::Ascii("lization"),
        dictgen::InsensitiveStr::Ascii("lize"),
        dictgen::InsensitiveStr::Ascii("lized"),
        dictgen::InsensitiveStr::Ascii("lizer"),
        dictgen::InsensitiveStr::Ascii("lizers"),
        dictgen::InsensitiveStr::Ascii("lizes"),
        dictgen::InsensitiveStr::Ascii("lizing"),
        dictgen::InsensitiveStr::Ascii("lly"),
        dictgen::InsensitiveStr::Ascii("ls"),
        dictgen::InsensitiveStr::Ascii("lsation"),
        dictgen::InsensitiveStr::Ascii("lse"),
        dictgen::InsensitiveStr::Ascii("lsed"),
        dictgen::InsensitiveStr::Ascii("lsiation"),
        dictgen::InsensitiveStr::Ascii("ly"),
        dictgen::InsensitiveStr::Ascii("lzation"),
        dictgen::InsensitiveStr::Ascii("lze"),
        dictgen::InsensitiveStr::Ascii("lzed"),
        dictgen::InsensitiveStr::Ascii("lziation"),
        dictgen::InsensitiveStr::Ascii("te"),
        dictgen::InsensitiveStr::Ascii("tion"),
        dictgen::InsensitiveStr::Ascii("tives"),
    ],
    values: &[
        &["initial"],
        &["initialisation"],
        &["initialise"],
        &["initialised"],
        &["initialiser"],
        &["initialisers"],
        &["initialises"],
        &["initialising"],
        &["initialization"],
        &["initialize"],
        &["initialized"],
        &["initializer"],
        &["initializers"],
        &["initializes"],
        &["initializing"],
        &["initially"],
        &["initials"],
        &["initialisation"],
        &["initialise"],
        &["initialised"],
        &["initialisation"],
        &["initially"],
        &["initialization"],
        &["initialize"],
        &["initialized"],
        &["initialization"],
        &["initiate"],
        &["initiation"],
        &["initiatives"],
    ],
    range: 1..=8,
};

static WORD_INIS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INIS_CHILDREN),
    value: None,
};

pub static WORD_INIS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ghts"),
        dictgen::InsensitiveStr::Ascii("ialise"),
        dictgen::InsensitiveStr::Ascii("ialised"),
        dictgen::InsensitiveStr::Ascii("ialises"),
        dictgen::InsensitiveStr::Ascii("ide"),
        dictgen::InsensitiveStr::Ascii("ides"),
    ],
    values: &[
        &["insights"],
        &["initialise"],
        &["initialised"],
        &["initialises"],
        &["inside"],
        &["insides"],
    ],
    range: 3..=7,
};

static WORD_ININ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ININ_CHILDREN),
    value: None,
};

pub static WORD_ININ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("telligent"),
        dictgen::InsensitiveStr::Ascii("terested"),
        dictgen::InsensitiveStr::Ascii("teresting"),
        dictgen::InsensitiveStr::Ascii("tialisation"),
        dictgen::InsensitiveStr::Ascii("tialization"),
    ],
    values: &[
        &["unintelligent"],
        &["uninterested"],
        &["uninteresting"],
        &["initialisation"],
        &["initialization"],
    ],
    range: 8..=11,
};

static WORD_INII_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INII_CHILDREN),
    value: None,
};

pub static WORD_INII_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("talize"),
        dictgen::InsensitiveStr::Ascii("tial"),
        dictgen::InsensitiveStr::Ascii("tialization"),
        dictgen::InsensitiveStr::Ascii("tializations"),
        dictgen::InsensitiveStr::Ascii("tialize"),
        dictgen::InsensitiveStr::Ascii("tialized"),
        dictgen::InsensitiveStr::Ascii("tializes"),
        dictgen::InsensitiveStr::Ascii("tializing"),
    ],
    values: &[
        &["initialize"],
        &["initial"],
        &["initialization"],
        &["initializations"],
        &["initialize"],
        &["initialized"],
        &["initializes"],
        &["initializing"],
    ],
    range: 4..=12,
};

static WORD_INIF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INIF_CHILDREN),
    value: None,
};

pub static WORD_INIF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("inite"),
        dictgen::InsensitiveStr::Ascii("inity"),
        dictgen::InsensitiveStr::Ascii("inte"),
        dictgen::InsensitiveStr::Ascii("ite"),
        dictgen::InsensitiveStr::Ascii("nite"),
        dictgen::InsensitiveStr::Ascii("nitely"),
        dictgen::InsensitiveStr::Ascii("nity"),
    ],
    values: &[
        &["infinite"],
        &["infinity"],
        &["infinite"],
        &["infinite"],
        &["infinite"],
        &["infinitely"],
        &["infinity"],
    ],
    range: 3..=6,
};

static WORD_INIE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INIE_CHILDREN),
    value: None,
};

pub static WORD_INIE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ct"),
        dictgen::InsensitiveStr::Ascii("cted"),
        dictgen::InsensitiveStr::Ascii("cting"),
        dictgen::InsensitiveStr::Ascii("ction"),
        dictgen::InsensitiveStr::Ascii("cts"),
    ],
    values: &[
        &["inject"],
        &["injected"],
        &["injecting"],
        &["injection"],
        &["injects"],
    ],
    range: 2..=5,
};

static WORD_INID_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INID_CHILDREN),
    value: None,
};

pub static WORD_INID_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ans"),
        dictgen::InsensitiveStr::Ascii("icate"),
        dictgen::InsensitiveStr::Ascii("icated"),
        dictgen::InsensitiveStr::Ascii("icates"),
        dictgen::InsensitiveStr::Ascii("icating"),
        dictgen::InsensitiveStr::Ascii("ication"),
        dictgen::InsensitiveStr::Ascii("ications"),
        dictgen::InsensitiveStr::Ascii("ividual"),
        dictgen::InsensitiveStr::Ascii("vidual"),
    ],
    values: &[
        &["indians"],
        &["indicate"],
        &["indicated"],
        &["indicates"],
        &["indicating"],
        &["indication"],
        &["indications"],
        &["individual"],
        &["individual"],
    ],
    range: 3..=8,
};

static WORD_INIA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INIA_CHILDREN),
    value: None,
};

pub static WORD_INIA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("lize"),
        dictgen::InsensitiveStr::Ascii("lized"),
        dictgen::InsensitiveStr::Ascii("te"),
    ],
    values: &[&["initialize"], &["initialized"], &["initiate"]],
    range: 2..=5,
};

static WORD_INH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INH_CHILDREN),
    value: Some(&["in"]),
};

pub static WORD_INH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("abitans"),
        dictgen::InsensitiveStr::Ascii("abitat"),
        dictgen::InsensitiveStr::Ascii("abitats"),
        dictgen::InsensitiveStr::Ascii("abitents"),
        dictgen::InsensitiveStr::Ascii("eirt"),
        dictgen::InsensitiveStr::Ascii("eirtance"),
        dictgen::InsensitiveStr::Ascii("eirted"),
        dictgen::InsensitiveStr::Ascii("erantly"),
        dictgen::InsensitiveStr::Ascii("eratance"),
        dictgen::InsensitiveStr::Ascii("eret"),
        dictgen::InsensitiveStr::Ascii("eretance"),
        dictgen::InsensitiveStr::Ascii("erets"),
        dictgen::InsensitiveStr::Ascii("eriable"),
        dictgen::InsensitiveStr::Ascii("erid"),
        dictgen::InsensitiveStr::Ascii("eriet"),
        dictgen::InsensitiveStr::Ascii("erint"),
        dictgen::InsensitiveStr::Ascii("erintly"),
        dictgen::InsensitiveStr::Ascii("eritablility"),
        dictgen::InsensitiveStr::Ascii("eritage"),
        dictgen::InsensitiveStr::Ascii("eritence"),
        dictgen::InsensitiveStr::Ascii("eritences"),
        dictgen::InsensitiveStr::Ascii("erith"),
        dictgen::InsensitiveStr::Ascii("erithed"),
        dictgen::InsensitiveStr::Ascii("erithing"),
        dictgen::InsensitiveStr::Ascii("eriths"),
        dictgen::InsensitiveStr::Ascii("eritted"),
        dictgen::InsensitiveStr::Ascii("ernetly"),
        dictgen::InsensitiveStr::Ascii("errit"),
        dictgen::InsensitiveStr::Ascii("erritance"),
        dictgen::InsensitiveStr::Ascii("errited"),
        dictgen::InsensitiveStr::Ascii("erriting"),
        dictgen::InsensitiveStr::Ascii("errits"),
        dictgen::InsensitiveStr::Ascii("ert"),
        dictgen::InsensitiveStr::Ascii("ertance"),
        dictgen::InsensitiveStr::Ascii("ertances"),
        dictgen::InsensitiveStr::Ascii("erted"),
        dictgen::InsensitiveStr::Ascii("ertiance"),
        dictgen::InsensitiveStr::Ascii("ertied"),
        dictgen::InsensitiveStr::Ascii("ertig"),
        dictgen::InsensitiveStr::Ascii("erting"),
        dictgen::InsensitiveStr::Ascii("erts"),
        dictgen::InsensitiveStr::Ascii("omogenous"),
        dictgen::InsensitiveStr::Ascii("umaan"),
        dictgen::InsensitiveStr::Ascii("umain"),
    ],
    values: &[
        &["inhabitants"],
        &["inhabitants"],
        &["inhabitants"],
        &["inhabitants"],
        &["inherit"],
        &["inheritance"],
        &["inherited"],
        &["inherently"],
        &["inheritance"],
        &["inherit"],
        &["inheritance"],
        &["inherits"],
        &["inheritable"],
        &["inherit"],
        &["inherit"],
        &["inherit"],
        &["inherently"],
        &["inheritability"],
        &["heritage", "inheritance"],
        &["inheritance"],
        &["inheritances"],
        &["inherit"],
        &["inherited"],
        &["inheriting"],
        &["inherits"],
        &["inherited"],
        &["inherently"],
        &["inherit"],
        &["inheritance"],
        &["inherited"],
        &["inheriting"],
        &["inherits"],
        &["inherit"],
        &["inheritance"],
        &["inheritances"],
        &["inherited"],
        &["inheritance"],
        &["inherited"],
        &["inheriting", "inherited"],
        &["inheriting"],
        &["inherits"],
        &["inhomogeneous"],
        &["inhuman"],
        &["inhuman"],
    ],
    range: 3..=12,
};

static WORD_ING_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ING_CHILDREN),
    value: None,
};

pub static WORD_ING_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("egral"),
        dictgen::InsensitiveStr::Ascii("egrated"),
        dictgen::InsensitiveStr::Ascii("enius"),
        dictgen::InsensitiveStr::Ascii("eniuty"),
        dictgen::InsensitiveStr::Ascii("enuitiy"),
        dictgen::InsensitiveStr::Ascii("erdients"),
        dictgen::InsensitiveStr::Ascii("estigator"),
        dictgen::InsensitiveStr::Ascii("eunity"),
        dictgen::InsensitiveStr::Ascii("ition"),
        dictgen::InsensitiveStr::Ascii("norar"),
        dictgen::InsensitiveStr::Ascii("nore"),
        dictgen::InsensitiveStr::Ascii("nored"),
        dictgen::InsensitiveStr::Ascii("nores"),
        dictgen::InsensitiveStr::Ascii("noring"),
        dictgen::InsensitiveStr::Ascii("ocnito"),
        dictgen::InsensitiveStr::Ascii("orance"),
        dictgen::InsensitiveStr::Ascii("orant"),
        dictgen::InsensitiveStr::Ascii("ore"),
        dictgen::InsensitiveStr::Ascii("ored"),
        dictgen::InsensitiveStr::Ascii("ores"),
        dictgen::InsensitiveStr::Ascii("oring"),
        dictgen::InsensitiveStr::Ascii("ration"),
        dictgen::InsensitiveStr::Ascii("rediant"),
        dictgen::InsensitiveStr::Ascii("rediants"),
        dictgen::InsensitiveStr::Ascii("rediens"),
        dictgen::InsensitiveStr::Ascii("redientes"),
        dictgen::InsensitiveStr::Ascii("rediets"),
        dictgen::InsensitiveStr::Ascii("reediants"),
        dictgen::InsensitiveStr::Ascii("reidents"),
        dictgen::InsensitiveStr::Ascii("riedents"),
        dictgen::InsensitiveStr::Ascii("uenity"),
    ],
    values: &[
        &["integral"],
        &["integrated"],
        &["ingenious"],
        &["ingenuity"],
        &["ingenuity"],
        &["ingredients"],
        &["investigator"],
        &["ingenuity"],
        &["ignition"],
        &["ignore", "ignorant"],
        &["ignore"],
        &["ignored"],
        &["ignores"],
        &["ignoring"],
        &["incognito"],
        &["ignorance"],
        &["ignorant"],
        &["ignore"],
        &["ignored"],
        &["ignores"],
        &["ignoring"],
        &["integration"],
        &["ingredient"],
        &["ingredients"],
        &["ingredients"],
        &["ingredients"],
        &["ingredient"],
        &["ingredients"],
        &["ingredient"],
        &["ingredient"],
        &["ingenuity"],
    ],
    range: 3..=9,
};

static WORD_INF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_INF_CHILDREN),
    value: None,
};

static WORD_INF_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_INFA_NODE),
    None,
    None,
    None,
    Some(&WORD_INFE_NODE),
    None,
    None,
    None,
    Some(&WORD_INFI_NODE),
    None,
    None,
    Some(&WORD_INFL_NODE),
    None,
    None,
    Some(&WORD_INFO_NODE),
    None,
    None,
    Some(&WORD_INFR_NODE),
    None,
    None,
    Some(&WORD_INFU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_INFU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INFU_CHILDREN),
    value: None,
};

pub static WORD_INFU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("lenced"),
        dictgen::InsensitiveStr::Ascii("lences"),
        dictgen::InsensitiveStr::Ascii("lential"),
    ],
    values: &[&["influenced"], &["influences"], &["influential"]],
    range: 6..=7,
};

static WORD_INFR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INFR_CHILDREN),
    value: None,
};

pub static WORD_INFR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("antryman"),
        dictgen::InsensitiveStr::Ascii("aread"),
        dictgen::InsensitiveStr::Ascii("asctructure"),
        dictgen::InsensitiveStr::Ascii("astracture"),
        dictgen::InsensitiveStr::Ascii("astrcuture"),
        dictgen::InsensitiveStr::Ascii("astructre"),
        dictgen::InsensitiveStr::Ascii("astructuur"),
        dictgen::InsensitiveStr::Ascii("astrucure"),
        dictgen::InsensitiveStr::Ascii("astrucutre"),
        dictgen::InsensitiveStr::Ascii("astrukture"),
        dictgen::InsensitiveStr::Ascii("astrutture"),
        dictgen::InsensitiveStr::Ascii("astruture"),
        dictgen::InsensitiveStr::Ascii("astucture"),
        dictgen::InsensitiveStr::Ascii("astuctures"),
        dictgen::InsensitiveStr::Ascii("asturcture"),
        dictgen::InsensitiveStr::Ascii("eqency"),
        dictgen::InsensitiveStr::Ascii("eqentcy"),
        dictgen::InsensitiveStr::Ascii("eqeuncy"),
        dictgen::InsensitiveStr::Ascii("eqeuntcy"),
        dictgen::InsensitiveStr::Ascii("equancies"),
        dictgen::InsensitiveStr::Ascii("equancy"),
        dictgen::InsensitiveStr::Ascii("equantcies"),
        dictgen::InsensitiveStr::Ascii("equantcy"),
        dictgen::InsensitiveStr::Ascii("equentcies"),
        dictgen::InsensitiveStr::Ascii("idgement"),
        dictgen::InsensitiveStr::Ascii("idging"),
        dictgen::InsensitiveStr::Ascii("igement"),
        dictgen::InsensitiveStr::Ascii("ignement"),
        dictgen::InsensitiveStr::Ascii("igning"),
        dictgen::InsensitiveStr::Ascii("ingeing"),
        dictgen::InsensitiveStr::Ascii("omal"),
        dictgen::InsensitiveStr::Ascii("omation"),
        dictgen::InsensitiveStr::Ascii("omative"),
        dictgen::InsensitiveStr::Ascii("omatoin"),
        dictgen::InsensitiveStr::Ascii("omed"),
        dictgen::InsensitiveStr::Ascii("oms"),
        dictgen::InsensitiveStr::Ascii("ormation"),
        dictgen::InsensitiveStr::Ascii("otn"),
        dictgen::InsensitiveStr::Ascii("ustructure"),
    ],
    values: &[
        &["infantryman"],
        &["infrared"],
        &["infrastructure"],
        &["infrastructure"],
        &["infrastructure"],
        &["infrastructure"],
        &["infrastructure"],
        &["infrastructure"],
        &["infrastructure"],
        &["infrastructure"],
        &["infrastructure"],
        &["infrastructure"],
        &["infrastructure"],
        &["infrastructures"],
        &["infrastructure"],
        &["infrequency"],
        &["infrequency"],
        &["infrequency"],
        &["infrequency"],
        &["infrequencies"],
        &["infrequency"],
        &["infrequencies"],
        &["infrequency"],
        &["infrequencies"],
        &["infringement"],
        &["infringing"],
        &["infringement"],
        &["infringement"],
        &["infringing"],
        &["infringing"],
        &["informal"],
        &["information"],
        &["informative"],
        &["information"],
        &["informed"],
        &["informs"],
        &["information"],
        &["infront"],
        &["infrastructure"],
    ],
    range: 3..=11,
};

static WORD_INFO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INFO_CHILDREN),
    value: None,
};

pub static WORD_INFO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("emation"),
        dictgen::InsensitiveStr::Ascii("grahic"),
        dictgen::InsensitiveStr::Ascii("grahpic"),
        dictgen::InsensitiveStr::Ascii("grapgic"),
        dictgen::InsensitiveStr::Ascii("grapic"),
        dictgen::InsensitiveStr::Ascii("grpahic"),
        dictgen::InsensitiveStr::Ascii("grpahics"),
        dictgen::InsensitiveStr::Ascii("mation"),
        dictgen::InsensitiveStr::Ascii("mational"),
        dictgen::InsensitiveStr::Ascii("matrion"),
        dictgen::InsensitiveStr::Ascii("med"),
        dictgen::InsensitiveStr::Ascii("mer"),
        dictgen::InsensitiveStr::Ascii("mration"),
        dictgen::InsensitiveStr::Ascii("ms"),
        dictgen::InsensitiveStr::Ascii("r"),
        dictgen::InsensitiveStr::Ascii("ramtion"),
        dictgen::InsensitiveStr::Ascii("ration"),
        dictgen::InsensitiveStr::Ascii("rational"),
        dictgen::InsensitiveStr::Ascii("rce"),
        dictgen::InsensitiveStr::Ascii("rced"),
        dictgen::InsensitiveStr::Ascii("rgivable"),
        dictgen::InsensitiveStr::Ascii("rmable"),
        dictgen::InsensitiveStr::Ascii("rmacion"),
        dictgen::InsensitiveStr::Ascii("rmaion"),
        dictgen::InsensitiveStr::Ascii("rmaional"),
        dictgen::InsensitiveStr::Ascii("rmaiton"),
        dictgen::InsensitiveStr::Ascii("rmarla"),
        dictgen::InsensitiveStr::Ascii("rmarle"),
        dictgen::InsensitiveStr::Ascii("rmarlo"),
        dictgen::InsensitiveStr::Ascii("rmas"),
        dictgen::InsensitiveStr::Ascii("rmatation"),
        dictgen::InsensitiveStr::Ascii("rmatations"),
        dictgen::InsensitiveStr::Ascii("rmate"),
        dictgen::InsensitiveStr::Ascii("rmatice"),
        dictgen::InsensitiveStr::Ascii("rmatie"),
        dictgen::InsensitiveStr::Ascii("rmatief"),
        dictgen::InsensitiveStr::Ascii("rmatiei"),
        dictgen::InsensitiveStr::Ascii("rmatike"),
        dictgen::InsensitiveStr::Ascii("rmatikon"),
        dictgen::InsensitiveStr::Ascii("rmatin"),
        dictgen::InsensitiveStr::Ascii("rmatino"),
        dictgen::InsensitiveStr::Ascii("rmatins"),
        dictgen::InsensitiveStr::Ascii("rmatio"),
        dictgen::InsensitiveStr::Ascii("rmatiom"),
        dictgen::InsensitiveStr::Ascii("rmations"),
        dictgen::InsensitiveStr::Ascii("rmativo"),
        dictgen::InsensitiveStr::Ascii("rmatoin"),
        dictgen::InsensitiveStr::Ascii("rmatoins"),
        dictgen::InsensitiveStr::Ascii("rmaton"),
        dictgen::InsensitiveStr::Ascii("rmella"),
        dictgen::InsensitiveStr::Ascii("rmerad"),
        dictgen::InsensitiveStr::Ascii("rmfation"),
        dictgen::InsensitiveStr::Ascii("rmis"),
        dictgen::InsensitiveStr::Ascii("rmitive"),
        dictgen::InsensitiveStr::Ascii("rmtion"),
        dictgen::InsensitiveStr::Ascii("rnt"),
        dictgen::InsensitiveStr::Ascii("rrmation"),
    ],
    values: &[
        &["information"],
        &["infographic"],
        &["infographic"],
        &["infographic"],
        &["infographic"],
        &["infographic"],
        &["infographic"],
        &["information"],
        &["informational"],
        &["information"],
        &["informed"],
        &["informer"],
        &["information"],
        &["informs"],
        &["info"],
        &["information"],
        &["information"],
        &["informational"],
        &["enforce"],
        &["enforced"],
        &["unforgivable"],
        &["informal"],
        &["information"],
        &["information"],
        &["informational"],
        &["information"],
        &["informal"],
        &["informal"],
        &["informal"],
        &["informs"],
        &["information"],
        &["information"],
        &["informative"],
        &["informative"],
        &["informative"],
        &["informative"],
        &["informative"],
        &["informative"],
        &["information"],
        &["information", "informing"],
        &["information"],
        &["information"],
        &["information"],
        &["information"],
        &["information"],
        &["information"],
        &["information"],
        &["information"],
        &["information"],
        &["informal"],
        &["informed"],
        &["information"],
        &["informs"],
        &["informative"],
        &["information"],
        &["infront"],
        &["information"],
    ],
    range: 1..=10,
};

static WORD_INFL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INFL_CHILDREN),
    value: None,
};

pub static WORD_INFL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("amable"),
        dictgen::InsensitiveStr::Ascii("amation"),
        dictgen::InsensitiveStr::Ascii("atabale"),
        dictgen::InsensitiveStr::Ascii("atabe"),
        dictgen::InsensitiveStr::Ascii("ateble"),
        dictgen::InsensitiveStr::Ascii("atible"),
        dictgen::InsensitiveStr::Ascii("atie"),
        dictgen::InsensitiveStr::Ascii("atoin"),
        dictgen::InsensitiveStr::Ascii("eunced"),
        dictgen::InsensitiveStr::Ascii("exable"),
        dictgen::InsensitiveStr::Ascii("itrate"),
        dictgen::InsensitiveStr::Ascii("itrator"),
        dictgen::InsensitiveStr::Ascii("uanced"),
        dictgen::InsensitiveStr::Ascii("uances"),
        dictgen::InsensitiveStr::Ascii("uancing"),
        dictgen::InsensitiveStr::Ascii("uece"),
        dictgen::InsensitiveStr::Ascii("ueced"),
        dictgen::InsensitiveStr::Ascii("ueces"),
        dictgen::InsensitiveStr::Ascii("uecing"),
        dictgen::InsensitiveStr::Ascii("uenceing"),
        dictgen::InsensitiveStr::Ascii("uencial"),
        dictgen::InsensitiveStr::Ascii("uencian"),
        dictgen::InsensitiveStr::Ascii("uencie"),
        dictgen::InsensitiveStr::Ascii("uencin"),
        dictgen::InsensitiveStr::Ascii("uening"),
        dictgen::InsensitiveStr::Ascii("uens"),
        dictgen::InsensitiveStr::Ascii("uense"),
        dictgen::InsensitiveStr::Ascii("uensed"),
        dictgen::InsensitiveStr::Ascii("uenser"),
        dictgen::InsensitiveStr::Ascii("uenses"),
        dictgen::InsensitiveStr::Ascii("uenta"),
        dictgen::InsensitiveStr::Ascii("uental"),
        dictgen::InsensitiveStr::Ascii("uented"),
        dictgen::InsensitiveStr::Ascii("uentes"),
        dictgen::InsensitiveStr::Ascii("uenting"),
        dictgen::InsensitiveStr::Ascii("uentual"),
        dictgen::InsensitiveStr::Ascii("uincing"),
        dictgen::InsensitiveStr::Ascii("uneced"),
    ],
    values: &[
        &["inflatable"],
        &["inflammation"],
        &["inflatable"],
        &["inflatable"],
        &["inflatable"],
        &["inflatable"],
        &["inflate"],
        &["inflation"],
        &["influenced"],
        &["inflexible"],
        &["infiltrate"],
        &["infiltrator"],
        &["influenced"],
        &["influences"],
        &["influencing"],
        &["influence"],
        &["influenced"],
        &["influences"],
        &["influencing"],
        &["influencing"],
        &["influential"],
        &["influencing"],
        &["influences"],
        &["influencing"],
        &["influencing"],
        &["influences"],
        &["influences"],
        &["influences"],
        &["influences"],
        &["influences"],
        &["influential"],
        &["influential"],
        &["influenced"],
        &["influences"],
        &["influencing"],
        &["influential"],
        &["influencing"],
        &["influenced"],
    ],
    range: 4..=8,
};

static WORD_INFI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INFI_CHILDREN),
    value: None,
};

pub static WORD_INFI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("deltiy"),
        dictgen::InsensitiveStr::Ascii("dility"),
        dictgen::InsensitiveStr::Ascii("litrate"),
        dictgen::InsensitiveStr::Ascii("litrated"),
        dictgen::InsensitiveStr::Ascii("litration"),
        dictgen::InsensitiveStr::Ascii("ltartor"),
        dictgen::InsensitiveStr::Ascii("ltrade"),
        dictgen::InsensitiveStr::Ascii("ltrait"),
        dictgen::InsensitiveStr::Ascii("ltraitor"),
        dictgen::InsensitiveStr::Ascii("ltrar"),
        dictgen::InsensitiveStr::Ascii("ltrare"),
        dictgen::InsensitiveStr::Ascii("ltraron"),
        dictgen::InsensitiveStr::Ascii("ltrarte"),
        dictgen::InsensitiveStr::Ascii("ltrase"),
        dictgen::InsensitiveStr::Ascii("ltrater"),
        dictgen::InsensitiveStr::Ascii("ltratie"),
        dictgen::InsensitiveStr::Ascii("ltratior"),
        dictgen::InsensitiveStr::Ascii("ltratred"),
        dictgen::InsensitiveStr::Ascii("ltre"),
        dictgen::InsensitiveStr::Ascii("ltrerat"),
        dictgen::InsensitiveStr::Ascii("nate"),
        dictgen::InsensitiveStr::Ascii("nately"),
        dictgen::InsensitiveStr::Ascii("net"),
        dictgen::InsensitiveStr::Ascii("netely"),
        dictgen::InsensitiveStr::Ascii("nie"),
        dictgen::InsensitiveStr::Ascii("niment"),
        dictgen::InsensitiveStr::Ascii("ninte"),
        dictgen::InsensitiveStr::Ascii("nit"),
        dictgen::InsensitiveStr::Ascii("nitelly"),
        dictgen::InsensitiveStr::Ascii("nitey"),
        dictgen::InsensitiveStr::Ascii("nitie"),
        dictgen::InsensitiveStr::Ascii("nitiy"),
        dictgen::InsensitiveStr::Ascii("nitley"),
        dictgen::InsensitiveStr::Ascii("nitly"),
        dictgen::InsensitiveStr::Ascii("nte"),
        dictgen::InsensitiveStr::Ascii("ntesimal"),
        dictgen::InsensitiveStr::Ascii("ntie"),
        dictgen::InsensitiveStr::Ascii("ntiely"),
        dictgen::InsensitiveStr::Ascii("ntiy"),
        dictgen::InsensitiveStr::Ascii("ntrator"),
        dictgen::InsensitiveStr::Ascii("nty"),
        dictgen::InsensitiveStr::Ascii("te"),
    ],
    values: &[
        &["infidelity"],
        &["infidelity"],
        &["infiltrate"],
        &["infiltrated"],
        &["infiltration"],
        &["infiltrator"],
        &["infiltrate"],
        &["infiltrate"],
        &["infiltrator"],
        &["infiltrator"],
        &["infiltrate"],
        &["infiltrator"],
        &["infiltrate"],
        &["infiltrate"],
        &["infiltrator"],
        &["infiltrate"],
        &["infiltrator"],
        &["infiltrate"],
        &["infiltrate"],
        &["infiltrate"],
        &["infinite"],
        &["infinitely"],
        &["infinite"],
        &["infinitely"],
        &["infinite"],
        &["infinite"],
        &["infinite"],
        &["infinite"],
        &["infinitely"],
        &["infinity"],
        &["infinite", "infinity"],
        &["infinity"],
        &["infinitely"],
        &["infinity", "infinitely"],
        &["infinite"],
        &["infinitesimal"],
        &["infinite"],
        &["infinitely"],
        &["infinity"],
        &["infiltrator"],
        &["infinity"],
        &["infinite"],
    ],
    range: 2..=9,
};

static WORD_INFE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INFE_CHILDREN),
    value: None,
};

pub static WORD_INFE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ccious"),
        dictgen::InsensitiveStr::Ascii("ctation"),
        dictgen::InsensitiveStr::Ascii("cteous"),
        dictgen::InsensitiveStr::Ascii("ctin"),
        dictgen::InsensitiveStr::Ascii("ctuous"),
        dictgen::InsensitiveStr::Ascii("dility"),
        dictgen::InsensitiveStr::Ascii("ktious"),
        dictgen::InsensitiveStr::Ascii("nro"),
        dictgen::InsensitiveStr::Ascii("red"),
        dictgen::InsensitiveStr::Ascii("rface"),
        dictgen::InsensitiveStr::Ascii("ring"),
        dictgen::InsensitiveStr::Ascii("rioara"),
        dictgen::InsensitiveStr::Ascii("rioare"),
        dictgen::InsensitiveStr::Ascii("rioir"),
        dictgen::InsensitiveStr::Ascii("rioirty"),
        dictgen::InsensitiveStr::Ascii("riorty"),
        dictgen::InsensitiveStr::Ascii("riour"),
        dictgen::InsensitiveStr::Ascii("rir"),
        dictgen::InsensitiveStr::Ascii("rmon"),
        dictgen::InsensitiveStr::Ascii("rrable"),
        dictgen::InsensitiveStr::Ascii("rrence"),
        dictgen::InsensitiveStr::Ascii("staion"),
        dictgen::InsensitiveStr::Ascii("stating"),
        dictgen::InsensitiveStr::Ascii("stato"),
        dictgen::InsensitiveStr::Ascii("staton"),
        dictgen::InsensitiveStr::Ascii("stions"),
        dictgen::InsensitiveStr::Ascii("x"),
    ],
    values: &[
        &["infectious"],
        &["infestation"],
        &["infectious"],
        &["infections"],
        &["infectious"],
        &["infidelity"],
        &["infectious"],
        &["inferno"],
        &["inferred"],
        &["interface"],
        &["inferring"],
        &["inferior"],
        &["inferior"],
        &["inferior"],
        &["inferiority"],
        &["inferiority"],
        &["inferior"],
        &["inferior"],
        &["inferno"],
        &["inferable"],
        &["inference"],
        &["infestation"],
        &["infestation"],
        &["infestation"],
        &["infestation"],
        &["infections"],
        &["index"],
    ],
    range: 1..=7,
};

static WORD_INFA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INFA_CHILDREN),
    value: None,
};

pub static WORD_INFA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("lability"),
        dictgen::InsensitiveStr::Ascii("llable"),
        dictgen::InsensitiveStr::Ascii("llibale"),
        dictgen::InsensitiveStr::Ascii("llibe"),
        dictgen::InsensitiveStr::Ascii("llibile"),
        dictgen::InsensitiveStr::Ascii("ltable"),
        dictgen::InsensitiveStr::Ascii("lte"),
        dictgen::InsensitiveStr::Ascii("lted"),
        dictgen::InsensitiveStr::Ascii("ltes"),
        dictgen::InsensitiveStr::Ascii("lting"),
        dictgen::InsensitiveStr::Ascii("ntis"),
        dictgen::InsensitiveStr::Ascii("ntus"),
        dictgen::InsensitiveStr::Ascii("rred"),
    ],
    values: &[
        &["infallibility"],
        &["infallible"],
        &["infallible"],
        &["infallible"],
        &["infallible"],
        &["inflatable", "infallible"],
        &["inflate"],
        &["inflated"],
        &["inflates"],
        &["inflating"],
        &["infants"],
        &["infants"],
        &["infrared"],
    ],
    range: 3..=8,
};

static WORD_INE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_INE_CHILDREN),
    value: None,
};

static WORD_INE_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_INEA_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_INEF_NODE),
    Some(&WORD_INEG_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_INEQ_NODE),
    Some(&WORD_INER_NODE),
    Some(&WORD_INES_NODE),
    Some(&WORD_INET_NODE),
    None,
    Some(&WORD_INEV_NODE),
    None,
    Some(&WORD_INEX_NODE),
    None,
    None,
];

static WORD_INEX_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INEX_CHILDREN),
    value: Some(&["index"]),
};

pub static WORD_INEX_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("blicably"),
        dictgen::InsensitiveStr::Ascii("eprienced"),
        dictgen::InsensitiveStr::Ascii("istant"),
        dictgen::InsensitiveStr::Ascii("pect"),
        dictgen::InsensitiveStr::Ascii("pectedly"),
        dictgen::InsensitiveStr::Ascii("peirenced"),
        dictgen::InsensitiveStr::Ascii("pencive"),
        dictgen::InsensitiveStr::Ascii("penisve"),
        dictgen::InsensitiveStr::Ascii("pense"),
        dictgen::InsensitiveStr::Ascii("pereince"),
        dictgen::InsensitiveStr::Ascii("pereinced"),
        dictgen::InsensitiveStr::Ascii("periance"),
        dictgen::InsensitiveStr::Ascii("perianced"),
        dictgen::InsensitiveStr::Ascii("periece"),
        dictgen::InsensitiveStr::Ascii("perieced"),
        dictgen::InsensitiveStr::Ascii("periecned"),
        dictgen::InsensitiveStr::Ascii("periencable"),
        dictgen::InsensitiveStr::Ascii("periened"),
        dictgen::InsensitiveStr::Ascii("periente"),
        dictgen::InsensitiveStr::Ascii("perince"),
        dictgen::InsensitiveStr::Ascii("perineced"),
        dictgen::InsensitiveStr::Ascii("pierence"),
        dictgen::InsensitiveStr::Ascii("pierenced"),
        dictgen::InsensitiveStr::Ascii("pirience"),
        dictgen::InsensitiveStr::Ascii("pirienced"),
        dictgen::InsensitiveStr::Ascii("plicabil"),
        dictgen::InsensitiveStr::Ascii("plicablely"),
        dictgen::InsensitiveStr::Ascii("plicabley"),
        dictgen::InsensitiveStr::Ascii("plicablly"),
        dictgen::InsensitiveStr::Ascii("plicaby"),
        dictgen::InsensitiveStr::Ascii("plicibly"),
    ],
    values: &[
        &["inexplicably"],
        &["inexperience"],
        &["inexistent"],
        &["inexpected", "unexpected"],
        &["unexpectedly"],
        &["inexperience"],
        &["inexpensive"],
        &["inexpensive"],
        &["inexpensive"],
        &["inexperience"],
        &["inexperienced"],
        &["inexperience"],
        &["inexperienced"],
        &["inexperience"],
        &["inexperienced"],
        &["inexperience"],
        &["inexperience"],
        &["inexperienced"],
        &["inexperience"],
        &["inexperience"],
        &["inexperience"],
        &["inexperienced", "inexperience"],
        &["inexperienced"],
        &["inexperience"],
        &["inexperienced"],
        &["inexplicably"],
        &["inexplicably"],
        &["inexplicably"],
        &["inexplicably"],
        &["inexplicably"],
        &["inexplicably"],
    ],
    range: 4..=11,
};

static WORD_INEV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INEV_CHILDREN),
    value: None,
};

pub static WORD_INEV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("atible"),
        dictgen::InsensitiveStr::Ascii("etable"),
        dictgen::InsensitiveStr::Ascii("etably"),
        dictgen::InsensitiveStr::Ascii("etible"),
        dictgen::InsensitiveStr::Ascii("idable"),
        dictgen::InsensitiveStr::Ascii("idably"),
        dictgen::InsensitiveStr::Ascii("itabile"),
        dictgen::InsensitiveStr::Ascii("itabily"),
        dictgen::InsensitiveStr::Ascii("itablely"),
        dictgen::InsensitiveStr::Ascii("itabley"),
        dictgen::InsensitiveStr::Ascii("itablity"),
        dictgen::InsensitiveStr::Ascii("itablly"),
        dictgen::InsensitiveStr::Ascii("itible"),
        dictgen::InsensitiveStr::Ascii("itibly"),
        dictgen::InsensitiveStr::Ascii("ititably"),
        dictgen::InsensitiveStr::Ascii("tiable"),
        dictgen::InsensitiveStr::Ascii("tiably"),
    ],
    values: &[
        &["inevitable"],
        &["inevitable"],
        &["inevitably"],
        &["inevitable"],
        &["inevitable"],
        &["inevitably"],
        &["inevitable"],
        &["inevitably"],
        &["inevitably"],
        &["inevitably"],
        &["inevitably"],
        &["inevitably"],
        &["inevitable"],
        &["inevitably"],
        &["inevitably"],
        &["inevitable"],
        &["inevitably"],
    ],
    range: 6..=8,
};

static WORD_INET_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INET_CHILDREN),
    value: None,
};

pub static WORD_INET_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("rrupts")],
    values: &[&["interrupts"]],
    range: 6..=6,
};

static WORD_INES_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INES_CHILDREN),
    value: Some(&["lines"]),
};

pub static WORD_INES_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("tart")],
    values: &[&["linestart"]],
    range: 4..=4,
};

static WORD_INER_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INER_CHILDREN),
    value: None,
};

pub static WORD_INER_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("face"),
        dictgen::InsensitiveStr::Ascii("it"),
        dictgen::InsensitiveStr::Ascii("itance"),
        dictgen::InsensitiveStr::Ascii("ited"),
        dictgen::InsensitiveStr::Ascii("iting"),
        dictgen::InsensitiveStr::Ascii("itor"),
        dictgen::InsensitiveStr::Ascii("itors"),
        dictgen::InsensitiveStr::Ascii("its"),
        dictgen::InsensitiveStr::Ascii("nal"),
        dictgen::InsensitiveStr::Ascii("rupt"),
        dictgen::InsensitiveStr::Ascii("shia"),
        dictgen::InsensitiveStr::Ascii("shial"),
        dictgen::InsensitiveStr::Ascii("sia"),
        dictgen::InsensitiveStr::Ascii("sial"),
        dictgen::InsensitiveStr::Ascii("sting"),
        dictgen::InsensitiveStr::Ascii("tion"),
    ],
    values: &[
        &["interface"],
        &["inherit"],
        &["inheritance"],
        &["inherited"],
        &["inheriting"],
        &["inheritor"],
        &["inheritors"],
        &["inherits"],
        &["internal"],
        &["interrupt"],
        &["inertia"],
        &["inertial"],
        &["inertia"],
        &["inertial"],
        &["inserting"],
        &["insertion"],
    ],
    range: 2..=6,
};

static WORD_INEQ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INEQ_CHILDREN),
    value: None,
};

pub static WORD_INEQ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ality"),
        dictgen::InsensitiveStr::Ascii("aulity"),
        dictgen::InsensitiveStr::Ascii("uailty"),
        dictgen::InsensitiveStr::Ascii("ualitiy"),
        dictgen::InsensitiveStr::Ascii("uallity"),
    ],
    values: &[
        &["inequality"],
        &["inequality"],
        &["inequality"],
        &["inequality"],
        &["inequality"],
    ],
    range: 5..=7,
};

static WORD_INEG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INEG_CHILDREN),
    value: None,
};

pub static WORD_INEG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("rate"),
        dictgen::InsensitiveStr::Ascii("rated"),
    ],
    values: &[&["integrate"], &["integrated"]],
    range: 4..=5,
};

static WORD_INEF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INEF_CHILDREN),
    value: None,
};

pub static WORD_INEF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("fciency"),
        dictgen::InsensitiveStr::Ascii("fcient"),
        dictgen::InsensitiveStr::Ascii("fciently"),
        dictgen::InsensitiveStr::Ascii("fecitve"),
        dictgen::InsensitiveStr::Ascii("fektive"),
        dictgen::InsensitiveStr::Ascii("ficeint"),
        dictgen::InsensitiveStr::Ascii("ficency"),
        dictgen::InsensitiveStr::Ascii("ficent"),
        dictgen::InsensitiveStr::Ascii("ficently"),
        dictgen::InsensitiveStr::Ascii("ficenty"),
        dictgen::InsensitiveStr::Ascii("ficiant"),
        dictgen::InsensitiveStr::Ascii("ficienct"),
        dictgen::InsensitiveStr::Ascii("ficienty"),
        dictgen::InsensitiveStr::Ascii("ficieny"),
        dictgen::InsensitiveStr::Ascii("fictive"),
        dictgen::InsensitiveStr::Ascii("fiecent"),
        dictgen::InsensitiveStr::Ascii("fient"),
        dictgen::InsensitiveStr::Ascii("fiently"),
        dictgen::InsensitiveStr::Ascii("fizient"),
        dictgen::InsensitiveStr::Ascii("icient"),
    ],
    values: &[
        &["inefficiency"],
        &["inefficient"],
        &["inefficiently"],
        &["ineffective"],
        &["ineffective"],
        &["inefficient"],
        &["inefficiency"],
        &["inefficient"],
        &["inefficiently"],
        &["inefficiently"],
        &["inefficient"],
        &["inefficient"],
        &["inefficiently"],
        &["inefficiency", "inefficiently"],
        &["ineffective"],
        &["inefficient"],
        &["inefficient"],
        &["inefficiently"],
        &["inefficient"],
        &["inefficient"],
    ],
    range: 5..=8,
};

static WORD_INEA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INEA_CHILDREN),
    value: None,
};

pub static WORD_INEA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("risation")],
    values: &[&["linearisation"]],
    range: 8..=8,
};

static WORD_IND_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_IND_CHILDREN),
    value: None,
};

static WORD_IND_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_INDA_NODE),
    None,
    Some(&WORD_INDC_NODE),
    Some(&WORD_INDD_NODE),
    Some(&WORD_INDE_NODE),
    None,
    None,
    None,
    Some(&WORD_INDI_NODE),
    None,
    None,
    Some(&WORD_INDL_NODE),
    None,
    None,
    Some(&WORD_INDO_NODE),
    Some(&WORD_INDP_NODE),
    None,
    Some(&WORD_INDR_NODE),
    None,
    None,
    Some(&WORD_INDU_NODE),
    Some(&WORD_INDV_NODE),
    None,
    Some(&WORD_INDX_NODE),
    None,
    None,
];

static WORD_INDX_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INDX_CHILDREN),
    value: None,
};

pub static WORD_INDX_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("es")],
    values: &[&["indexes"]],
    range: 2..=2,
};

static WORD_INDV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INDV_CHILDREN),
    value: None,
};

pub static WORD_INDV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("idual"),
        dictgen::InsensitiveStr::Ascii("iduals"),
    ],
    values: &[&["individual"], &["individuals"]],
    range: 5..=6,
};

static WORD_INDU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INDU_CHILDREN),
    value: None,
};

pub static WORD_INDU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("gle"),
        dictgen::InsensitiveStr::Ascii("lgue"),
        dictgen::InsensitiveStr::Ascii("re"),
        dictgen::InsensitiveStr::Ascii("stiral"),
        dictgen::InsensitiveStr::Ascii("stiralized"),
        dictgen::InsensitiveStr::Ascii("stires"),
        dictgen::InsensitiveStr::Ascii("strail"),
        dictgen::InsensitiveStr::Ascii("strailized"),
        dictgen::InsensitiveStr::Ascii("strees"),
        dictgen::InsensitiveStr::Ascii("strialied"),
        dictgen::InsensitiveStr::Ascii("strialzed"),
        dictgen::InsensitiveStr::Ascii("strias"),
        dictgen::InsensitiveStr::Ascii("striel"),
        dictgen::InsensitiveStr::Ascii("striella"),
        dictgen::InsensitiveStr::Ascii("striels"),
        dictgen::InsensitiveStr::Ascii("strija"),
        dictgen::InsensitiveStr::Ascii("strije"),
        dictgen::InsensitiveStr::Ascii("strijske"),
        dictgen::InsensitiveStr::Ascii("strualized"),
        dictgen::InsensitiveStr::Ascii("structible"),
        dictgen::InsensitiveStr::Ascii("trial"),
    ],
    values: &[
        &["indulge"],
        &["indulge"],
        &["endure"],
        &["industrial"],
        &["industrialized"],
        &["industries"],
        &["industrial"],
        &["industrialized"],
        &["industries"],
        &["industrialized"],
        &["industrialized"],
        &["industries"],
        &["industrial"],
        &["industrial"],
        &["industries"],
        &["industrial"],
        &["industries"],
        &["industries"],
        &["industrialized"],
        &["indestructible"],
        &["industrial"],
    ],
    range: 2..=10,
};

static WORD_INDR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INDR_CHILDREN),
    value: None,
};

pub static WORD_INDR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ect"),
        dictgen::InsensitiveStr::Ascii("oduction"),
        dictgen::InsensitiveStr::Ascii("oductory"),
    ],
    values: &[&["indirect"], &["introduction"], &["introductory"]],
    range: 3..=8,
};

static WORD_INDP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INDP_CHILDREN),
    value: None,
};

pub static WORD_INDP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("endent"),
        dictgen::InsensitiveStr::Ascii("endently"),
    ],
    values: &[&["independent"], &["independently"]],
    range: 6..=8,
};

static WORD_INDO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INDO_CHILDREN),
    value: None,
};

pub static WORD_INDO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("crtinated"),
        dictgen::InsensitiveStr::Ascii("crtination"),
        dictgen::InsensitiveStr::Ascii("cternated"),
        dictgen::InsensitiveStr::Ascii("ctornated"),
        dictgen::InsensitiveStr::Ascii("ctrication"),
        dictgen::InsensitiveStr::Ascii("ctrinatie"),
        dictgen::InsensitiveStr::Ascii("ctrinatin"),
        dictgen::InsensitiveStr::Ascii("ctronated"),
        dictgen::InsensitiveStr::Ascii("ensia"),
        dictgen::InsensitiveStr::Ascii("ensian"),
        dictgen::InsensitiveStr::Ascii("ktrination"),
        dictgen::InsensitiveStr::Ascii("nasian"),
        dictgen::InsensitiveStr::Ascii("neisa"),
        dictgen::InsensitiveStr::Ascii("neisan"),
        dictgen::InsensitiveStr::Ascii("nesa"),
        dictgen::InsensitiveStr::Ascii("nesean"),
        dictgen::InsensitiveStr::Ascii("nesien"),
        dictgen::InsensitiveStr::Ascii("nesion"),
        dictgen::InsensitiveStr::Ascii("nisian"),
        dictgen::InsensitiveStr::Ascii("nistan"),
    ],
    values: &[
        &["indoctrinated"],
        &["indoctrination"],
        &["indoctrinated"],
        &["indoctrinated"],
        &["indoctrination"],
        &["indoctrinated"],
        &["indoctrination"],
        &["indoctrinated"],
        &["indonesia"],
        &["indonesian"],
        &["indoctrination"],
        &["indonesian"],
        &["indonesia"],
        &["indonesian"],
        &["indonesia"],
        &["indonesian"],
        &["indonesian"],
        &["indonesian"],
        &["indonesian"],
        &["indonesian"],
    ],
    range: 4..=10,
};

static WORD_INDL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INDL_CHILDREN),
    value: None,
};

pub static WORD_INDL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("uge")],
    values: &[&["indulge"]],
    range: 3..=3,
};

static WORD_INDI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_INDI_CHILDREN),
    value: None,
};

static WORD_INDI_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_INDIA_NODE),
    None,
    Some(&WORD_INDIC_NODE),
    Some(&WORD_INDID_NODE),
    Some(&WORD_INDIE_NODE),
    Some(&WORD_INDIF_NODE),
    Some(&WORD_INDIG_NODE),
    None,
    None,
    None,
    Some(&WORD_INDIK_NODE),
    None,
    Some(&WORD_INDIM_NODE),
    None,
    None,
    Some(&WORD_INDIP_NODE),
    Some(&WORD_INDIQ_NODE),
    Some(&WORD_INDIR_NODE),
    Some(&WORD_INDIS_NODE),
    None,
    None,
    Some(&WORD_INDIV_NODE),
    None,
    None,
    None,
    Some(&WORD_INDIZ_NODE),
];

static WORD_INDIZ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INDIZ_CHILDREN),
    value: None,
};

pub static WORD_INDIZ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ies")],
    values: &[&["indices"]],
    range: 3..=3,
};

static WORD_INDIV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INDIV_CHILDREN),
    value: None,
};

pub static WORD_INDIV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("dual"),
        dictgen::InsensitiveStr::Ascii("dually"),
        dictgen::InsensitiveStr::Ascii("dualy"),
        dictgen::InsensitiveStr::Ascii("idal"),
        dictgen::InsensitiveStr::Ascii("idally"),
        dictgen::InsensitiveStr::Ascii("idals"),
        dictgen::InsensitiveStr::Ascii("idaul"),
        dictgen::InsensitiveStr::Ascii("idaully"),
        dictgen::InsensitiveStr::Ascii("idauls"),
        dictgen::InsensitiveStr::Ascii("idauly"),
        dictgen::InsensitiveStr::Ascii("idial"),
        dictgen::InsensitiveStr::Ascii("idiual"),
        dictgen::InsensitiveStr::Ascii("idiually"),
        dictgen::InsensitiveStr::Ascii("iduais"),
        dictgen::InsensitiveStr::Ascii("iduales"),
        dictgen::InsensitiveStr::Ascii("iduall"),
        dictgen::InsensitiveStr::Ascii("iduallity"),
        dictgen::InsensitiveStr::Ascii("idualty"),
        dictgen::InsensitiveStr::Ascii("idualy"),
        dictgen::InsensitiveStr::Ascii("iduati"),
        dictgen::InsensitiveStr::Ascii("iduel"),
        dictgen::InsensitiveStr::Ascii("iduella"),
        dictgen::InsensitiveStr::Ascii("iduelly"),
        dictgen::InsensitiveStr::Ascii("iduels"),
        dictgen::InsensitiveStr::Ascii("iduely"),
        dictgen::InsensitiveStr::Ascii("idul"),
        dictgen::InsensitiveStr::Ascii("idule"),
        dictgen::InsensitiveStr::Ascii("idules"),
        dictgen::InsensitiveStr::Ascii("iduls"),
        dictgen::InsensitiveStr::Ascii("idus"),
        dictgen::InsensitiveStr::Ascii("isual"),
        dictgen::InsensitiveStr::Ascii("isuality"),
        dictgen::InsensitiveStr::Ascii("isually"),
        dictgen::InsensitiveStr::Ascii("isuals"),
        dictgen::InsensitiveStr::Ascii("iual"),
        dictgen::InsensitiveStr::Ascii("iually"),
        dictgen::InsensitiveStr::Ascii("iuals"),
        dictgen::InsensitiveStr::Ascii("iudal"),
        dictgen::InsensitiveStr::Ascii("iudally"),
        dictgen::InsensitiveStr::Ascii("ual"),
        dictgen::InsensitiveStr::Ascii("udual"),
        dictgen::InsensitiveStr::Ascii("uduality"),
        dictgen::InsensitiveStr::Ascii("udually"),
        dictgen::InsensitiveStr::Ascii("uduals"),
    ],
    values: &[
        &["individual"],
        &["individually"],
        &["individually"],
        &["individual"],
        &["individually"],
        &["individuals"],
        &["individual"],
        &["individually"],
        &["individuals"],
        &["individually"],
        &["individual"],
        &["individual"],
        &["individually"],
        &["individuals"],
        &["individuals"],
        &["individual", "individually"],
        &["individuality"],
        &["individuality"],
        &["individually"],
        &["individuality"],
        &["individual"],
        &["individual"],
        &["individually"],
        &["individuals"],
        &["individually"],
        &["individual"],
        &["individual"],
        &["individuals"],
        &["individuals"],
        &["individuals"],
        &["individual"],
        &["individuality"],
        &["individually"],
        &["individuals"],
        &["individual"],
        &["individually"],
        &["individuals"],
        &["individuals"],
        &["individually"],
        &["individual"],
        &["individual"],
        &["individuality"],
        &["individually"],
        &["individuals"],
    ],
    range: 3..=9,
};

static WORD_INDIS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INDIS_CHILDREN),
    value: None,
};

pub static WORD_INDIS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ious"),
        dictgen::InsensitiveStr::Ascii("pensible"),
        dictgen::InsensitiveStr::Ascii("putible"),
        dictgen::InsensitiveStr::Ascii("putibly"),
        dictgen::InsensitiveStr::Ascii("tiguishable"),
        dictgen::InsensitiveStr::Ascii("tinguisable"),
        dictgen::InsensitiveStr::Ascii("tinguishible"),
        dictgen::InsensitiveStr::Ascii("tingusihable"),
        dictgen::InsensitiveStr::Ascii("tinquishable"),
        dictgen::InsensitiveStr::Ascii("tructible"),
        dictgen::InsensitiveStr::Ascii("tuingishable"),
    ],
    values: &[
        &["insidious"],
        &["indispensable"],
        &["indisputable"],
        &["indisputably"],
        &["indistinguishable"],
        &["indistinguishable"],
        &["indistinguishable"],
        &["indistinguishable"],
        &["indistinguishable"],
        &["indestructible"],
        &["indistinguishable"],
    ],
    range: 4..=12,
};

static WORD_INDIR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INDIR_CHILDREN),
    value: None,
};

pub static WORD_INDIR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eclty"),
        dictgen::InsensitiveStr::Ascii("ectely"),
        dictgen::InsensitiveStr::Ascii("ecty"),
        dictgen::InsensitiveStr::Ascii("ektly"),
    ],
    values: &[
        &["indirectly"],
        &["indirectly"],
        &["indirectly"],
        &["indirectly"],
    ],
    range: 4..=6,
};

static WORD_INDIQ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INDIQ_CHILDREN),
    value: None,
};

pub static WORD_INDIQ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("uate"),
        dictgen::InsensitiveStr::Ascii("uates"),
    ],
    values: &[&["indicate"], &["indicates"]],
    range: 4..=5,
};

static WORD_INDIP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INDIP_CHILDREN),
    value: None,
};

pub static WORD_INDIP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("endence"),
        dictgen::InsensitiveStr::Ascii("endent"),
        dictgen::InsensitiveStr::Ascii("endently"),
    ],
    values: &[&["independence"], &["independent"], &["independently"]],
    range: 6..=8,
};

static WORD_INDIM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INDIM_CHILDREN),
    value: None,
};

pub static WORD_INDIM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("idating"),
        dictgen::InsensitiveStr::Ascii("idation"),
    ],
    values: &[&["intimidating"], &["intimidation"]],
    range: 7..=7,
};

static WORD_INDIK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INDIK_CHILDREN),
    value: None,
};

pub static WORD_INDIK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ation")],
    values: &[&["indication"]],
    range: 5..=5,
};

static WORD_INDIG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INDIG_CHILDREN),
    value: None,
};

pub static WORD_INDIG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eneous"),
        dictgen::InsensitiveStr::Ascii("enious"),
        dictgen::InsensitiveStr::Ascii("enius"),
        dictgen::InsensitiveStr::Ascii("enos"),
        dictgen::InsensitiveStr::Ascii("enuous"),
        dictgen::InsensitiveStr::Ascii("ineous"),
        dictgen::InsensitiveStr::Ascii("inous"),
        dictgen::InsensitiveStr::Ascii("neous"),
    ],
    values: &[
        &["indigenous"],
        &["indigenous"],
        &["indigenous"],
        &["indigenous"],
        &["indigenous"],
        &["indigenous"],
        &["indigenous"],
        &["indigenous"],
    ],
    range: 4..=6,
};

static WORD_INDIF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INDIF_CHILDREN),
    value: None,
};

pub static WORD_INDIF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ferance"),
        dictgen::InsensitiveStr::Ascii("ferant"),
        dictgen::InsensitiveStr::Ascii("ferente"),
        dictgen::InsensitiveStr::Ascii("fernce"),
        dictgen::InsensitiveStr::Ascii("fernece"),
        dictgen::InsensitiveStr::Ascii("fernt"),
    ],
    values: &[
        &["indifference"],
        &["indifferent"],
        &["indifference"],
        &["indifference"],
        &["indifference"],
        &["indifferent"],
    ],
    range: 5..=7,
};

static WORD_INDIE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INDIE_CHILDREN),
    value: None,
};

pub static WORD_INDIE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("n"),
        dictgen::InsensitiveStr::Ascii("ns"),
    ],
    values: &[&["indian", "endian"], &["indians", "endians"]],
    range: 1..=2,
};

static WORD_INDID_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INDID_CHILDREN),
    value: None,
};

pub static WORD_INDID_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("e")],
    values: &[&["inside", "indeed"]],
    range: 1..=1,
};

static WORD_INDIC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INDIC_CHILDREN),
    value: None,
};

pub static WORD_INDIC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aite"),
        dictgen::InsensitiveStr::Ascii("aste"),
        dictgen::InsensitiveStr::Ascii("at"),
        dictgen::InsensitiveStr::Ascii("ateds"),
        dictgen::InsensitiveStr::Ascii("atee"),
        dictgen::InsensitiveStr::Ascii("aters"),
        dictgen::InsensitiveStr::Ascii("ateurs"),
        dictgen::InsensitiveStr::Ascii("atie"),
        dictgen::InsensitiveStr::Ascii("ationg"),
        dictgen::InsensitiveStr::Ascii("atior"),
        dictgen::InsensitiveStr::Ascii("atiors"),
        dictgen::InsensitiveStr::Ascii("ativo"),
        dictgen::InsensitiveStr::Ascii("ato"),
        dictgen::InsensitiveStr::Ascii("atore"),
        dictgen::InsensitiveStr::Ascii("ats"),
        dictgen::InsensitiveStr::Ascii("ees"),
        dictgen::InsensitiveStr::Ascii("ence"),
        dictgen::InsensitiveStr::Ascii("entally"),
        dictgen::InsensitiveStr::Ascii("ents"),
        dictgen::InsensitiveStr::Ascii("iate"),
        dictgen::InsensitiveStr::Ascii("iated"),
        dictgen::InsensitiveStr::Ascii("iates"),
        dictgen::InsensitiveStr::Ascii("iating"),
        dictgen::InsensitiveStr::Ascii("ies"),
        dictgen::InsensitiveStr::Ascii("itave"),
        dictgen::InsensitiveStr::Ascii("itive"),
        dictgen::InsensitiveStr::Ascii("te"),
        dictgen::InsensitiveStr::Ascii("tement"),
        dictgen::InsensitiveStr::Ascii("tes"),
        dictgen::InsensitiveStr::Ascii("tor"),
        dictgen::InsensitiveStr::Ascii("trinated"),
    ],
    values: &[
        &["indicate"],
        &["indicates"],
        &["indicate"],
        &["indicated", "indicates"],
        &["indicates", "indicated"],
        &["indicates", "indicators"],
        &["indicates"],
        &["indicative"],
        &["indicating", "indication"],
        &["indicator"],
        &["indicators"],
        &["indication"],
        &["indication"],
        &["indicate"],
        &["indicators", "indicates", "indicate"],
        &["indices"],
        &["incidence"],
        &["incidentally"],
        &["incidents"],
        &["indicate"],
        &["indicated"],
        &["indicates"],
        &["indicating"],
        &["indices"],
        &["indicative"],
        &["indicative"],
        &["indicate"],
        &["indictment"],
        &["indicates"],
        &["indicator"],
        &["indoctrinated"],
    ],
    range: 2..=8,
};

static WORD_INDIA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INDIA_CHILDREN),
    value: None,
};

pub static WORD_INDIA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("an"),
        dictgen::InsensitiveStr::Ascii("ctor"),
        dictgen::InsensitiveStr::Ascii("naoplis"),
        dictgen::InsensitiveStr::Ascii("napols"),
        dictgen::InsensitiveStr::Ascii("nas"),
        dictgen::InsensitiveStr::Ascii("nds"),
        dictgen::InsensitiveStr::Ascii("nia"),
        dictgen::InsensitiveStr::Ascii("nna"),
        dictgen::InsensitiveStr::Ascii("nopolis"),
        dictgen::InsensitiveStr::Ascii("nos"),
        dictgen::InsensitiveStr::Ascii("te"),
        dictgen::InsensitiveStr::Ascii("ted"),
        dictgen::InsensitiveStr::Ascii("tes"),
        dictgen::InsensitiveStr::Ascii("ting"),
    ],
    values: &[
        &["indiana"],
        &["indicator"],
        &["indianapolis"],
        &["indianapolis"],
        &["indians"],
        &["indians"],
        &["indiana"],
        &["indiana"],
        &["indianapolis"],
        &["indians"],
        &["indicate"],
        &["indicated"],
        &["indicates"],
        &["indicating"],
    ],
    range: 2..=7,
};

static WORD_INDE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_INDE_CHILDREN),
    value: None,
};

static WORD_INDE_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    Some(&WORD_INDEC_NODE),
    Some(&WORD_INDED_NODE),
    None,
    Some(&WORD_INDEF_NODE),
    Some(&WORD_INDEG_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_INDEM_NODE),
    Some(&WORD_INDEN_NODE),
    None,
    Some(&WORD_INDEP_NODE),
    None,
    Some(&WORD_INDER_NODE),
    Some(&WORD_INDES_NODE),
    Some(&WORD_INDET_NODE),
    None,
    Some(&WORD_INDEV_NODE),
    None,
    Some(&WORD_INDEX_NODE),
    None,
    None,
];

static WORD_INDEX_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INDEX_CHILDREN),
    value: None,
};

pub static WORD_INDEX_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ig"),
        dictgen::InsensitiveStr::Ascii("s"),
        dictgen::InsensitiveStr::Ascii("t"),
    ],
    values: &[&["indexing"], &["indexes", "indices"], &["index", "indent"]],
    range: 1..=2,
};

static WORD_INDEV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INDEV_CHILDREN),
    value: None,
};

pub static WORD_INDEV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("er"),
        dictgen::InsensitiveStr::Ascii("ered"),
        dictgen::InsensitiveStr::Ascii("eres"),
        dictgen::InsensitiveStr::Ascii("ering"),
        dictgen::InsensitiveStr::Ascii("ers"),
    ],
    values: &[
        &["endeavor"],
        &["endeavored"],
        &["endeavors"],
        &["endeavoring"],
        &["endeavors"],
    ],
    range: 2..=5,
};

static WORD_INDET_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INDET_CHILDREN),
    value: None,
};

pub static WORD_INDET_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ifiable"),
        dictgen::InsensitiveStr::Ascii("ification"),
    ],
    values: &[&["identifiable"], &["identification"]],
    range: 7..=9,
};

static WORD_INDES_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INDES_CHILDREN),
    value: Some(&["index"]),
};

pub static WORD_INDES_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("criminent"),
        dictgen::InsensitiveStr::Ascii("pensable"),
        dictgen::InsensitiveStr::Ascii("pensible"),
        dictgen::InsensitiveStr::Ascii("trictible"),
        dictgen::InsensitiveStr::Ascii("tructble"),
        dictgen::InsensitiveStr::Ascii("tructibe"),
        dictgen::InsensitiveStr::Ascii("tructuble"),
    ],
    values: &[
        &["indiscriminate"],
        &["indispensable"],
        &["indispensable"],
        &["indestructible"],
        &["indestructible"],
        &["indestructible"],
        &["indestructible"],
    ],
    range: 8..=9,
};

static WORD_INDER_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INDER_CHILDREN),
    value: None,
};

pub static WORD_INDER_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ect"),
        dictgen::InsensitiveStr::Ascii("ictly"),
        dictgen::InsensitiveStr::Ascii("ts"),
    ],
    values: &[&["indirect"], &["indirectly"], &["inserts"]],
    range: 2..=5,
};

static WORD_INDEP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_INDEP_CHILDREN),
    value: None,
};

static WORD_INDEP_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_INDEPA_NODE),
    None,
    None,
    Some(&WORD_INDEPD_NODE),
    Some(&WORD_INDEPE_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_INDEPE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INDEPE_CHILDREN),
    value: None,
};

pub static WORD_INDEPE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("dantly"),
        dictgen::InsensitiveStr::Ascii("dence"),
        dictgen::InsensitiveStr::Ascii("dent"),
        dictgen::InsensitiveStr::Ascii("dently"),
        dictgen::InsensitiveStr::Ascii("dnent"),
        dictgen::InsensitiveStr::Ascii("ncence"),
        dictgen::InsensitiveStr::Ascii("nd"),
        dictgen::InsensitiveStr::Ascii("ndance"),
        dictgen::InsensitiveStr::Ascii("ndant"),
        dictgen::InsensitiveStr::Ascii("ndante"),
        dictgen::InsensitiveStr::Ascii("ndantes"),
        dictgen::InsensitiveStr::Ascii("ndantly"),
        dictgen::InsensitiveStr::Ascii("ndece"),
        dictgen::InsensitiveStr::Ascii("nded"),
        dictgen::InsensitiveStr::Ascii("ndedly"),
        dictgen::InsensitiveStr::Ascii("ndend"),
        dictgen::InsensitiveStr::Ascii("ndendet"),
        dictgen::InsensitiveStr::Ascii("ndendly"),
        dictgen::InsensitiveStr::Ascii("ndenet"),
        dictgen::InsensitiveStr::Ascii("ndenly"),
        dictgen::InsensitiveStr::Ascii("ndens"),
        dictgen::InsensitiveStr::Ascii("ndense"),
        dictgen::InsensitiveStr::Ascii("ndentally"),
        dictgen::InsensitiveStr::Ascii("ndente"),
        dictgen::InsensitiveStr::Ascii("ndentisme"),
        dictgen::InsensitiveStr::Ascii("ndentiste"),
        dictgen::InsensitiveStr::Ascii("ndentness"),
        dictgen::InsensitiveStr::Ascii("ndet"),
        dictgen::InsensitiveStr::Ascii("ndetly"),
        dictgen::InsensitiveStr::Ascii("ndetn"),
        dictgen::InsensitiveStr::Ascii("ndets"),
        dictgen::InsensitiveStr::Ascii("ndly"),
        dictgen::InsensitiveStr::Ascii("ndnent"),
        dictgen::InsensitiveStr::Ascii("ndnet"),
        dictgen::InsensitiveStr::Ascii("ndnt"),
        dictgen::InsensitiveStr::Ascii("ndntly"),
        dictgen::InsensitiveStr::Ascii("ndt"),
        dictgen::InsensitiveStr::Ascii("ndtly"),
        dictgen::InsensitiveStr::Ascii("nedent"),
        dictgen::InsensitiveStr::Ascii("nendence"),
        dictgen::InsensitiveStr::Ascii("nent"),
        dictgen::InsensitiveStr::Ascii("nently"),
        dictgen::InsensitiveStr::Ascii("nt"),
        dictgen::InsensitiveStr::Ascii("ntend"),
        dictgen::InsensitiveStr::Ascii("ntent"),
        dictgen::InsensitiveStr::Ascii("ntently"),
        dictgen::InsensitiveStr::Ascii("ntents"),
        dictgen::InsensitiveStr::Ascii("ntly"),
    ],
    values: &[
        &["independently"],
        &["independence"],
        &["independent"],
        &["independently"],
        &["independents"],
        &["independence"],
        &["independent"],
        &["independence"],
        &["independent"],
        &["independents"],
        &["independents"],
        &["independently"],
        &["independence"],
        &["independent"],
        &["independently"],
        &["independent"],
        &["independent"],
        &["independently"],
        &["independents"],
        &["independently"],
        &["independents"],
        &["independents"],
        &["independently"],
        &["independence"],
        &["independents"],
        &["independents"],
        &["independents"],
        &["independent"],
        &["independently"],
        &["independents"],
        &["independents"],
        &["independently"],
        &["independent"],
        &["independents", "independent"],
        &["independent"],
        &["independently"],
        &["independent"],
        &["independently"],
        &["independent"],
        &["independence"],
        &["independent"],
        &["independently"],
        &["independent"],
        &["independents"],
        &["independent"],
        &["independently"],
        &["independents"],
        &["independently"],
    ],
    range: 2..=9,
};

static WORD_INDEPD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INDEPD_CHILDREN),
    value: None,
};

pub static WORD_INDEPD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ence"),
        dictgen::InsensitiveStr::Ascii("encente"),
        dictgen::InsensitiveStr::Ascii("endance"),
        dictgen::InsensitiveStr::Ascii("endant"),
        dictgen::InsensitiveStr::Ascii("endantly"),
        dictgen::InsensitiveStr::Ascii("endence"),
        dictgen::InsensitiveStr::Ascii("endency"),
        dictgen::InsensitiveStr::Ascii("endent"),
        dictgen::InsensitiveStr::Ascii("endently"),
        dictgen::InsensitiveStr::Ascii("endet"),
        dictgen::InsensitiveStr::Ascii("endetly"),
        dictgen::InsensitiveStr::Ascii("enence"),
        dictgen::InsensitiveStr::Ascii("enent"),
        dictgen::InsensitiveStr::Ascii("enently"),
        dictgen::InsensitiveStr::Ascii("ent"),
        dictgen::InsensitiveStr::Ascii("ented"),
        dictgen::InsensitiveStr::Ascii("entedly"),
        dictgen::InsensitiveStr::Ascii("ently"),
    ],
    values: &[
        &["independence"],
        &["independence"],
        &["independence"],
        &["independent"],
        &["independently"],
        &["independence"],
        &["independency"],
        &["independent"],
        &["independently"],
        &["independent"],
        &["independently"],
        &["independence"],
        &["independents", "independent"],
        &["independently"],
        &["independent"],
        &["independent"],
        &["independently"],
        &["independently"],
    ],
    range: 3..=8,
};

static WORD_INDEPA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INDEPA_CHILDREN),
    value: None,
};

pub static WORD_INDEPA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ndance")],
    values: &[&["independence"]],
    range: 6..=6,
};

static WORD_INDEN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INDEN_CHILDREN),
    value: None,
};

pub static WORD_INDEN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("dation"),
        dictgen::InsensitiveStr::Ascii("ded"),
        dictgen::InsensitiveStr::Ascii("dent"),
        dictgen::InsensitiveStr::Ascii("taction"),
        dictgen::InsensitiveStr::Ascii("taion"),
        dictgen::InsensitiveStr::Ascii("tended"),
        dictgen::InsensitiveStr::Ascii("tical"),
        dictgen::InsensitiveStr::Ascii("tically"),
        dictgen::InsensitiveStr::Ascii("tifer"),
        dictgen::InsensitiveStr::Ascii("tification"),
        dictgen::InsensitiveStr::Ascii("tified"),
        dictgen::InsensitiveStr::Ascii("tifier"),
        dictgen::InsensitiveStr::Ascii("tifies"),
        dictgen::InsensitiveStr::Ascii("tifing"),
        dictgen::InsensitiveStr::Ascii("tify"),
        dictgen::InsensitiveStr::Ascii("tifying"),
        dictgen::InsensitiveStr::Ascii("tin"),
        dictgen::InsensitiveStr::Ascii("tit"),
        dictgen::InsensitiveStr::Ascii("tity"),
        dictgen::InsensitiveStr::Ascii("tleveal"),
        dictgen::InsensitiveStr::Ascii("x"),
    ],
    values: &[
        &["indentation"],
        &["intended", "indented"],
        &["indent", "indented", "independent"],
        &["indentation"],
        &["indentation"],
        &["indented"],
        &["identical"],
        &["identically"],
        &["identifier"],
        &["identification"],
        &["identified"],
        &["identifier"],
        &["identifies"],
        &["identifying"],
        &["identify"],
        &["identifying"],
        &["indent"],
        &["identity"],
        &["identity"],
        &["indentlevel"],
        &["index"],
    ],
    range: 1..=10,
};

static WORD_INDEM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INDEM_CHILDREN),
    value: None,
};

pub static WORD_INDEM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("potent")],
    values: &[&["idempotent"]],
    range: 6..=6,
};

static WORD_INDEG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INDEG_CHILDREN),
    value: None,
};

pub static WORD_INDEG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("inous")],
    values: &[&["indigenous"]],
    range: 5..=5,
};

static WORD_INDEF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INDEF_CHILDREN),
    value: None,
};

pub static WORD_INDEF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("enite"),
        dictgen::InsensitiveStr::Ascii("inate"),
        dictgen::InsensitiveStr::Ascii("inately"),
        dictgen::InsensitiveStr::Ascii("ineable"),
        dictgen::InsensitiveStr::Ascii("inete"),
        dictgen::InsensitiveStr::Ascii("inetely"),
        dictgen::InsensitiveStr::Ascii("inetly"),
        dictgen::InsensitiveStr::Ascii("ininte"),
        dictgen::InsensitiveStr::Ascii("initelly"),
        dictgen::InsensitiveStr::Ascii("initiley"),
        dictgen::InsensitiveStr::Ascii("initive"),
        dictgen::InsensitiveStr::Ascii("initively"),
        dictgen::InsensitiveStr::Ascii("initley"),
        dictgen::InsensitiveStr::Ascii("initly"),
        dictgen::InsensitiveStr::Ascii("inity"),
        dictgen::InsensitiveStr::Ascii("intiely"),
        dictgen::InsensitiveStr::Ascii("intly"),
    ],
    values: &[
        &["indefinite"],
        &["indefinite"],
        &["indefinitely"],
        &["undefinable"],
        &["indefinite"],
        &["indefinitely"],
        &["indefinitely"],
        &["indefinite"],
        &["indefinitely"],
        &["indefinitely"],
        &["indefinite"],
        &["indefinitely"],
        &["indefinitely"],
        &["indefinitely"],
        &["indefinitely"],
        &["indefinitely"],
        &["indefinitely"],
    ],
    range: 5..=9,
};

static WORD_INDED_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INDED_CHILDREN),
    value: Some(&["indeed", "index"]),
};

pub static WORD_INDED_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[],
    values: &[],
    range: 0..=0,
};

static WORD_INDEC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INDEC_CHILDREN),
    value: None,
};

pub static WORD_INDEC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ate"),
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("ies"),
    ],
    values: &[&["indicate"], &["indices"], &["indices"]],
    range: 2..=3,
};

static WORD_INDD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INDD_CHILDREN),
    value: None,
};

pub static WORD_INDD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ex"),
        dictgen::InsensitiveStr::Ascii("ividual"),
        dictgen::InsensitiveStr::Ascii("ividually"),
        dictgen::InsensitiveStr::Ascii("ividuals"),
    ],
    values: &[
        &["index"],
        &["individual"],
        &["individually"],
        &["individuals"],
    ],
    range: 2..=9,
};

static WORD_INDC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INDC_CHILDREN),
    value: None,
};

pub static WORD_INDC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ates"),
        dictgen::InsensitiveStr::Ascii("iate"),
    ],
    values: &[&["indicates"], &["indicate"]],
    range: 4..=4,
};

static WORD_INDA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INDA_CHILDREN),
    value: None,
};

pub static WORD_INDA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ins"),
        dictgen::InsensitiveStr::Ascii("vertently"),
    ],
    values: &[&["indians"], &["inadvertently"]],
    range: 3..=9,
};

static WORD_INC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_INC_CHILDREN),
    value: None,
};

static WORD_INC_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_INCA_NODE),
    None,
    None,
    None,
    Some(&WORD_INCE_NODE),
    None,
    Some(&WORD_INCG_NODE),
    Some(&WORD_INCH_NODE),
    Some(&WORD_INCI_NODE),
    None,
    None,
    Some(&WORD_INCL_NODE),
    Some(&WORD_INCM_NODE),
    None,
    Some(&WORD_INCO_NODE),
    Some(&WORD_INCP_NODE),
    None,
    Some(&WORD_INCR_NODE),
    None,
    Some(&WORD_INCT_NODE),
    Some(&WORD_INCU_NODE),
    Some(&WORD_INCV_NODE),
    None,
    None,
    None,
    None,
];

static WORD_INCV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INCV_CHILDREN),
    value: None,
};

pub static WORD_INCV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("alid")],
    values: &[&["invalid"]],
    range: 4..=4,
};

static WORD_INCU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INCU_CHILDREN),
    value: None,
};

pub static WORD_INCU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("de"),
        dictgen::InsensitiveStr::Ascii("ded"),
        dictgen::InsensitiveStr::Ascii("des"),
        dictgen::InsensitiveStr::Ascii("ding"),
        dictgen::InsensitiveStr::Ascii("lde"),
        dictgen::InsensitiveStr::Ascii("lded"),
        dictgen::InsensitiveStr::Ascii("ldes"),
        dictgen::InsensitiveStr::Ascii("lding"),
        dictgen::InsensitiveStr::Ascii("nabla"),
        dictgen::InsensitiveStr::Ascii("re"),
        dictgen::InsensitiveStr::Ascii("rruptable"),
        dictgen::InsensitiveStr::Ascii("rruptible"),
    ],
    values: &[
        &["include"],
        &["included"],
        &["includes"],
        &["including"],
        &["include"],
        &["included"],
        &["includes"],
        &["including"],
        &["incunabula"],
        &["incur"],
        &["incorruptible"],
        &["incorruptible"],
    ],
    range: 2..=9,
};

static WORD_INCT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INCT_CHILDREN),
    value: None,
};

pub static WORD_INCT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ance"),
        dictgen::InsensitiveStr::Ascii("roduce"),
        dictgen::InsensitiveStr::Ascii("roduced"),
    ],
    values: &[&["instance"], &["introduce"], &["introduced"]],
    range: 4..=7,
};

static WORD_INCR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INCR_CHILDREN),
    value: None,
};

pub static WORD_INCR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("amental"),
        dictgen::InsensitiveStr::Ascii("amentally"),
        dictgen::InsensitiveStr::Ascii("aments"),
        dictgen::InsensitiveStr::Ascii("eadible"),
        dictgen::InsensitiveStr::Ascii("eading"),
        dictgen::InsensitiveStr::Ascii("eaing"),
        dictgen::InsensitiveStr::Ascii("eament"),
        dictgen::InsensitiveStr::Ascii("eas"),
        dictgen::InsensitiveStr::Ascii("edable"),
        dictgen::InsensitiveStr::Ascii("edably"),
        dictgen::InsensitiveStr::Ascii("ediable"),
        dictgen::InsensitiveStr::Ascii("ediably"),
        dictgen::InsensitiveStr::Ascii("edibe"),
        dictgen::InsensitiveStr::Ascii("edibile"),
        dictgen::InsensitiveStr::Ascii("edibily"),
        dictgen::InsensitiveStr::Ascii("ediblely"),
        dictgen::InsensitiveStr::Ascii("edibley"),
        dictgen::InsensitiveStr::Ascii("ediby"),
        dictgen::InsensitiveStr::Ascii("emantal"),
        dictgen::InsensitiveStr::Ascii("emeant"),
        dictgen::InsensitiveStr::Ascii("emeantal"),
        dictgen::InsensitiveStr::Ascii("emeanted"),
        dictgen::InsensitiveStr::Ascii("emeanting"),
        dictgen::InsensitiveStr::Ascii("emeants"),
        dictgen::InsensitiveStr::Ascii("ememnts"),
        dictgen::InsensitiveStr::Ascii("emenet"),
        dictgen::InsensitiveStr::Ascii("emenetd"),
        dictgen::InsensitiveStr::Ascii("emeneted"),
        dictgen::InsensitiveStr::Ascii("emenets"),
        dictgen::InsensitiveStr::Ascii("ementall"),
        dictgen::InsensitiveStr::Ascii("ementaly"),
        dictgen::InsensitiveStr::Ascii("ementarla"),
        dictgen::InsensitiveStr::Ascii("ementarlo"),
        dictgen::InsensitiveStr::Ascii("ementas"),
        dictgen::InsensitiveStr::Ascii("ementers"),
        dictgen::InsensitiveStr::Ascii("emential"),
        dictgen::InsensitiveStr::Ascii("emently"),
        dictgen::InsensitiveStr::Ascii("ementos"),
        dictgen::InsensitiveStr::Ascii("emet"),
        dictgen::InsensitiveStr::Ascii("emetal"),
        dictgen::InsensitiveStr::Ascii("emeted"),
        dictgen::InsensitiveStr::Ascii("emeting"),
        dictgen::InsensitiveStr::Ascii("emnet"),
        dictgen::InsensitiveStr::Ascii("ese"),
        dictgen::InsensitiveStr::Ascii("esed"),
        dictgen::InsensitiveStr::Ascii("eses"),
        dictgen::InsensitiveStr::Ascii("esing"),
        dictgen::InsensitiveStr::Ascii("femental"),
        dictgen::InsensitiveStr::Ascii("imental"),
        dictgen::InsensitiveStr::Ascii("iments"),
        dictgen::InsensitiveStr::Ascii("menet"),
        dictgen::InsensitiveStr::Ascii("menetd"),
        dictgen::InsensitiveStr::Ascii("meneted"),
        dictgen::InsensitiveStr::Ascii("ment"),
        dictgen::InsensitiveStr::Ascii("mental"),
        dictgen::InsensitiveStr::Ascii("mentally"),
        dictgen::InsensitiveStr::Ascii("mented"),
        dictgen::InsensitiveStr::Ascii("menting"),
        dictgen::InsensitiveStr::Ascii("ments"),
        dictgen::InsensitiveStr::Ascii("ompehensible"),
    ],
    values: &[
        &["incremental"],
        &["incrementally"],
        &["increments"],
        &["incredible"],
        &["increasing"],
        &["increasing"],
        &["increment"],
        &["increase"],
        &["incredible"],
        &["incredibly"],
        &["incredible"],
        &["incredibly"],
        &["incredible"],
        &["incredible"],
        &["incredibly"],
        &["incredibly"],
        &["incredibly"],
        &["incredibly"],
        &["incremental"],
        &["increment"],
        &["incremental"],
        &["incremented"],
        &["incrementing"],
        &["increments"],
        &["increments"],
        &["increment"],
        &["incremented"],
        &["incremented"],
        &["increments"],
        &["incremental", "incrementally"],
        &["incrementally"],
        &["incremental"],
        &["incremental"],
        &["increments"],
        &["increments"],
        &["incremental"],
        &["incremental"],
        &["increments"],
        &["increment"],
        &["incremental"],
        &["incremented"],
        &["incrementing"],
        &["increment"],
        &["increase"],
        &["increased"],
        &["increases"],
        &["increasing"],
        &["incremental"],
        &["incremental"],
        &["increments"],
        &["increment"],
        &["incremented"],
        &["incremented"],
        &["increment"],
        &["incremental"],
        &["incrementally"],
        &["incremented"],
        &["incrementing"],
        &["increments"],
        &["incomprehensible"],
    ],
    range: 3..=12,
};

static WORD_INCP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INCP_CHILDREN),
    value: None,
};

pub static WORD_INCP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("etion")],
    values: &[&["inception"]],
    range: 5..=5,
};

static WORD_INCO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_INCO_CHILDREN),
    value: None,
};

static WORD_INCO_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_INCOG_NODE),
    Some(&WORD_INCOH_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_INCOM_NODE),
    Some(&WORD_INCON_NODE),
    Some(&WORD_INCOO_NODE),
    Some(&WORD_INCOP_NODE),
    None,
    Some(&WORD_INCOR_NODE),
    Some(&WORD_INCOS_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_INCOS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INCOS_CHILDREN),
    value: None,
};

pub static WORD_INCOS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("istencies"),
        dictgen::InsensitiveStr::Ascii("istency"),
        dictgen::InsensitiveStr::Ascii("istent"),
        dictgen::InsensitiveStr::Ascii("istente"),
    ],
    values: &[
        &["inconsistencies"],
        &["inconsistency"],
        &["inconsistent"],
        &["inconsistent"],
    ],
    range: 6..=9,
};

static WORD_INCOR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INCOR_CHILDREN),
    value: None,
};

pub static WORD_INCOR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ect"),
        dictgen::InsensitiveStr::Ascii("ectly"),
        dictgen::InsensitiveStr::Ascii("opate"),
        dictgen::InsensitiveStr::Ascii("opates"),
        dictgen::InsensitiveStr::Ascii("oporated"),
        dictgen::InsensitiveStr::Ascii("oprate"),
        dictgen::InsensitiveStr::Ascii("parate"),
        dictgen::InsensitiveStr::Ascii("parated"),
        dictgen::InsensitiveStr::Ascii("parates"),
        dictgen::InsensitiveStr::Ascii("parating"),
        dictgen::InsensitiveStr::Ascii("perate"),
        dictgen::InsensitiveStr::Ascii("perated"),
        dictgen::InsensitiveStr::Ascii("perates"),
        dictgen::InsensitiveStr::Ascii("perating"),
        dictgen::InsensitiveStr::Ascii("peration"),
        dictgen::InsensitiveStr::Ascii("porare"),
        dictgen::InsensitiveStr::Ascii("pore"),
        dictgen::InsensitiveStr::Ascii("portaed"),
        dictgen::InsensitiveStr::Ascii("portate"),
        dictgen::InsensitiveStr::Ascii("ported"),
        dictgen::InsensitiveStr::Ascii("prates"),
        dictgen::InsensitiveStr::Ascii("proate"),
        dictgen::InsensitiveStr::Ascii("reclty"),
        dictgen::InsensitiveStr::Ascii("recly"),
        dictgen::InsensitiveStr::Ascii("recty"),
        dictgen::InsensitiveStr::Ascii("reect"),
        dictgen::InsensitiveStr::Ascii("reectly"),
        dictgen::InsensitiveStr::Ascii("rent"),
        dictgen::InsensitiveStr::Ascii("ret"),
        dictgen::InsensitiveStr::Ascii("retly"),
        dictgen::InsensitiveStr::Ascii("rrect"),
        dictgen::InsensitiveStr::Ascii("rrectly"),
        dictgen::InsensitiveStr::Ascii("ruptable"),
    ],
    values: &[
        &["incorrect"],
        &["incorrectly"],
        &["incorporate"],
        &["incorporates"],
        &["incorporated"],
        &["incorporate"],
        &["incorporate"],
        &["incorporated"],
        &["incorporates"],
        &["incorporating"],
        &["incorporate"],
        &["incorporated"],
        &["incorporates"],
        &["incorporating"],
        &["incorporation"],
        &["incorporate"],
        &["incorporate"],
        &["incorporated"],
        &["incorporate"],
        &["incorporated"],
        &["incorporates"],
        &["incorporated"],
        &["incorrectly"],
        &["incorrectly"],
        &["incorrectly"],
        &["incorrect"],
        &["incorrectly"],
        &["incorrect"],
        &["incorrect"],
        &["incorrectly"],
        &["incorrect"],
        &["incorrectly"],
        &["incorruptible"],
    ],
    range: 3..=8,
};

static WORD_INCOP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INCOP_CHILDREN),
    value: None,
};

pub static WORD_INCOP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("erate"),
        dictgen::InsensitiveStr::Ascii("erated"),
        dictgen::InsensitiveStr::Ascii("erates"),
        dictgen::InsensitiveStr::Ascii("erating"),
        dictgen::InsensitiveStr::Ascii("orate"),
        dictgen::InsensitiveStr::Ascii("orated"),
        dictgen::InsensitiveStr::Ascii("orates"),
        dictgen::InsensitiveStr::Ascii("orating"),
        dictgen::InsensitiveStr::Ascii("rorate"),
        dictgen::InsensitiveStr::Ascii("rorated"),
        dictgen::InsensitiveStr::Ascii("rorates"),
        dictgen::InsensitiveStr::Ascii("rorating"),
    ],
    values: &[
        &["incorporate"],
        &["incorporated"],
        &["incorporates"],
        &["incorporating"],
        &["incorporate"],
        &["incorporated"],
        &["incorporates"],
        &["incorporating"],
        &["incorporate"],
        &["incorporated"],
        &["incorporates"],
        &["incorporating"],
    ],
    range: 5..=8,
};

static WORD_INCOO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INCOO_CHILDREN),
    value: None,
};

pub static WORD_INCOO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("perates")],
    values: &[&["incorporates"]],
    range: 7..=7,
};

static WORD_INCON_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_INCON_CHILDREN),
    value: None,
};

static WORD_INCON_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    Some(&WORD_INCONC_NODE),
    Some(&WORD_INCOND_NODE),
    None,
    Some(&WORD_INCONF_NODE),
    Some(&WORD_INCONG_NODE),
    None,
    Some(&WORD_INCONI_NODE),
    None,
    None,
    Some(&WORD_INCONL_NODE),
    None,
    None,
    None,
    Some(&WORD_INCONP_NODE),
    None,
    None,
    Some(&WORD_INCONS_NODE),
    Some(&WORD_INCONT_NODE),
    None,
    Some(&WORD_INCONV_NODE),
    None,
    None,
    None,
    None,
];

static WORD_INCONV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INCONV_CHILDREN),
    value: None,
};

pub static WORD_INCONV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("einence"),
        dictgen::InsensitiveStr::Ascii("einent"),
        dictgen::InsensitiveStr::Ascii("eniance"),
        dictgen::InsensitiveStr::Ascii("eniant"),
        dictgen::InsensitiveStr::Ascii("eniantly"),
        dictgen::InsensitiveStr::Ascii("eniece"),
        dictgen::InsensitiveStr::Ascii("eniente"),
        dictgen::InsensitiveStr::Ascii("eniet"),
        dictgen::InsensitiveStr::Ascii("enince"),
        dictgen::InsensitiveStr::Ascii("entional"),
        dictgen::InsensitiveStr::Ascii("ertable"),
        dictgen::InsensitiveStr::Ascii("ienence"),
        dictgen::InsensitiveStr::Ascii("ienenced"),
        dictgen::InsensitiveStr::Ascii("ienent"),
        dictgen::InsensitiveStr::Ascii("ienience"),
        dictgen::InsensitiveStr::Ascii("ienient"),
        dictgen::InsensitiveStr::Ascii("ineance"),
        dictgen::InsensitiveStr::Ascii("ineances"),
        dictgen::InsensitiveStr::Ascii("inence"),
        dictgen::InsensitiveStr::Ascii("inences"),
        dictgen::InsensitiveStr::Ascii("iniance"),
        dictgen::InsensitiveStr::Ascii("iniances"),
        dictgen::InsensitiveStr::Ascii("inience"),
        dictgen::InsensitiveStr::Ascii("iniences"),
        dictgen::InsensitiveStr::Ascii("iniency"),
        dictgen::InsensitiveStr::Ascii("iniencys"),
    ],
    values: &[
        &["inconvenience"],
        &["inconvenient"],
        &["inconvenience"],
        &["inconvenient"],
        &["inconveniently"],
        &["inconvenience"],
        &["inconvenience"],
        &["inconvenient"],
        &["inconvenience"],
        &["unconventional"],
        &["inconvertible"],
        &["inconvenience"],
        &["inconvenience"],
        &["inconvenient"],
        &["inconvenience"],
        &["inconvenient"],
        &["inconvenience"],
        &["inconveniences"],
        &["inconvenience"],
        &["inconveniences"],
        &["inconvenience"],
        &["inconveniences"],
        &["inconvenience"],
        &["inconveniences"],
        &["inconvenience"],
        &["inconveniences"],
    ],
    range: 5..=8,
};

static WORD_INCONT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INCONT_CHILDREN),
    value: None,
};

pub static WORD_INCONT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("rollably")],
    values: &[&["uncontrollably"]],
    range: 8..=8,
};

static WORD_INCONS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INCONS_CHILDREN),
    value: None,
};

pub static WORD_INCONS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ciously"),
        dictgen::InsensitiveStr::Ascii("ecuential"),
        dictgen::InsensitiveStr::Ascii("equantial"),
        dictgen::InsensitiveStr::Ascii("equencial"),
        dictgen::InsensitiveStr::Ascii("equental"),
        dictgen::InsensitiveStr::Ascii("equentional"),
        dictgen::InsensitiveStr::Ascii("equentual"),
        dictgen::InsensitiveStr::Ascii("iderant"),
        dictgen::InsensitiveStr::Ascii("iquential"),
        dictgen::InsensitiveStr::Ascii("isent"),
        dictgen::InsensitiveStr::Ascii("isently"),
        dictgen::InsensitiveStr::Ascii("isntency"),
        dictgen::InsensitiveStr::Ascii("istance"),
        dictgen::InsensitiveStr::Ascii("istancies"),
        dictgen::InsensitiveStr::Ascii("istancy"),
        dictgen::InsensitiveStr::Ascii("istant"),
        dictgen::InsensitiveStr::Ascii("istecy"),
        dictgen::InsensitiveStr::Ascii("isten"),
        dictgen::InsensitiveStr::Ascii("istencias"),
        dictgen::InsensitiveStr::Ascii("istend"),
        dictgen::InsensitiveStr::Ascii("istendly"),
        dictgen::InsensitiveStr::Ascii("istendt"),
        dictgen::InsensitiveStr::Ascii("istendtly"),
        dictgen::InsensitiveStr::Ascii("istenly"),
        dictgen::InsensitiveStr::Ascii("istensies"),
        dictgen::InsensitiveStr::Ascii("istensy"),
        dictgen::InsensitiveStr::Ascii("istentcies"),
        dictgen::InsensitiveStr::Ascii("istentcy"),
        dictgen::InsensitiveStr::Ascii("istented"),
        dictgen::InsensitiveStr::Ascii("istenties"),
        dictgen::InsensitiveStr::Ascii("istenty"),
        dictgen::InsensitiveStr::Ascii("isteny"),
        dictgen::InsensitiveStr::Ascii("itant"),
        dictgen::InsensitiveStr::Ascii("itency"),
        dictgen::InsensitiveStr::Ascii("itent"),
        dictgen::InsensitiveStr::Ascii("tent"),
        dictgen::InsensitiveStr::Ascii("titutional"),
    ],
    values: &[
        &["unconsciously"],
        &["inconsequential"],
        &["inconsequential"],
        &["inconsequential"],
        &["inconsequential"],
        &["inconsequential"],
        &["inconsequential"],
        &["inconsiderate"],
        &["inconsequential"],
        &["inconsistent"],
        &["inconsistently"],
        &["inconsistency"],
        &["inconsistency"],
        &["inconsistencies"],
        &["inconsistency"],
        &["inconsistent"],
        &["inconsistency"],
        &["inconsistent"],
        &["inconsistencies"],
        &["inconsistent"],
        &["inconsistently"],
        &["inconsistent"],
        &["inconsistently"],
        &["inconsistency", "inconsistently"],
        &["inconsistencies"],
        &["inconsistency"],
        &["inconsistencies"],
        &["inconsistency"],
        &["inconsistent"],
        &["inconsistencies"],
        &["inconsistency"],
        &["inconsistency", "inconsistent"],
        &["inconsistent"],
        &["inconsistency"],
        &["inconsistent"],
        &["inconsistent", "inconstant"],
        &["unconstitutional"],
    ],
    range: 4..=11,
};

static WORD_INCONP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INCONP_CHILDREN),
    value: None,
};

pub static WORD_INCONP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("rehensible")],
    values: &[&["incomprehensible"]],
    range: 10..=10,
};

static WORD_INCONL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INCONL_CHILDREN),
    value: None,
};

pub static WORD_INCONL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("usive")],
    values: &[&["inconclusive"]],
    range: 5..=5,
};

static WORD_INCONI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INCONI_CHILDREN),
    value: None,
};

pub static WORD_INCONI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("sistent"),
        dictgen::InsensitiveStr::Ascii("stencies"),
    ],
    values: &[&["inconsistent"], &["inconsistencies"]],
    range: 7..=8,
};

static WORD_INCONG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INCONG_CHILDREN),
    value: None,
};

pub static WORD_INCONG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ito")],
    values: &[&["incognito"]],
    range: 3..=3,
};

static WORD_INCONF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INCONF_CHILDREN),
    value: None,
};

pub static WORD_INCONF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ort"),
        dictgen::InsensitiveStr::Ascii("ortable"),
    ],
    values: &[&["discomfort", "uncomfortable"], &["uncomfortable"]],
    range: 3..=7,
};

static WORD_INCOND_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INCOND_CHILDREN),
    value: None,
};

pub static WORD_INCOND_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("itional"),
        dictgen::InsensitiveStr::Ascii("itionally"),
    ],
    values: &[&["unconditional"], &["unconditionally"]],
    range: 7..=9,
};

static WORD_INCONC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INCONC_CHILDREN),
    value: None,
};

pub static WORD_INCONC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("equential"),
        dictgen::InsensitiveStr::Ascii("iderate"),
        dictgen::InsensitiveStr::Ascii("istencies"),
        dictgen::InsensitiveStr::Ascii("istency"),
        dictgen::InsensitiveStr::Ascii("istent"),
    ],
    values: &[
        &["inconsequential"],
        &["inconsiderate"],
        &["inconsistencies"],
        &["inconsistency"],
        &["inconsistent"],
    ],
    range: 6..=9,
};

static WORD_INCOM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_INCOM_CHILDREN),
    value: None,
};

static WORD_INCOM_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_INCOMA_NODE),
    Some(&WORD_INCOMB_NODE),
    None,
    None,
    None,
    Some(&WORD_INCOMF_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_INCOMM_NODE),
    None,
    None,
    Some(&WORD_INCOMP_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_INCOMP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INCOMP_CHILDREN),
    value: None,
};

pub static WORD_INCOMP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aitible"),
        dictgen::InsensitiveStr::Ascii("aitiblity"),
        dictgen::InsensitiveStr::Ascii("arible"),
        dictgen::InsensitiveStr::Ascii("artible"),
        dictgen::InsensitiveStr::Ascii("asitate"),
        dictgen::InsensitiveStr::Ascii("asitated"),
        dictgen::InsensitiveStr::Ascii("asitates"),
        dictgen::InsensitiveStr::Ascii("asitating"),
        dictgen::InsensitiveStr::Ascii("atabable"),
        dictgen::InsensitiveStr::Ascii("atabiity"),
        dictgen::InsensitiveStr::Ascii("atabile"),
        dictgen::InsensitiveStr::Ascii("atabilities"),
        dictgen::InsensitiveStr::Ascii("atability"),
        dictgen::InsensitiveStr::Ascii("atabillity"),
        dictgen::InsensitiveStr::Ascii("atabilty"),
        dictgen::InsensitiveStr::Ascii("atabily"),
        dictgen::InsensitiveStr::Ascii("atable"),
        dictgen::InsensitiveStr::Ascii("atablie"),
        dictgen::InsensitiveStr::Ascii("atablility"),
        dictgen::InsensitiveStr::Ascii("atablities"),
        dictgen::InsensitiveStr::Ascii("atablitiy"),
        dictgen::InsensitiveStr::Ascii("atablity"),
        dictgen::InsensitiveStr::Ascii("atably"),
        dictgen::InsensitiveStr::Ascii("ataibility"),
        dictgen::InsensitiveStr::Ascii("ataible"),
        dictgen::InsensitiveStr::Ascii("ataility"),
        dictgen::InsensitiveStr::Ascii("atatbility"),
        dictgen::InsensitiveStr::Ascii("atatble"),
        dictgen::InsensitiveStr::Ascii("atatible"),
        dictgen::InsensitiveStr::Ascii("atbility"),
        dictgen::InsensitiveStr::Ascii("atble"),
        dictgen::InsensitiveStr::Ascii("atent"),
        dictgen::InsensitiveStr::Ascii("atiability"),
        dictgen::InsensitiveStr::Ascii("atiable"),
        dictgen::InsensitiveStr::Ascii("atibil"),
        dictgen::InsensitiveStr::Ascii("atibile"),
        dictgen::InsensitiveStr::Ascii("atibilies"),
        dictgen::InsensitiveStr::Ascii("atiblities"),
        dictgen::InsensitiveStr::Ascii("atiblity"),
        dictgen::InsensitiveStr::Ascii("etance"),
        dictgen::InsensitiveStr::Ascii("etant"),
        dictgen::InsensitiveStr::Ascii("ete"),
        dictgen::InsensitiveStr::Ascii("etente"),
        dictgen::InsensitiveStr::Ascii("etentence"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("itable"),
        dictgen::InsensitiveStr::Ascii("itent"),
        dictgen::InsensitiveStr::Ascii("leate"),
        dictgen::InsensitiveStr::Ascii("leete"),
        dictgen::InsensitiveStr::Ascii("letd"),
        dictgen::InsensitiveStr::Ascii("otent"),
        dictgen::InsensitiveStr::Ascii("rehencible"),
        dictgen::InsensitiveStr::Ascii("rehendible"),
        dictgen::InsensitiveStr::Ascii("rehenisble"),
        dictgen::InsensitiveStr::Ascii("rehensable"),
        dictgen::InsensitiveStr::Ascii("rehensibe"),
        dictgen::InsensitiveStr::Ascii("rehesible"),
        dictgen::InsensitiveStr::Ascii("rehinsible"),
        dictgen::InsensitiveStr::Ascii("rihensible"),
        dictgen::InsensitiveStr::Ascii("table"),
        dictgen::InsensitiveStr::Ascii("tetent"),
        dictgen::InsensitiveStr::Ascii("tible"),
    ],
    values: &[
        &["incompatible"],
        &["incompatibility"],
        &["incompatible", "incomparable"],
        &["incompatible"],
        &["incapacitate"],
        &["incapacitated"],
        &["incapacitates"],
        &["incapacitating"],
        &["incompatible"],
        &["incompatibility"],
        &["incompatible"],
        &["incompatibilities"],
        &["incompatibility"],
        &["incompatibility"],
        &["incompatibility"],
        &["incompatibility"],
        &["incompatible"],
        &["incompatible", "incompatibly"],
        &["incompatibility"],
        &["incompatibilities"],
        &["incompatibility"],
        &["incompatibility"],
        &["incompatibly"],
        &["incompatibility"],
        &["incompatible"],
        &["incompatibility"],
        &["incompatibility"],
        &["incompatible"],
        &["incompatible"],
        &["incompatibility"],
        &["incompatible"],
        &["incompetent"],
        &["incompatibility"],
        &["incompatible"],
        &["incompatible"],
        &["incompatible"],
        &["incompatibilities"],
        &["incompatibilities"],
        &["incompatibility"],
        &["incompetence"],
        &["incompetent"],
        &["incomplete"],
        &["incompetence"],
        &["incompetence"],
        &["incoming"],
        &["incompatible"],
        &["incompetent"],
        &["incomplete"],
        &["incomplete"],
        &["incomplete"],
        &["incompetent"],
        &["incomprehensible"],
        &["incomprehensible"],
        &["incomprehensible"],
        &["incomprehensible"],
        &["incomprehensible"],
        &["incomprehensible"],
        &["incomprehensible"],
        &["incomprehensible"],
        &["incompatible"],
        &["incompetent"],
        &["incompatible"],
    ],
    range: 3..=11,
};

static WORD_INCOMM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INCOMM_CHILDREN),
    value: None,
};

pub static WORD_INCOMM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("plete"),
    ],
    values: &[&["incoming"], &["incomplete"]],
    range: 3..=5,
};

static WORD_INCOMF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INCOMF_CHILDREN),
    value: None,
};

pub static WORD_INCOMF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ort"),
        dictgen::InsensitiveStr::Ascii("ortable"),
        dictgen::InsensitiveStr::Ascii("ortably"),
    ],
    values: &[
        &["discomfort", "uncomfortable"],
        &["uncomfortable"],
        &["uncomfortably"],
    ],
    range: 3..=7,
};

static WORD_INCOMB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INCOMB_CHILDREN),
    value: None,
};

pub static WORD_INCOMB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("atibilities"),
        dictgen::InsensitiveStr::Ascii("atibility"),
    ],
    values: &[&["incompatibilities"], &["incompatibility"]],
    range: 9..=11,
};

static WORD_INCOMA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INCOMA_CHILDREN),
    value: None,
};

pub static WORD_INCOMA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("patibility"),
        dictgen::InsensitiveStr::Ascii("patible"),
        dictgen::InsensitiveStr::Ascii("ptibele"),
        dictgen::InsensitiveStr::Ascii("ptibelities"),
        dictgen::InsensitiveStr::Ascii("ptibelity"),
        dictgen::InsensitiveStr::Ascii("ptible"),
        dictgen::InsensitiveStr::Ascii("tible"),
    ],
    values: &[
        &["incompatibility"],
        &["incompatible"],
        &["incompatible"],
        &["incompatibilities"],
        &["incompatibility"],
        &["incompatible"],
        &["incompatible"],
    ],
    range: 5..=11,
};

static WORD_INCOH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INCOH_CHILDREN),
    value: None,
};

pub static WORD_INCOH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("erance"),
        dictgen::InsensitiveStr::Ascii("erancy"),
        dictgen::InsensitiveStr::Ascii("erant"),
        dictgen::InsensitiveStr::Ascii("erantly"),
        dictgen::InsensitiveStr::Ascii("errent"),
        dictgen::InsensitiveStr::Ascii("orent"),
    ],
    values: &[
        &["incoherence"],
        &["incoherency"],
        &["incoherent"],
        &["incoherently"],
        &["incoherent"],
        &["incoherent"],
    ],
    range: 5..=7,
};

static WORD_INCOG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INCOG_CHILDREN),
    value: None,
};

pub static WORD_INCOG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("into"),
        dictgen::InsensitiveStr::Ascii("nitio"),
        dictgen::InsensitiveStr::Ascii("nition"),
    ],
    values: &[&["incognito"], &["incognito"], &["incognito"]],
    range: 4..=6,
};

static WORD_INCM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INCM_CHILDREN),
    value: None,
};

pub static WORD_INCM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("rement")],
    values: &[&["increment"]],
    range: 6..=6,
};

static WORD_INCL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INCL_CHILDREN),
    value: None,
};

pub static WORD_INCL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("anation"),
        dictgen::InsensitiveStr::Ascii("ding"),
        dictgen::InsensitiveStr::Ascii("due"),
        dictgen::InsensitiveStr::Ascii("dued"),
        dictgen::InsensitiveStr::Ascii("dues"),
        dictgen::InsensitiveStr::Ascii("enation"),
        dictgen::InsensitiveStr::Ascii("inacion"),
        dictgen::InsensitiveStr::Ascii("inaison"),
        dictgen::InsensitiveStr::Ascii("inato"),
        dictgen::InsensitiveStr::Ascii("ince"),
        dictgen::InsensitiveStr::Ascii("inde"),
        dictgen::InsensitiveStr::Ascii("iude"),
        dictgen::InsensitiveStr::Ascii("iuded"),
        dictgen::InsensitiveStr::Ascii("iudes"),
        dictgen::InsensitiveStr::Ascii("iuding"),
        dictgen::InsensitiveStr::Ascii("ode"),
        dictgen::InsensitiveStr::Ascii("reased"),
        dictgen::InsensitiveStr::Ascii("ud"),
        dictgen::InsensitiveStr::Ascii("udea"),
        dictgen::InsensitiveStr::Ascii("udeds"),
        dictgen::InsensitiveStr::Ascii("udee"),
        dictgen::InsensitiveStr::Ascii("udeing"),
        dictgen::InsensitiveStr::Ascii("udied"),
        dictgen::InsensitiveStr::Ascii("udig"),
        dictgen::InsensitiveStr::Ascii("udign"),
        dictgen::InsensitiveStr::Ascii("udng"),
        dictgen::InsensitiveStr::Ascii("ue"),
        dictgen::InsensitiveStr::Ascii("ued"),
        dictgen::InsensitiveStr::Ascii("ues"),
        dictgen::InsensitiveStr::Ascii("uging"),
        dictgen::InsensitiveStr::Ascii("uide"),
        dictgen::InsensitiveStr::Ascii("uing"),
        dictgen::InsensitiveStr::Ascii("use"),
        dictgen::InsensitiveStr::Ascii("used"),
        dictgen::InsensitiveStr::Ascii("using"),
        dictgen::InsensitiveStr::Ascii("usinve"),
        dictgen::InsensitiveStr::Ascii("ution"),
        dictgen::InsensitiveStr::Ascii("utions"),
    ],
    values: &[
        &["inclination"],
        &["including"],
        &["include"],
        &["included"],
        &["includes"],
        &["inclination"],
        &["inclination"],
        &["inclination"],
        &["inclination"],
        &["incline"],
        &["incline"],
        &["include"],
        &["included"],
        &["includes"],
        &["including"],
        &["include"],
        &["increased"],
        &["include"],
        &["include"],
        &["includes", "included"],
        &["include"],
        &["including"],
        &["included"],
        &["including"],
        &["including"],
        &["including"],
        &["include"],
        &["included"],
        &["includes"],
        &["including"],
        &["include"],
        &["including"],
        &["includes"],
        &["included"],
        &["including"],
        &["inclusive"],
        &["inclusion"],
        &["inclusions"],
    ],
    range: 2..=7,
};

static WORD_INCI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INCI_CHILDREN),
    value: None,
};

pub static WORD_INCI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("dencies"),
        dictgen::InsensitiveStr::Ascii("dentaly"),
        dictgen::InsensitiveStr::Ascii("dentes"),
        dictgen::InsensitiveStr::Ascii("dential"),
        dictgen::InsensitiveStr::Ascii("dentially"),
        dictgen::InsensitiveStr::Ascii("dently"),
        dictgen::InsensitiveStr::Ascii("dentul"),
    ],
    values: &[
        &["incidence"],
        &["incidentally"],
        &["incidents"],
        &["incidental"],
        &["incidentally"],
        &["incidentally"],
        &["incidental"],
    ],
    range: 6..=9,
};

static WORD_INCH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INCH_CHILDREN),
    value: None,
};

pub static WORD_INCH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("oerent")],
    values: &[&["incoherent"]],
    range: 6..=6,
};

static WORD_INCG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INCG_CHILDREN),
    value: None,
};

pub static WORD_INCG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("onito")],
    values: &[&["incognito"]],
    range: 5..=5,
};

static WORD_INCE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INCE_CHILDREN),
    value: None,
};

pub static WORD_INCE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("dentally"),
        dictgen::InsensitiveStr::Ascii("ment"),
        dictgen::InsensitiveStr::Ascii("mental"),
        dictgen::InsensitiveStr::Ascii("mentally"),
        dictgen::InsensitiveStr::Ascii("mented"),
        dictgen::InsensitiveStr::Ascii("ments"),
        dictgen::InsensitiveStr::Ascii("ntivare"),
        dictgen::InsensitiveStr::Ascii("ntivate"),
        dictgen::InsensitiveStr::Ascii("ntiveise"),
        dictgen::InsensitiveStr::Ascii("ntivice"),
        dictgen::InsensitiveStr::Ascii("ntivies"),
        dictgen::InsensitiveStr::Ascii("ntivos"),
        dictgen::InsensitiveStr::Ascii("rase"),
        dictgen::InsensitiveStr::Ascii("rased"),
        dictgen::InsensitiveStr::Ascii("rasing"),
        dictgen::InsensitiveStr::Ascii("rceration"),
        dictgen::InsensitiveStr::Ascii("stigator"),
    ],
    values: &[
        &["incidentally"],
        &["increment"],
        &["incremental"],
        &["incrementally"],
        &["incremented"],
        &["increments"],
        &["incentive"],
        &["incentive"],
        &["incentives"],
        &["incentive"],
        &["incentives"],
        &["incentives"],
        &["increase"],
        &["increased"],
        &["increasing"],
        &["incarceration"],
        &["investigator"],
    ],
    range: 4..=9,
};

static WORD_INCA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INCA_CHILDREN),
    value: None,
};

pub static WORD_INCA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("lid"),
        dictgen::InsensitiveStr::Ascii("rantion"),
        dictgen::InsensitiveStr::Ascii("rcaration"),
        dictgen::InsensitiveStr::Ascii("rcelated"),
        dictgen::InsensitiveStr::Ascii("rcerato"),
        dictgen::InsensitiveStr::Ascii("rcirated"),
        dictgen::InsensitiveStr::Ascii("rciration"),
        dictgen::InsensitiveStr::Ascii("rnacion"),
        dictgen::InsensitiveStr::Ascii("rnato"),
        dictgen::InsensitiveStr::Ascii("rnaton"),
        dictgen::InsensitiveStr::Ascii("rserated"),
        dictgen::InsensitiveStr::Ascii("rseration"),
        dictgen::InsensitiveStr::Ascii("tation"),
        dictgen::InsensitiveStr::Ascii("tations"),
        dictgen::InsensitiveStr::Ascii("tive"),
    ],
    values: &[
        &["invalid"],
        &["incarnation"],
        &["incarceration"],
        &["incarcerated"],
        &["incarceration"],
        &["incarcerated"],
        &["incarceration"],
        &["incarnation"],
        &["incarnation"],
        &["incarnation"],
        &["incarcerated"],
        &["incarceration"],
        &["incantation"],
        &["incantations"],
        &["inactive"],
    ],
    range: 3..=9,
};

static WORD_INB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INB_CHILDREN),
    value: None,
};

pub static WORD_INB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("alance"),
        dictgen::InsensitiveStr::Ascii("alanced"),
        dictgen::InsensitiveStr::Ascii("ankment"),
        dictgen::InsensitiveStr::Ascii("ankments"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("edded"),
        dictgen::InsensitiveStr::Ascii("eetwen"),
        dictgen::InsensitiveStr::Ascii("elievable"),
        dictgen::InsensitiveStr::Ascii("etweeen"),
        dictgen::InsensitiveStr::Ascii("etwen"),
        dictgen::InsensitiveStr::Ascii("ewteen"),
        dictgen::InsensitiveStr::Ascii("ility"),
        dictgen::InsensitiveStr::Ascii("race"),
        dictgen::InsensitiveStr::Ascii("raced"),
        dictgen::InsensitiveStr::Ascii("racer"),
        dictgen::InsensitiveStr::Ascii("races"),
        dictgen::InsensitiveStr::Ascii("racing"),
        dictgen::InsensitiveStr::Ascii("rase"),
        dictgen::InsensitiveStr::Ascii("rased"),
        dictgen::InsensitiveStr::Ascii("raser"),
        dictgen::InsensitiveStr::Ascii("rases"),
        dictgen::InsensitiveStr::Ascii("rasing"),
        dictgen::InsensitiveStr::Ascii("rio"),
        dictgen::InsensitiveStr::Ascii("rios"),
    ],
    values: &[
        &["imbalance"],
        &["imbalanced"],
        &["embankment"],
        &["embankments"],
        &["imbed"],
        &["imbedded"],
        &["inbetween"],
        &["unbelievable"],
        &["inbetween"],
        &["inbetween"],
        &["inbetween"],
        &["inability"],
        &["embrace"],
        &["embraced"],
        &["embracer"],
        &["embraces"],
        &["embracing"],
        &["embrace"],
        &["embraced"],
        &["embracer"],
        &["embraces"],
        &["embracing"],
        &["embryo"],
        &["embryos"],
    ],
    range: 2..=9,
};

static WORD_INA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_INA_CHILDREN),
    value: None,
};

static WORD_INA_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    Some(&WORD_INAB_NODE),
    Some(&WORD_INAC_NODE),
    Some(&WORD_INAD_NODE),
    None,
    None,
    Some(&WORD_INAG_NODE),
    Some(&WORD_INAH_NODE),
    None,
    None,
    Some(&WORD_INAK_NODE),
    Some(&WORD_INAL_NODE),
    None,
    None,
    None,
    Some(&WORD_INAP_NODE),
    None,
    None,
    None,
    Some(&WORD_INAT_NODE),
    Some(&WORD_INAU_NODE),
    Some(&WORD_INAV_NODE),
    None,
    None,
    None,
    None,
];

static WORD_INAV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INAV_CHILDREN),
    value: None,
};

pub static WORD_INAV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("lid"),
        dictgen::InsensitiveStr::Ascii("lis"),
    ],
    values: &[&["invalid"], &["invalid"]],
    range: 3..=3,
};

static WORD_INAU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INAU_CHILDREN),
    value: None,
};

pub static WORD_INAU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("gures")],
    values: &[&["inaugurates"]],
    range: 5..=5,
};

static WORD_INAT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INAT_CHILDREN),
    value: None,
};

pub static WORD_INAT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("tractive"),
    ],
    values: &[&["innate"], &["unattractive"]],
    range: 1..=8,
};

static WORD_INAP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INAP_CHILDREN),
    value: None,
};

pub static WORD_INAP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("porpriate"),
        dictgen::InsensitiveStr::Ascii("porpriately"),
        dictgen::InsensitiveStr::Ascii("propiate"),
        dictgen::InsensitiveStr::Ascii("propirate"),
        dictgen::InsensitiveStr::Ascii("propraite"),
        dictgen::InsensitiveStr::Ascii("propraitely"),
        dictgen::InsensitiveStr::Ascii("proprate"),
        dictgen::InsensitiveStr::Ascii("propreate"),
        dictgen::InsensitiveStr::Ascii("propriae"),
        dictgen::InsensitiveStr::Ascii("propriatelly"),
        dictgen::InsensitiveStr::Ascii("propriatley"),
        dictgen::InsensitiveStr::Ascii("propriatly"),
        dictgen::InsensitiveStr::Ascii("propriet"),
        dictgen::InsensitiveStr::Ascii("proprietly"),
        dictgen::InsensitiveStr::Ascii("roppriate"),
        dictgen::InsensitiveStr::Ascii("roppriately"),
        dictgen::InsensitiveStr::Ascii("ropriate"),
        dictgen::InsensitiveStr::Ascii("ropriately"),
    ],
    values: &[
        &["inappropriate"],
        &["inappropriately"],
        &["inappropriate"],
        &["inappropriate"],
        &["inappropriate"],
        &["inappropriately"],
        &["inappropriate"],
        &["inappropriate"],
        &["inappropriately"],
        &["inappropriately"],
        &["inappropriately"],
        &["inappropriately"],
        &["inappropriately"],
        &["inappropriately"],
        &["inappropriate"],
        &["inappropriately"],
        &["inappropriate"],
        &["inappropriately"],
    ],
    range: 8..=12,
};

static WORD_INAL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INAL_CHILDREN),
    value: None,
};

pub static WORD_INAL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("id")],
    values: &[&["invalid"]],
    range: 2..=2,
};

static WORD_INAK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INAK_CHILDREN),
    value: None,
};

pub static WORD_INAK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("tively")],
    values: &[&["inactively"]],
    range: 6..=6,
};

static WORD_INAH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INAH_CHILDREN),
    value: None,
};

pub static WORD_INAH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("bitants")],
    values: &[&["inhabitants"]],
    range: 7..=7,
};

static WORD_INAG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INAG_CHILDREN),
    value: None,
};

pub static WORD_INAG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("urated"),
        dictgen::InsensitiveStr::Ascii("uration"),
    ],
    values: &[&["inaugurated"], &["inauguration"]],
    range: 6..=7,
};

static WORD_INAD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INAD_CHILDREN),
    value: None,
};

pub static WORD_INAD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aquate"),
        dictgen::InsensitiveStr::Ascii("aquete"),
        dictgen::InsensitiveStr::Ascii("ecuate"),
        dictgen::InsensitiveStr::Ascii("eguate"),
        dictgen::InsensitiveStr::Ascii("eqaute"),
        dictgen::InsensitiveStr::Ascii("equet"),
        dictgen::InsensitiveStr::Ascii("equete"),
        dictgen::InsensitiveStr::Ascii("equite"),
        dictgen::InsensitiveStr::Ascii("iquate"),
        dictgen::InsensitiveStr::Ascii("quate"),
        dictgen::InsensitiveStr::Ascii("ventently"),
        dictgen::InsensitiveStr::Ascii("verdently"),
        dictgen::InsensitiveStr::Ascii("vertant"),
        dictgen::InsensitiveStr::Ascii("vertantely"),
        dictgen::InsensitiveStr::Ascii("vertantly"),
        dictgen::InsensitiveStr::Ascii("vertedly"),
        dictgen::InsensitiveStr::Ascii("vertendly"),
        dictgen::InsensitiveStr::Ascii("vertenly"),
    ],
    values: &[
        &["inadequate"],
        &["inadequate"],
        &["inadequate"],
        &["inadequate"],
        &["inadequate"],
        &["inadequate"],
        &["inadequate"],
        &["inadequate"],
        &["inadequate"],
        &["inadequate"],
        &["inadvertently"],
        &["inadvertently"],
        &["inadvertent"],
        &["inadvertently"],
        &["inadvertently"],
        &["inadvertently"],
        &["inadvertently"],
        &["inadvertently"],
    ],
    range: 5..=10,
};

static WORD_INAC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INAC_CHILDREN),
    value: None,
};

pub static WORD_INAC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ccessible"),
        dictgen::InsensitiveStr::Ascii("cesible"),
        dictgen::InsensitiveStr::Ascii("cesibles"),
        dictgen::InsensitiveStr::Ascii("cessable"),
        dictgen::InsensitiveStr::Ascii("cessbile"),
        dictgen::InsensitiveStr::Ascii("cessble"),
        dictgen::InsensitiveStr::Ascii("cessibile"),
        dictgen::InsensitiveStr::Ascii("cruate"),
        dictgen::InsensitiveStr::Ascii("curaccies"),
        dictgen::InsensitiveStr::Ascii("curaccy"),
        dictgen::InsensitiveStr::Ascii("curaces"),
        dictgen::InsensitiveStr::Ascii("curasies"),
        dictgen::InsensitiveStr::Ascii("curaties"),
        dictgen::InsensitiveStr::Ascii("curicies"),
        dictgen::InsensitiveStr::Ascii("currate"),
        dictgen::InsensitiveStr::Ascii("essible"),
        dictgen::InsensitiveStr::Ascii("uraccies"),
        dictgen::InsensitiveStr::Ascii("urate"),
        dictgen::InsensitiveStr::Ascii("urracies"),
        dictgen::InsensitiveStr::Ascii("urrate"),
    ],
    values: &[
        &["inaccessible"],
        &["inaccessible"],
        &["inaccessible"],
        &["inaccessible"],
        &["inaccessible"],
        &["inaccessible"],
        &["inaccessible"],
        &["inaccurate"],
        &["inaccuracies"],
        &["inaccuracy"],
        &["inaccuracies"],
        &["inaccuracies"],
        &["inaccuracies"],
        &["inaccuracies"],
        &["inaccurate"],
        &["inaccessible"],
        &["inaccuracies"],
        &["inaccurate"],
        &["inaccuracies"],
        &["inaccurate"],
    ],
    range: 5..=9,
};

static WORD_INAB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_INAB_CHILDREN),
    value: None,
};

pub static WORD_INAB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("le"),
        dictgen::InsensitiveStr::Ascii("led"),
        dictgen::InsensitiveStr::Ascii("les"),
        dictgen::InsensitiveStr::Ascii("lility"),
        dictgen::InsensitiveStr::Ascii("ling"),
    ],
    values: &[
        &["enable", "unable"],
        &["enabled"],
        &["enables"],
        &["inability"],
        &["enabling"],
    ],
    range: 2..=6,
};

static WORD_IM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_IM_CHILDREN),
    value: None,
};

static WORD_IM_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_IMA_NODE),
    Some(&WORD_IMB_NODE),
    Some(&WORD_IMC_NODE),
    None,
    Some(&WORD_IME_NODE),
    Some(&WORD_IMF_NODE),
    Some(&WORD_IMG_NODE),
    None,
    Some(&WORD_IMI_NODE),
    None,
    None,
    Some(&WORD_IML_NODE),
    Some(&WORD_IMM_NODE),
    None,
    Some(&WORD_IMO_NODE),
    Some(&WORD_IMP_NODE),
    None,
    Some(&WORD_IMR_NODE),
    Some(&WORD_IMS_NODE),
    Some(&WORD_IMT_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_IMT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_IMT_CHILDREN),
    value: None,
};

pub static WORD_IMT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("imidating"),
        dictgen::InsensitiveStr::Ascii("imidation"),
    ],
    values: &[&["intimidating"], &["intimidation"]],
    range: 9..=9,
};

static WORD_IMS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_IMS_CHILDREN),
    value: None,
};

pub static WORD_IMS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ensitive")],
    values: &[&["insensitive"]],
    range: 8..=8,
};

static WORD_IMR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_IMR_CHILDREN),
    value: None,
};

pub static WORD_IMR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ovement"),
        dictgen::InsensitiveStr::Ascii("pove"),
        dictgen::InsensitiveStr::Ascii("poved"),
        dictgen::InsensitiveStr::Ascii("povement"),
        dictgen::InsensitiveStr::Ascii("povements"),
        dictgen::InsensitiveStr::Ascii("poves"),
        dictgen::InsensitiveStr::Ascii("poving"),
        dictgen::InsensitiveStr::Ascii("povised"),
    ],
    values: &[
        &["improvement"],
        &["improve"],
        &["improved"],
        &["improvement"],
        &["improvements"],
        &["improves"],
        &["improving"],
        &["improvised"],
    ],
    range: 4..=9,
};

static WORD_IMP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_IMP_CHILDREN),
    value: None,
};

static WORD_IMP_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_IMPA_NODE),
    None,
    Some(&WORD_IMPC_NODE),
    None,
    Some(&WORD_IMPE_NODE),
    None,
    None,
    None,
    Some(&WORD_IMPI_NODE),
    None,
    None,
    Some(&WORD_IMPL_NODE),
    None,
    None,
    Some(&WORD_IMPO_NODE),
    Some(&WORD_IMPP_NODE),
    None,
    Some(&WORD_IMPR_NODE),
    None,
    None,
    Some(&WORD_IMPU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_IMPU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_IMPU_CHILDREN),
    value: None,
};

pub static WORD_IMPU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("les"),
        dictgen::InsensitiveStr::Ascii("lisve"),
        dictgen::InsensitiveStr::Ascii("lsemos"),
        dictgen::InsensitiveStr::Ascii("lsivley"),
        dictgen::InsensitiveStr::Ascii("ne"),
        dictgen::InsensitiveStr::Ascii("ned"),
        dictgen::InsensitiveStr::Ascii("ner"),
        dictgen::InsensitiveStr::Ascii("nes"),
        dictgen::InsensitiveStr::Ascii("ning"),
        dictgen::InsensitiveStr::Ascii("ns"),
        dictgen::InsensitiveStr::Ascii("sle"),
        dictgen::InsensitiveStr::Ascii("sles"),
        dictgen::InsensitiveStr::Ascii("slive"),
        dictgen::InsensitiveStr::Ascii("t"),
    ],
    values: &[
        &["impulse"],
        &["impulsive"],
        &["impulses"],
        &["impulsive"],
        &["impugn"],
        &["impugned"],
        &["impugner"],
        &["impugns"],
        &["impugning"],
        &["impugns"],
        &["impulse"],
        &["impulses"],
        &["impulsive"],
        &["input"],
    ],
    range: 1..=7,
};

static WORD_IMPR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_IMPR_CHILDREN),
    value: None,
};

static WORD_IMPR_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_IMPRA_NODE),
    None,
    None,
    None,
    Some(&WORD_IMPRE_NODE),
    None,
    None,
    None,
    Some(&WORD_IMPRI_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_IMPRO_NODE),
    None,
    None,
    None,
    Some(&WORD_IMPRS_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_IMPRS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_IMPRS_CHILDREN),
    value: None,
};

pub static WORD_IMPRS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ioned")],
    values: &[&["imprisoned"]],
    range: 5..=5,
};

static WORD_IMPRO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_IMPRO_CHILDREN),
    value: None,
};

pub static WORD_IMPRO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("babe"),
        dictgen::InsensitiveStr::Ascii("babil"),
        dictgen::InsensitiveStr::Ascii("babile"),
        dictgen::InsensitiveStr::Ascii("be"),
        dictgen::InsensitiveStr::Ascii("bement"),
        dictgen::InsensitiveStr::Ascii("bements"),
        dictgen::InsensitiveStr::Ascii("bes"),
        dictgen::InsensitiveStr::Ascii("bible"),
        dictgen::InsensitiveStr::Ascii("bing"),
        dictgen::InsensitiveStr::Ascii("bment"),
        dictgen::InsensitiveStr::Ascii("bments"),
        dictgen::InsensitiveStr::Ascii("of"),
        dictgen::InsensitiveStr::Ascii("ofement"),
        dictgen::InsensitiveStr::Ascii("ofing"),
        dictgen::InsensitiveStr::Ascii("ofment"),
        dictgen::InsensitiveStr::Ascii("ofs"),
        dictgen::InsensitiveStr::Ascii("ove"),
        dictgen::InsensitiveStr::Ascii("oved"),
        dictgen::InsensitiveStr::Ascii("ovement"),
        dictgen::InsensitiveStr::Ascii("ovements"),
        dictgen::InsensitiveStr::Ascii("oves"),
        dictgen::InsensitiveStr::Ascii("oving"),
        dictgen::InsensitiveStr::Ascii("ovment"),
        dictgen::InsensitiveStr::Ascii("ovments"),
        dictgen::InsensitiveStr::Ascii("pable"),
        dictgen::InsensitiveStr::Ascii("pely"),
        dictgen::InsensitiveStr::Ascii("pre"),
        dictgen::InsensitiveStr::Ascii("sined"),
        dictgen::InsensitiveStr::Ascii("soned"),
        dictgen::InsensitiveStr::Ascii("sonment"),
        dictgen::InsensitiveStr::Ascii("ssible"),
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("tance"),
        dictgen::InsensitiveStr::Ascii("tant"),
        dictgen::InsensitiveStr::Ascii("tantly"),
        dictgen::InsensitiveStr::Ascii("tation"),
        dictgen::InsensitiveStr::Ascii("tations"),
        dictgen::InsensitiveStr::Ascii("ted"),
        dictgen::InsensitiveStr::Ascii("ter"),
        dictgen::InsensitiveStr::Ascii("ters"),
        dictgen::InsensitiveStr::Ascii("ting"),
        dictgen::InsensitiveStr::Ascii("ts"),
        dictgen::InsensitiveStr::Ascii("vemen"),
        dictgen::InsensitiveStr::Ascii("vemenet"),
        dictgen::InsensitiveStr::Ascii("vemenets"),
        dictgen::InsensitiveStr::Ascii("vemens"),
        dictgen::InsensitiveStr::Ascii("vemnt"),
        dictgen::InsensitiveStr::Ascii("vemnts"),
        dictgen::InsensitiveStr::Ascii("vents"),
        dictgen::InsensitiveStr::Ascii("vie"),
        dictgen::InsensitiveStr::Ascii("viserad"),
        dictgen::InsensitiveStr::Ascii("vished"),
        dictgen::InsensitiveStr::Ascii("vision"),
        dictgen::InsensitiveStr::Ascii("vized"),
        dictgen::InsensitiveStr::Ascii("vmenet"),
        dictgen::InsensitiveStr::Ascii("vmenets"),
        dictgen::InsensitiveStr::Ascii("vment"),
        dictgen::InsensitiveStr::Ascii("vments"),
    ],
    values: &[
        &["improbable"],
        &["improbable"],
        &["improbable"],
        &["improve"],
        &["improvement"],
        &["improvements"],
        &["improves"],
        &["improbable"],
        &["improving"],
        &["improvement"],
        &["improvements"],
        &["improve"],
        &["improvement"],
        &["improving"],
        &["improvement"],
        &["improves"],
        &["improve"],
        &["improved"],
        &["improvement"],
        &["improvements"],
        &["improves"],
        &["improving"],
        &["improvement"],
        &["improvements"],
        &["improbable"],
        &["improperly"],
        &["improper"],
        &["imprisoned"],
        &["imprisoned"],
        &["imprisonment"],
        &["impossible"],
        &["import"],
        &["importance"],
        &["important"],
        &["importantly"],
        &["importation"],
        &["importations"],
        &["imported"],
        &["importer"],
        &["importers"],
        &["importing"],
        &["imports"],
        &["improvement"],
        &["improvement"],
        &["improvements"],
        &["improvements"],
        &["improvement"],
        &["improvements"],
        &["improves"],
        &["improvised"],
        &["improvised"],
        &["improvised"],
        &["improvisation"],
        &["improvised"],
        &["improvement"],
        &["improvements"],
        &["improvement"],
        &["improvements"],
    ],
    range: 1..=8,
};

static WORD_IMPRI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_IMPRI_CHILDREN),
    value: None,
};

pub static WORD_IMPRI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("oned"),
        dictgen::InsensitiveStr::Ascii("sonent"),
        dictgen::InsensitiveStr::Ascii("sonned"),
    ],
    values: &[&["imprisoned"], &["imprisonment"], &["imprisoned"]],
    range: 4..=6,
};

static WORD_IMPRE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_IMPRE_CHILDREN),
    value: None,
};

pub static WORD_IMPRE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ative"),
        dictgen::InsensitiveStr::Ascii("fect"),
        dictgen::InsensitiveStr::Ascii("fection"),
        dictgen::InsensitiveStr::Ascii("fections"),
        dictgen::InsensitiveStr::Ascii("mented"),
        dictgen::InsensitiveStr::Ascii("s"),
        dictgen::InsensitiveStr::Ascii("sison"),
        dictgen::InsensitiveStr::Ascii("sive"),
        dictgen::InsensitiveStr::Ascii("sonating"),
        dictgen::InsensitiveStr::Ascii("ssario"),
        dictgen::InsensitiveStr::Ascii("ssin"),
        dictgen::InsensitiveStr::Ascii("ssoin"),
        dictgen::InsensitiveStr::Ascii("ssons"),
        dictgen::InsensitiveStr::Ascii("sssion"),
        dictgen::InsensitiveStr::Ascii("ve"),
    ],
    values: &[
        &["imperative"],
        &["imperfect"],
        &["imperfections"],
        &["imperfections"],
        &["implemented"],
        &["impress"],
        &["impressions"],
        &["impressive"],
        &["impersonating"],
        &["impresario"],
        &["impressions"],
        &["impressions"],
        &["impressions"],
        &["impressions"],
        &["improve"],
    ],
    range: 1..=8,
};

static WORD_IMPRA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_IMPRA_CHILDREN),
    value: None,
};

pub static WORD_IMPRA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ctial"),
        dictgen::InsensitiveStr::Ascii("cticle"),
    ],
    values: &[&["impractical"], &["impractical"]],
    range: 5..=6,
};

static WORD_IMPP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_IMPP_CHILDREN),
    value: None,
};

pub static WORD_IMPP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("lement"),
        dictgen::InsensitiveStr::Ascii("lementating"),
        dictgen::InsensitiveStr::Ascii("lementation"),
        dictgen::InsensitiveStr::Ascii("lemented"),
    ],
    values: &[
        &["implement"],
        &["implementing"],
        &["implementation"],
        &["implemented"],
    ],
    range: 6..=11,
};

static WORD_IMPO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_IMPO_CHILDREN),
    value: None,
};

static WORD_IMPO_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_IMPOL_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_IMPOR_NODE),
    Some(&WORD_IMPOS_NODE),
    Some(&WORD_IMPOT_NODE),
    None,
    Some(&WORD_IMPOV_NODE),
    None,
    None,
    None,
    None,
];

static WORD_IMPOV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_IMPOV_CHILDREN),
    value: None,
};

pub static WORD_IMPOV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("ement"),
        dictgen::InsensitiveStr::Ascii("ements"),
        dictgen::InsensitiveStr::Ascii("erised"),
        dictgen::InsensitiveStr::Ascii("ershied"),
        dictgen::InsensitiveStr::Ascii("ersihed"),
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("ing"),
    ],
    values: &[
        &["improve"],
        &["improved"],
        &["improvement"],
        &["improvements"],
        &["impoverished"],
        &["impoverished"],
        &["impoverished"],
        &["improves"],
        &["improving"],
    ],
    range: 1..=7,
};

static WORD_IMPOT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_IMPOT_CHILDREN),
    value: Some(&["import"]),
};

pub static WORD_IMPOT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ant"),
        dictgen::InsensitiveStr::Ascii("r"),
        dictgen::InsensitiveStr::Ascii("rt"),
    ],
    values: &[
        &["important", "impotent"],
        &["import", "importer"],
        &["import", "imported", "importer"],
    ],
    range: 1..=3,
};

static WORD_IMPOS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_IMPOS_CHILDREN),
    value: None,
};

pub static WORD_IMPOS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ible"),
        dictgen::InsensitiveStr::Ascii("sable"),
        dictgen::InsensitiveStr::Ascii("sbily"),
        dictgen::InsensitiveStr::Ascii("sibal"),
        dictgen::InsensitiveStr::Ascii("sibe"),
        dictgen::InsensitiveStr::Ascii("sibel"),
        dictgen::InsensitiveStr::Ascii("sibile"),
        dictgen::InsensitiveStr::Ascii("sibillity"),
        dictgen::InsensitiveStr::Ascii("sibilty"),
        dictgen::InsensitiveStr::Ascii("sibily"),
        dictgen::InsensitiveStr::Ascii("siblble"),
        dictgen::InsensitiveStr::Ascii("siblely"),
        dictgen::InsensitiveStr::Ascii("sibley"),
        dictgen::InsensitiveStr::Ascii("siblity"),
        dictgen::InsensitiveStr::Ascii("siblly"),
        dictgen::InsensitiveStr::Ascii("sibry"),
        dictgen::InsensitiveStr::Ascii("sibul"),
    ],
    values: &[
        &["impossible"],
        &["impossible"],
        &["impossibly"],
        &["impossibly"],
        &["impossible"],
        &["impossibly"],
        &["impossible"],
        &["impossibility"],
        &["impossibility"],
        &["impossibly"],
        &["impossible"],
        &["impossibly"],
        &["impossibly"],
        &["impossibly"],
        &["impossibly"],
        &["impossibly"],
        &["impossibly"],
    ],
    range: 4..=9,
};

static WORD_IMPOR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_IMPOR_CHILDREN),
    value: None,
};

pub static WORD_IMPOR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ant"),
        dictgen::InsensitiveStr::Ascii("bable"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("ot"),
        dictgen::InsensitiveStr::Ascii("oted"),
        dictgen::InsensitiveStr::Ascii("oting"),
        dictgen::InsensitiveStr::Ascii("ots"),
        dictgen::InsensitiveStr::Ascii("ove"),
        dictgen::InsensitiveStr::Ascii("oved"),
        dictgen::InsensitiveStr::Ascii("ovement"),
        dictgen::InsensitiveStr::Ascii("ovements"),
        dictgen::InsensitiveStr::Ascii("oves"),
        dictgen::InsensitiveStr::Ascii("oving"),
        dictgen::InsensitiveStr::Ascii("per"),
        dictgen::InsensitiveStr::Ascii("sts"),
        dictgen::InsensitiveStr::Ascii("tamt"),
        dictgen::InsensitiveStr::Ascii("tanly"),
        dictgen::InsensitiveStr::Ascii("tantce"),
        dictgen::InsensitiveStr::Ascii("tantely"),
        dictgen::InsensitiveStr::Ascii("tanty"),
        dictgen::InsensitiveStr::Ascii("tas"),
        dictgen::InsensitiveStr::Ascii("tat"),
        dictgen::InsensitiveStr::Ascii("td"),
        dictgen::InsensitiveStr::Ascii("ten"),
        dictgen::InsensitiveStr::Ascii("tence"),
        dictgen::InsensitiveStr::Ascii("tend"),
        dictgen::InsensitiveStr::Ascii("tent"),
        dictgen::InsensitiveStr::Ascii("tently"),
        dictgen::InsensitiveStr::Ascii("terad"),
        dictgen::InsensitiveStr::Ascii("tes"),
        dictgen::InsensitiveStr::Ascii("tnt"),
        dictgen::InsensitiveStr::Ascii("v"),
        dictgen::InsensitiveStr::Ascii("ve"),
        dictgen::InsensitiveStr::Ascii("ved"),
        dictgen::InsensitiveStr::Ascii("vement"),
        dictgen::InsensitiveStr::Ascii("vements"),
        dictgen::InsensitiveStr::Ascii("ves"),
        dictgen::InsensitiveStr::Ascii("ving"),
        dictgen::InsensitiveStr::Ascii("vised"),
        dictgen::InsensitiveStr::Ascii("vment"),
    ],
    values: &[
        &["important"],
        &["improbable"],
        &["importing"],
        &["import"],
        &["imported"],
        &["importing"],
        &["imports"],
        &["improve"],
        &["improved"],
        &["improvement"],
        &["improvements"],
        &["improves"],
        &["improving"],
        &["improper"],
        &["imports"],
        &["important"],
        &["importantly"],
        &["importance"],
        &["importantly"],
        &["importantly"],
        &["imports"],
        &["important"],
        &["imported"],
        &["importance", "important"],
        &["importance"],
        &["imported"],
        &["important"],
        &["importantly"],
        &["imported"],
        &["imports"],
        &["important"],
        &["improve", "improv"],
        &["improve"],
        &["improved"],
        &["improvement"],
        &["improvements"],
        &["improves"],
        &["improving"],
        &["improvised"],
        &["improvement"],
    ],
    range: 1..=8,
};

static WORD_IMPOL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_IMPOL_CHILDREN),
    value: None,
};

pub static WORD_IMPOL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("de")],
    values: &[&["implode"]],
    range: 2..=2,
};

static WORD_IMPL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_IMPL_CHILDREN),
    value: None,
};

static WORD_IMPL_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_IMPLA_NODE),
    None,
    Some(&WORD_IMPLC_NODE),
    None,
    Some(&WORD_IMPLE_NODE),
    None,
    None,
    None,
    Some(&WORD_IMPLI_NODE),
    None,
    None,
    None,
    Some(&WORD_IMPLM_NODE),
    None,
    Some(&WORD_IMPLO_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_IMPLU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_IMPLU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_IMPLU_CHILDREN),
    value: None,
};

pub static WORD_IMPLU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("se"),
        dictgen::InsensitiveStr::Ascii("ses"),
        dictgen::InsensitiveStr::Ascii("sive"),
    ],
    values: &[&["impulse"], &["impulses"], &["impulsive"]],
    range: 2..=4,
};

static WORD_IMPLO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_IMPLO_CHILDREN),
    value: None,
};

pub static WORD_IMPLO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("sed"),
        dictgen::InsensitiveStr::Ascii("ys"),
    ],
    values: &[&["implode"], &["implode"], &["employs"]],
    range: 2..=3,
};

static WORD_IMPLM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_IMPLM_CHILDREN),
    value: None,
};

pub static WORD_IMPLM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("enet"),
        dictgen::InsensitiveStr::Ascii("enetaion"),
        dictgen::InsensitiveStr::Ascii("enetaions"),
        dictgen::InsensitiveStr::Ascii("enetation"),
        dictgen::InsensitiveStr::Ascii("enetations"),
        dictgen::InsensitiveStr::Ascii("enetd"),
        dictgen::InsensitiveStr::Ascii("eneted"),
        dictgen::InsensitiveStr::Ascii("eneter"),
        dictgen::InsensitiveStr::Ascii("eneting"),
        dictgen::InsensitiveStr::Ascii("enets"),
        dictgen::InsensitiveStr::Ascii("ent"),
        dictgen::InsensitiveStr::Ascii("entation"),
        dictgen::InsensitiveStr::Ascii("entations"),
        dictgen::InsensitiveStr::Ascii("ented"),
        dictgen::InsensitiveStr::Ascii("enting"),
        dictgen::InsensitiveStr::Ascii("ents"),
    ],
    values: &[
        &["implement"],
        &["implementation"],
        &["implementations"],
        &["implementation"],
        &["implementations"],
        &["implemented"],
        &["implemented"],
        &["implementer"],
        &["implementing"],
        &["implements"],
        &["implement"],
        &["implementation"],
        &["implementations"],
        &["implemented"],
        &["implementing"],
        &["implements"],
    ],
    range: 3..=10,
};

static WORD_IMPLI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_IMPLI_CHILDREN),
    value: None,
};

pub static WORD_IMPLI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cacion"),
        dictgen::InsensitiveStr::Ascii("cati"),
        dictgen::InsensitiveStr::Ascii("catia"),
        dictgen::InsensitiveStr::Ascii("catie"),
        dictgen::InsensitiveStr::Ascii("catii"),
        dictgen::InsensitiveStr::Ascii("catons"),
        dictgen::InsensitiveStr::Ascii("cetly"),
        dictgen::InsensitiveStr::Ascii("ciet"),
        dictgen::InsensitiveStr::Ascii("ciete"),
        dictgen::InsensitiveStr::Ascii("cilty"),
        dictgen::InsensitiveStr::Ascii("cite"),
        dictgen::InsensitiveStr::Ascii("citely"),
        dictgen::InsensitiveStr::Ascii("citily"),
        dictgen::InsensitiveStr::Ascii("citley"),
        dictgen::InsensitiveStr::Ascii("city"),
        dictgen::InsensitiveStr::Ascii("ct"),
        dictgen::InsensitiveStr::Ascii("ctly"),
        dictgen::InsensitiveStr::Ascii("kation"),
        dictgen::InsensitiveStr::Ascii("mcit"),
        dictgen::InsensitiveStr::Ascii("mcitly"),
        dictgen::InsensitiveStr::Ascii("menation"),
        dictgen::InsensitiveStr::Ascii("ment"),
        dictgen::InsensitiveStr::Ascii("mentaion"),
        dictgen::InsensitiveStr::Ascii("mentaions"),
        dictgen::InsensitiveStr::Ascii("mentation"),
        dictgen::InsensitiveStr::Ascii("mentations"),
        dictgen::InsensitiveStr::Ascii("mented"),
        dictgen::InsensitiveStr::Ascii("menting"),
        dictgen::InsensitiveStr::Ascii("mention"),
        dictgen::InsensitiveStr::Ascii("mentions"),
        dictgen::InsensitiveStr::Ascii("mentor"),
        dictgen::InsensitiveStr::Ascii("ments"),
    ],
    values: &[
        &["implication"],
        &["implicit"],
        &["implicit"],
        &["implicit"],
        &["implicit"],
        &["implications"],
        &["implicitly"],
        &["implicit"],
        &["implicit"],
        &["implicitly"],
        &["implicit", "implicitly"],
        &["implicitly"],
        &["implicitly"],
        &["implicitly"],
        &["implicitly"],
        &["implicit"],
        &["implicitly"],
        &["implication"],
        &["implicit"],
        &["implicitly"],
        &["implementation"],
        &["implement"],
        &["implementation"],
        &["implementations"],
        &["implementation"],
        &["implementations"],
        &["implemented"],
        &["implementing"],
        &["implementation"],
        &["implementations"],
        &["implementor"],
        &["implements"],
    ],
    range: 2..=10,
};

static WORD_IMPLE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_IMPLE_CHILDREN),
    value: None,
};

static WORD_IMPLE_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    Some(&WORD_IMPLEC_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_IMPLEI_NODE),
    None,
    None,
    None,
    Some(&WORD_IMPLEM_NODE),
    Some(&WORD_IMPLEN_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_IMPLET_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_IMPLET_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_IMPLET_CHILDREN),
    value: Some(&["implement"]),
};

pub static WORD_IMPLET_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ation"),
        dictgen::InsensitiveStr::Ascii("ations"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("er"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("ment"),
        dictgen::InsensitiveStr::Ascii("s"),
    ],
    values: &[
        &["implementation"],
        &["implementations"],
        &["implemented"],
        &["implementer"],
        &["implementing"],
        &["implement"],
        &["implements"],
    ],
    range: 1..=6,
};

static WORD_IMPLEN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_IMPLEN_CHILDREN),
    value: None,
};

pub static WORD_IMPLEN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eted"),
        dictgen::InsensitiveStr::Ascii("ment"),
        dictgen::InsensitiveStr::Ascii("mentation"),
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("tation"),
        dictgen::InsensitiveStr::Ascii("tations"),
        dictgen::InsensitiveStr::Ascii("ted"),
        dictgen::InsensitiveStr::Ascii("ting"),
        dictgen::InsensitiveStr::Ascii("tors"),
        dictgen::InsensitiveStr::Ascii("ts"),
    ],
    values: &[
        &["implemented"],
        &["implement"],
        &["implementation"],
        &["implement"],
        &["implementation"],
        &["implementations"],
        &["implemented"],
        &["implementing"],
        &["implementers"],
        &["implements"],
    ],
    range: 1..=9,
};

static WORD_IMPLEM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_IMPLEM_CHILDREN),
    value: None,
};

static WORD_IMPLEM_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_IMPLEMA_NODE),
    None,
    None,
    None,
    Some(&WORD_IMPLEME_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_IMPLEMN_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_IMPLEMT_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_IMPLEMT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_IMPLEMT_CHILDREN),
    value: Some(&["implement"]),
};

pub static WORD_IMPLEMT_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("ation"),
            dictgen::InsensitiveStr::Ascii("ations"),
            dictgen::InsensitiveStr::Ascii("ed"),
            dictgen::InsensitiveStr::Ascii("entation"),
            dictgen::InsensitiveStr::Ascii("entations"),
            dictgen::InsensitiveStr::Ascii("ing"),
            dictgen::InsensitiveStr::Ascii("s"),
        ],
        values: &[
            &["implementation"],
            &["implementations"],
            &["implemented"],
            &["implementation"],
            &["implementations"],
            &["implementing"],
            &["implements"],
        ],
        range: 1..=9,
    };

static WORD_IMPLEMN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_IMPLEMN_CHILDREN),
    value: None,
};

pub static WORD_IMPLEMN_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("t"),
            dictgen::InsensitiveStr::Ascii("tation"),
            dictgen::InsensitiveStr::Ascii("tations"),
        ],
        values: &[&["implement"], &["implementation"], &["implementations"]],
        range: 1..=7,
    };

static WORD_IMPLEME_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_IMPLEME_CHILDREN),
    value: None,
};

static WORD_IMPLEME_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_IMPLEMEM_NODE),
    Some(&WORD_IMPLEMEN_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_IMPLEMET_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_IMPLEMET_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_IMPLEMET_CHILDREN),
    value: Some(&["implements", "implement"]),
};

pub static WORD_IMPLEMET_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("ation"),
            dictgen::InsensitiveStr::Ascii("ations"),
            dictgen::InsensitiveStr::Ascii("ed"),
            dictgen::InsensitiveStr::Ascii("end"),
            dictgen::InsensitiveStr::Ascii("ing"),
            dictgen::InsensitiveStr::Ascii("nation"),
            dictgen::InsensitiveStr::Ascii("s"),
        ],
        values: &[
            &["implementation"],
            &["implementations"],
            &["implemented"],
            &["implemented"],
            &["implementing"],
            &["implementations", "implementation"],
            &["implements"],
        ],
        range: 1..=6,
    };

static WORD_IMPLEMEN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_IMPLEMEN_CHILDREN),
    value: Some(&["implement"]),
};

static WORD_IMPLEMEN_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_IMPLEMENA_NODE),
    None,
    Some(&WORD_IMPLEMENC_NODE),
    Some(&WORD_IMPLEMEND_NODE),
    Some(&WORD_IMPLEMENE_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_IMPLEMENR_NODE),
    None,
    Some(&WORD_IMPLEMENT_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_IMPLEMENT_NODE: dictgen::DictTrieNode<&'static [&'static str]> =
    dictgen::DictTrieNode {
        children: dictgen::DictTrieChild::Flat(&WORD_IMPLEMENT_CHILDREN),
        value: None,
    };

pub static WORD_IMPLEMENT_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("acion"),
            dictgen::InsensitiveStr::Ascii("aciones"),
            dictgen::InsensitiveStr::Ascii("aed"),
            dictgen::InsensitiveStr::Ascii("aion"),
            dictgen::InsensitiveStr::Ascii("aions"),
            dictgen::InsensitiveStr::Ascii("aiton"),
            dictgen::InsensitiveStr::Ascii("aitons"),
            dictgen::InsensitiveStr::Ascii("antions"),
            dictgen::InsensitiveStr::Ascii("as"),
            dictgen::InsensitiveStr::Ascii("ase"),
            dictgen::InsensitiveStr::Ascii("asi"),
            dictgen::InsensitiveStr::Ascii("astion"),
            dictgen::InsensitiveStr::Ascii("ataion"),
            dictgen::InsensitiveStr::Ascii("atation"),
            dictgen::InsensitiveStr::Ascii("ated"),
            dictgen::InsensitiveStr::Ascii("ates"),
            dictgen::InsensitiveStr::Ascii("atin"),
            dictgen::InsensitiveStr::Ascii("ating"),
            dictgen::InsensitiveStr::Ascii("atino"),
            dictgen::InsensitiveStr::Ascii("atins"),
            dictgen::InsensitiveStr::Ascii("atio"),
            dictgen::InsensitiveStr::Ascii("ationen"),
            dictgen::InsensitiveStr::Ascii("ationer"),
            dictgen::InsensitiveStr::Ascii("atios"),
            dictgen::InsensitiveStr::Ascii("atition"),
            dictgen::InsensitiveStr::Ascii("ato"),
            dictgen::InsensitiveStr::Ascii("atoin"),
            dictgen::InsensitiveStr::Ascii("atoins"),
            dictgen::InsensitiveStr::Ascii("atoion"),
            dictgen::InsensitiveStr::Ascii("aton"),
            dictgen::InsensitiveStr::Ascii("ator"),
            dictgen::InsensitiveStr::Ascii("ators"),
            dictgen::InsensitiveStr::Ascii("attion"),
            dictgen::InsensitiveStr::Ascii("d"),
            dictgen::InsensitiveStr::Ascii("e"),
            dictgen::InsensitiveStr::Ascii("es"),
            dictgen::InsensitiveStr::Ascii("et"),
            dictgen::InsensitiveStr::Ascii("iaon"),
            dictgen::InsensitiveStr::Ascii("ig"),
            dictgen::InsensitiveStr::Ascii("ion"),
            dictgen::InsensitiveStr::Ascii("ions"),
            dictgen::InsensitiveStr::Ascii("os"),
            dictgen::InsensitiveStr::Ascii("taion"),
        ],
        values: &[
            &["implementation"],
            &["implementations"],
            &["implemented"],
            &["implementation"],
            &["implementations"],
            &["implementation"],
            &["implementations"],
            &["implementations"],
            &["implements"],
            &["implements"],
            &["implements"],
            &["implementation"],
            &["implementation"],
            &["implementation"],
            &["implemented"],
            &["implements"],
            &["implementations", "implementation", "implementing"],
            &["implementation", "implementing"],
            &["implementations"],
            &["implementations"],
            &["implementation"],
            &["implementations"],
            &["implementations"],
            &["implementations"],
            &["implementation"],
            &["implementation"],
            &["implementation"],
            &["implementations"],
            &["implementation"],
            &["implementation"],
            &["implementer"],
            &["implementers"],
            &["implementation"],
            &["implemented"],
            &["implement", "implemented"],
            &["implements"],
            &["implemented"],
            &["implementation"],
            &["implementing"],
            &["implementation"],
            &["implementations"],
            &["implements"],
            &["implementation"],
        ],
        range: 1..=7,
    };

static WORD_IMPLEMENR_NODE: dictgen::DictTrieNode<&'static [&'static str]> =
    dictgen::DictTrieNode {
        children: dictgen::DictTrieChild::Flat(&WORD_IMPLEMENR_CHILDREN),
        value: None,
    };

pub static WORD_IMPLEMENR_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[dictgen::InsensitiveStr::Ascii("t")],
        values: &[&["implement"]],
        range: 1..=1,
    };

static WORD_IMPLEMENE_NODE: dictgen::DictTrieNode<&'static [&'static str]> =
    dictgen::DictTrieNode {
        children: dictgen::DictTrieChild::Flat(&WORD_IMPLEMENE_CHILDREN),
        value: None,
    };

pub static WORD_IMPLEMENE_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("d"),
            dictgen::InsensitiveStr::Ascii("t"),
            dictgen::InsensitiveStr::Ascii("taion"),
            dictgen::InsensitiveStr::Ascii("taions"),
            dictgen::InsensitiveStr::Ascii("tation"),
            dictgen::InsensitiveStr::Ascii("tations"),
            dictgen::InsensitiveStr::Ascii("td"),
            dictgen::InsensitiveStr::Ascii("ted"),
            dictgen::InsensitiveStr::Ascii("ter"),
            dictgen::InsensitiveStr::Ascii("ting"),
            dictgen::InsensitiveStr::Ascii("tions"),
            dictgen::InsensitiveStr::Ascii("ts"),
        ],
        values: &[
            &["implemented"],
            &["implements", "implement"],
            &["implementation"],
            &["implementations"],
            &["implementation"],
            &["implementations"],
            &["implemented"],
            &["implemented"],
            &["implementer"],
            &["implementing"],
            &["implementations"],
            &["implements"],
        ],
        range: 1..=7,
    };

static WORD_IMPLEMEND_NODE: dictgen::DictTrieNode<&'static [&'static str]> =
    dictgen::DictTrieNode {
        children: dictgen::DictTrieChild::Flat(&WORD_IMPLEMEND_CHILDREN),
        value: Some(&["implement"]),
    };

pub static WORD_IMPLEMEND_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[dictgen::InsensitiveStr::Ascii("s")],
        values: &[&["implements"]],
        range: 1..=1,
    };

static WORD_IMPLEMENC_NODE: dictgen::DictTrieNode<&'static [&'static str]> =
    dictgen::DictTrieNode {
        children: dictgen::DictTrieChild::Flat(&WORD_IMPLEMENC_CHILDREN),
        value: None,
    };

pub static WORD_IMPLEMENC_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[dictgen::InsensitiveStr::Ascii("ted")],
        values: &[&["implemented"]],
        range: 3..=3,
    };

static WORD_IMPLEMENA_NODE: dictgen::DictTrieNode<&'static [&'static str]> =
    dictgen::DictTrieNode {
        children: dictgen::DictTrieChild::Flat(&WORD_IMPLEMENA_CHILDREN),
        value: None,
    };

pub static WORD_IMPLEMENA_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("tation"),
            dictgen::InsensitiveStr::Ascii("tion"),
            dictgen::InsensitiveStr::Ascii("tiona"),
            dictgen::InsensitiveStr::Ascii("tiond"),
            dictgen::InsensitiveStr::Ascii("tions"),
        ],
        values: &[
            &["implementation"],
            &["implementation"],
            &["implementation"],
            &["implementation"],
            &["implementations"],
        ],
        range: 4..=6,
    };

static WORD_IMPLEMEM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_IMPLEMEM_CHILDREN),
    value: None,
};

pub static WORD_IMPLEMEM_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("emnt"),
            dictgen::InsensitiveStr::Ascii("emntation"),
            dictgen::InsensitiveStr::Ascii("ent"),
            dictgen::InsensitiveStr::Ascii("entation"),
            dictgen::InsensitiveStr::Ascii("entations"),
            dictgen::InsensitiveStr::Ascii("ented"),
            dictgen::InsensitiveStr::Ascii("enting"),
            dictgen::InsensitiveStr::Ascii("ents"),
            dictgen::InsensitiveStr::Ascii("etation"),
            dictgen::InsensitiveStr::Ascii("ntation"),
            dictgen::InsensitiveStr::Ascii("t"),
            dictgen::InsensitiveStr::Ascii("tation"),
            dictgen::InsensitiveStr::Ascii("tations"),
            dictgen::InsensitiveStr::Ascii("ted"),
            dictgen::InsensitiveStr::Ascii("ting"),
            dictgen::InsensitiveStr::Ascii("ts"),
        ],
        values: &[
            &["implement"],
            &["implementation"],
            &["implement"],
            &["implementation"],
            &["implementations"],
            &["implemented"],
            &["implementing"],
            &["implements"],
            &["implementation"],
            &["implementation"],
            &["implement"],
            &["implementation"],
            &["implementations"],
            &["implemented"],
            &["implementing"],
            &["implements"],
        ],
        range: 1..=9,
    };

static WORD_IMPLEMA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_IMPLEMA_CHILDREN),
    value: None,
};

pub static WORD_IMPLEMA_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("ntation"),
            dictgen::InsensitiveStr::Ascii("taion"),
            dictgen::InsensitiveStr::Ascii("taions"),
        ],
        values: &[
            &["implementation"],
            &["implementation"],
            &["implementations"],
        ],
        range: 5..=7,
    };

static WORD_IMPLEI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_IMPLEI_CHILDREN),
    value: None,
};

pub static WORD_IMPLEI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ment")],
    values: &[&["implement"]],
    range: 4..=4,
};

static WORD_IMPLEC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_IMPLEC_CHILDREN),
    value: None,
};

pub static WORD_IMPLEC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ations")],
    values: &[&["implications"]],
    range: 6..=6,
};

static WORD_IMPLC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_IMPLC_CHILDREN),
    value: None,
};

pub static WORD_IMPLC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("it"),
        dictgen::InsensitiveStr::Ascii("itly"),
        dictgen::InsensitiveStr::Ascii("t"),
    ],
    values: &[&["implicit"], &["implicitly"], &["implicit"]],
    range: 1..=4,
};

static WORD_IMPLA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_IMPLA_CHILDREN),
    value: None,
};

pub static WORD_IMPLA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ce"),
        dictgen::InsensitiveStr::Ascii("ment"),
        dictgen::InsensitiveStr::Ascii("mentation"),
        dictgen::InsensitiveStr::Ascii("mented"),
        dictgen::InsensitiveStr::Ascii("menting"),
        dictgen::InsensitiveStr::Ascii("ments"),
        dictgen::InsensitiveStr::Ascii("ntase"),
        dictgen::InsensitiveStr::Ascii("ntes"),
        dictgen::InsensitiveStr::Ascii("usable"),
        dictgen::InsensitiveStr::Ascii("usbile"),
        dictgen::InsensitiveStr::Ascii("usble"),
        dictgen::InsensitiveStr::Ascii("usibe"),
        dictgen::InsensitiveStr::Ascii("usibile"),
    ],
    values: &[
        &["inplace"],
        &["implement"],
        &["implementation"],
        &["implemented"],
        &["implementing"],
        &["implements"],
        &["implants"],
        &["implants"],
        &["implausible"],
        &["implausible"],
        &["implausible"],
        &["implausible"],
        &["implausible"],
    ],
    range: 2..=9,
};

static WORD_IMPI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_IMPI_CHILDREN),
    value: None,
};

pub static WORD_IMPI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("led")],
    values: &[&["implied"]],
    range: 3..=3,
};

static WORD_IMPE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_IMPE_CHILDREN),
    value: None,
};

pub static WORD_IMPE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cabbly"),
        dictgen::InsensitiveStr::Ascii("ccabile"),
        dictgen::InsensitiveStr::Ascii("ccible"),
        dictgen::InsensitiveStr::Ascii("ckable"),
        dictgen::InsensitiveStr::Ascii("dence"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("lement"),
        dictgen::InsensitiveStr::Ascii("lementation"),
        dictgen::InsensitiveStr::Ascii("lemented"),
        dictgen::InsensitiveStr::Ascii("lementing"),
        dictgen::InsensitiveStr::Ascii("lements"),
        dictgen::InsensitiveStr::Ascii("lentation"),
        dictgen::InsensitiveStr::Ascii("lment"),
        dictgen::InsensitiveStr::Ascii("lmentation"),
        dictgen::InsensitiveStr::Ascii("lmentations"),
        dictgen::InsensitiveStr::Ascii("lments"),
        dictgen::InsensitiveStr::Ascii("ment"),
        dictgen::InsensitiveStr::Ascii("mentaion"),
        dictgen::InsensitiveStr::Ascii("mentaions"),
        dictgen::InsensitiveStr::Ascii("mentated"),
        dictgen::InsensitiveStr::Ascii("mentation"),
        dictgen::InsensitiveStr::Ascii("mentations"),
        dictgen::InsensitiveStr::Ascii("mented"),
        dictgen::InsensitiveStr::Ascii("menting"),
        dictgen::InsensitiveStr::Ascii("mentling"),
        dictgen::InsensitiveStr::Ascii("mentor"),
        dictgen::InsensitiveStr::Ascii("ments"),
        dictgen::InsensitiveStr::Ascii("railist"),
        dictgen::InsensitiveStr::Ascii("ravi"),
        dictgen::InsensitiveStr::Ascii("realist"),
        dictgen::InsensitiveStr::Ascii("retive"),
        dictgen::InsensitiveStr::Ascii("rfactions"),
        dictgen::InsensitiveStr::Ascii("rfectionists"),
        dictgen::InsensitiveStr::Ascii("rfet"),
        dictgen::InsensitiveStr::Ascii("riaal"),
        dictgen::InsensitiveStr::Ascii("rialfist"),
        dictgen::InsensitiveStr::Ascii("rialims"),
        dictgen::InsensitiveStr::Ascii("rialisim"),
        dictgen::InsensitiveStr::Ascii("rialsim"),
        dictgen::InsensitiveStr::Ascii("rialsm"),
        dictgen::InsensitiveStr::Ascii("rialst"),
        dictgen::InsensitiveStr::Ascii("rialstic"),
        dictgen::InsensitiveStr::Ascii("riarist"),
        dictgen::InsensitiveStr::Ascii("rical"),
        dictgen::InsensitiveStr::Ascii("rically"),
        dictgen::InsensitiveStr::Ascii("rislist"),
        dictgen::InsensitiveStr::Ascii("ritave"),
        dictgen::InsensitiveStr::Ascii("ritive"),
        dictgen::InsensitiveStr::Ascii("rmable"),
        dictgen::InsensitiveStr::Ascii("rsinating"),
        dictgen::InsensitiveStr::Ascii("rsonationg"),
    ],
    values: &[
        &["impeccably"],
        &["impeccable"],
        &["impeccable"],
        &["impeccable"],
        &["impedance"],
        &["impede"],
        &["implement"],
        &["implementation"],
        &["implemented"],
        &["implementing"],
        &["implements"],
        &["implementation"],
        &["implement"],
        &["implementations", "implementation"],
        &["implementations"],
        &["implements"],
        &["implement"],
        &["implementation"],
        &["implementations"],
        &["implemented"],
        &["implementation"],
        &["implementations"],
        &["implemented"],
        &["implementing"],
        &["implementing"],
        &["implementer"],
        &["implements"],
        &["imperialist"],
        &["imperative"],
        &["imperialist"],
        &["imperative"],
        &["imperfections"],
        &["imperfections"],
        &["imperfect"],
        &["imperial"],
        &["imperialist"],
        &["imperialism"],
        &["imperialism"],
        &["imperialism"],
        &["imperialism"],
        &["imperialist"],
        &["imperialist"],
        &["imperialist"],
        &["empirical", "imperial"],
        &["empirically"],
        &["imperialist"],
        &["imperative"],
        &["imperative"],
        &["impermeable"],
        &["impersonating"],
        &["impersonating"],
    ],
    range: 2..=12,
};

static WORD_IMPC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_IMPC_CHILDREN),
    value: None,
};

pub static WORD_IMPC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("at"),
        dictgen::InsensitiveStr::Ascii("ated"),
        dictgen::InsensitiveStr::Ascii("ating"),
        dictgen::InsensitiveStr::Ascii("ats"),
    ],
    values: &[&["impact"], &["impacted"], &["impacting"], &["impacts"]],
    range: 2..=5,
};

static WORD_IMPA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_IMPA_CHILDREN),
    value: None,
};

pub static WORD_IMPA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ctes"),
        dictgen::InsensitiveStr::Ascii("ctos"),
        dictgen::InsensitiveStr::Ascii("itent"),
        dictgen::InsensitiveStr::Ascii("ried"),
        dictgen::InsensitiveStr::Ascii("rital"),
        dictgen::InsensitiveStr::Ascii("rtirla"),
    ],
    values: &[
        &["impacts"],
        &["impacts"],
        &["impatient"],
        &["impaired"],
        &["impartial"],
        &["impartial"],
    ],
    range: 4..=6,
};

static WORD_IMO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_IMO_CHILDREN),
    value: None,
};

pub static WORD_IMO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("licit"),
        dictgen::InsensitiveStr::Ascii("licitly"),
        dictgen::InsensitiveStr::Ascii("rt"),
        dictgen::InsensitiveStr::Ascii("rtable"),
        dictgen::InsensitiveStr::Ascii("rted"),
        dictgen::InsensitiveStr::Ascii("rtes"),
        dictgen::InsensitiveStr::Ascii("rting"),
        dictgen::InsensitiveStr::Ascii("rts"),
        dictgen::InsensitiveStr::Ascii("vable"),
    ],
    values: &[
        &["implicit"],
        &["implicitly"],
        &["import"],
        &["importable"],
        &["imported"],
        &["imports"],
        &["importing"],
        &["imports"],
        &["immovable"],
    ],
    range: 2..=7,
};

static WORD_IMM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_IMM_CHILDREN),
    value: None,
};

static WORD_IMM_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_IMMA_NODE),
    Some(&WORD_IMMB_NODE),
    None,
    None,
    Some(&WORD_IMME_NODE),
    None,
    None,
    None,
    Some(&WORD_IMMI_NODE),
    None,
    None,
    None,
    Some(&WORD_IMMM_NODE),
    None,
    Some(&WORD_IMMO_NODE),
    None,
    None,
    None,
    Some(&WORD_IMMS_NODE),
    None,
    Some(&WORD_IMMU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_IMMU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_IMMU_CHILDREN),
    value: None,
};

pub static WORD_IMMU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("niy"),
        dictgen::InsensitiveStr::Ascii("nosupressant"),
        dictgen::InsensitiveStr::Ascii("tible"),
    ],
    values: &[&["immunity"], &["immunosuppressant"], &["immutable"]],
    range: 3..=12,
};

static WORD_IMMS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_IMMS_CHILDREN),
    value: None,
};

pub static WORD_IMMS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("erive"),
        dictgen::InsensitiveStr::Ascii("ersive"),
        dictgen::InsensitiveStr::Ascii("ersively"),
    ],
    values: &[&["immersive"], &["immersive"], &["immersively"]],
    range: 5..=8,
};

static WORD_IMMO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_IMMO_CHILDREN),
    value: None,
};

pub static WORD_IMMO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("bilie"),
        dictgen::InsensitiveStr::Ascii("bilien"),
        dictgen::InsensitiveStr::Ascii("bilier"),
        dictgen::InsensitiveStr::Ascii("bille"),
        dictgen::InsensitiveStr::Ascii("bilze"),
        dictgen::InsensitiveStr::Ascii("bilzed"),
        dictgen::InsensitiveStr::Ascii("bilzer"),
        dictgen::InsensitiveStr::Ascii("bilzes"),
        dictgen::InsensitiveStr::Ascii("blie"),
        dictgen::InsensitiveStr::Ascii("ratlity"),
        dictgen::InsensitiveStr::Ascii("rtailty"),
        dictgen::InsensitiveStr::Ascii("rtales"),
        dictgen::InsensitiveStr::Ascii("rtalis"),
        dictgen::InsensitiveStr::Ascii("rtalisy"),
        dictgen::InsensitiveStr::Ascii("rtaliy"),
        dictgen::InsensitiveStr::Ascii("rtallity"),
        dictgen::InsensitiveStr::Ascii("rtalls"),
        dictgen::InsensitiveStr::Ascii("rtalty"),
        dictgen::InsensitiveStr::Ascii("rtaly"),
        dictgen::InsensitiveStr::Ascii("rtas"),
    ],
    values: &[
        &["immobile"],
        &["immobile"],
        &["immobile"],
        &["immobile"],
        &["immobile"],
        &["immobile"],
        &["immobile"],
        &["immobile"],
        &["immobile"],
        &["immortality"],
        &["immortality"],
        &["immortals"],
        &["immortals"],
        &["immortals"],
        &["immortality"],
        &["immortality"],
        &["immortals"],
        &["immortality"],
        &["immortality"],
        &["immortals"],
    ],
    range: 4..=8,
};

static WORD_IMMM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_IMMM_CHILDREN),
    value: None,
};

pub static WORD_IMMM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ediate"),
        dictgen::InsensitiveStr::Ascii("ediately"),
    ],
    values: &[&["immediate"], &["immediately"]],
    range: 6..=8,
};

static WORD_IMMI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_IMMI_CHILDREN),
    value: None,
};

pub static WORD_IMMI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("dately"),
        dictgen::InsensitiveStr::Ascii("datly"),
        dictgen::InsensitiveStr::Ascii("deately"),
        dictgen::InsensitiveStr::Ascii("diate"),
        dictgen::InsensitiveStr::Ascii("diatelly"),
        dictgen::InsensitiveStr::Ascii("diately"),
        dictgen::InsensitiveStr::Ascii("diatly"),
        dictgen::InsensitiveStr::Ascii("graiton"),
        dictgen::InsensitiveStr::Ascii("grantes"),
        dictgen::InsensitiveStr::Ascii("granti"),
        dictgen::InsensitiveStr::Ascii("grato"),
        dictgen::InsensitiveStr::Ascii("grents"),
        dictgen::InsensitiveStr::Ascii("net"),
        dictgen::InsensitiveStr::Ascii("tate"),
        dictgen::InsensitiveStr::Ascii("tated"),
        dictgen::InsensitiveStr::Ascii("tating"),
        dictgen::InsensitiveStr::Ascii("tator"),
    ],
    values: &[
        &["immediately"],
        &["immediately"],
        &["immediately"],
        &["immediate"],
        &["immediately"],
        &["immediately"],
        &["immediately"],
        &["immigration"],
        &["immigrants"],
        &["immigration"],
        &["immigration"],
        &["immigrants"],
        &["imminent"],
        &["imitate"],
        &["imitated"],
        &["imitating"],
        &["imitator"],
    ],
    range: 3..=8,
};

static WORD_IMME_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_IMME_CHILDREN),
    value: None,
};

pub static WORD_IMME_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("adiate"),
        dictgen::InsensitiveStr::Ascii("adiately"),
        dictgen::InsensitiveStr::Ascii("daite"),
        dictgen::InsensitiveStr::Ascii("date"),
        dictgen::InsensitiveStr::Ascii("dately"),
        dictgen::InsensitiveStr::Ascii("deate"),
        dictgen::InsensitiveStr::Ascii("deately"),
        dictgen::InsensitiveStr::Ascii("deatly"),
        dictgen::InsensitiveStr::Ascii("dially"),
        dictgen::InsensitiveStr::Ascii("dialty"),
        dictgen::InsensitiveStr::Ascii("diantely"),
        dictgen::InsensitiveStr::Ascii("diantly"),
        dictgen::InsensitiveStr::Ascii("diated"),
        dictgen::InsensitiveStr::Ascii("diatelly"),
        dictgen::InsensitiveStr::Ascii("diatelty"),
        dictgen::InsensitiveStr::Ascii("diatley"),
        dictgen::InsensitiveStr::Ascii("diatlly"),
        dictgen::InsensitiveStr::Ascii("diatly"),
        dictgen::InsensitiveStr::Ascii("diatlye"),
        dictgen::InsensitiveStr::Ascii("dietely"),
        dictgen::InsensitiveStr::Ascii("dietly"),
        dictgen::InsensitiveStr::Ascii("ditaly"),
        dictgen::InsensitiveStr::Ascii("ditately"),
        dictgen::InsensitiveStr::Ascii("idate"),
        dictgen::InsensitiveStr::Ascii("idately"),
        dictgen::InsensitiveStr::Ascii("nantly"),
        dictgen::InsensitiveStr::Ascii("nint"),
        dictgen::InsensitiveStr::Ascii("nseley"),
        dictgen::InsensitiveStr::Ascii("nsley"),
        dictgen::InsensitiveStr::Ascii("risve"),
        dictgen::InsensitiveStr::Ascii("rsie"),
        dictgen::InsensitiveStr::Ascii("rsve"),
        dictgen::InsensitiveStr::Ascii("snely"),
    ],
    values: &[
        &["immediate"],
        &["immediately"],
        &["immediate"],
        &["immediate"],
        &["immediately"],
        &["immediate"],
        &["immediately"],
        &["immediately"],
        &["immediately"],
        &["immediately"],
        &["immediately"],
        &["immediately"],
        &["immediate", "immediately"],
        &["immediately"],
        &["immediately"],
        &["immediately"],
        &["immediately"],
        &["immediately"],
        &["immediately"],
        &["immediately"],
        &["immediately"],
        &["immediately"],
        &["immediately"],
        &["immediate"],
        &["immediately"],
        &["eminently"],
        &["imminent"],
        &["immensely"],
        &["immensely"],
        &["immersive"],
        &["immerse"],
        &["immerse"],
        &["immensely"],
    ],
    range: 4..=8,
};

static WORD_IMMB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_IMMB_CHILDREN),
    value: None,
};

pub static WORD_IMMB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("oile")],
    values: &[&["immobile"]],
    range: 4..=4,
};

static WORD_IMMA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_IMMA_CHILDREN),
    value: None,
};

pub static WORD_IMMA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("diate"),
        dictgen::InsensitiveStr::Ascii("diately"),
        dictgen::InsensitiveStr::Ascii("diatly"),
        dictgen::InsensitiveStr::Ascii("turaty"),
        dictgen::InsensitiveStr::Ascii("tureity"),
        dictgen::InsensitiveStr::Ascii("turety"),
    ],
    values: &[
        &["immediate"],
        &["immediately"],
        &["immediately"],
        &["immaturity"],
        &["immaturity"],
        &["immaturity"],
    ],
    range: 5..=7,
};

static WORD_IML_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_IML_CHILDREN),
    value: None,
};

pub static WORD_IML_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ement"),
        dictgen::InsensitiveStr::Ascii("ementation"),
        dictgen::InsensitiveStr::Ascii("emented"),
        dictgen::InsensitiveStr::Ascii("ementing"),
        dictgen::InsensitiveStr::Ascii("ements"),
        dictgen::InsensitiveStr::Ascii("icit"),
        dictgen::InsensitiveStr::Ascii("icitly"),
        dictgen::InsensitiveStr::Ascii("iment"),
        dictgen::InsensitiveStr::Ascii("imentation"),
        dictgen::InsensitiveStr::Ascii("imented"),
        dictgen::InsensitiveStr::Ascii("imenting"),
        dictgen::InsensitiveStr::Ascii("iments"),
        dictgen::InsensitiveStr::Ascii("pementation"),
    ],
    values: &[
        &["implement"],
        &["implementation"],
        &["implemented"],
        &["implementing"],
        &["implements"],
        &["implicit"],
        &["implicitly"],
        &["implement"],
        &["implementation"],
        &["implemented"],
        &["implementing"],
        &["implements"],
        &["implementations"],
    ],
    range: 4..=11,
};

static WORD_IMI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_IMI_CHILDREN),
    value: None,
};

pub static WORD_IMI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("diately"),
        dictgen::InsensitiveStr::Ascii("grant"),
        dictgen::InsensitiveStr::Ascii("grate"),
        dictgen::InsensitiveStr::Ascii("grated"),
        dictgen::InsensitiveStr::Ascii("gration"),
        dictgen::InsensitiveStr::Ascii("lar"),
        dictgen::InsensitiveStr::Ascii("nent"),
    ],
    values: &[
        &["immediately"],
        &["emigrant", "immigrant"],
        &["immigrate", "emigrate"],
        &["emigrated", "immigrated"],
        &["emigration", "immigration"],
        &["similar"],
        &["eminent", "imminent", "immanent"],
    ],
    range: 3..=7,
};

static WORD_IMG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_IMG_CHILDREN),
    value: None,
};

pub static WORD_IMG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("age"),
        dictgen::InsensitiveStr::Ascii("rants"),
    ],
    values: &[&["image"], &["migrants"]],
    range: 3..=5,
};

static WORD_IMF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_IMF_CHILDREN),
    value: None,
};

pub static WORD_IMF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("amus")],
    values: &[&["infamous"]],
    range: 4..=4,
};

static WORD_IME_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_IME_CHILDREN),
    value: None,
};

pub static WORD_IME_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("datly"),
        dictgen::InsensitiveStr::Ascii("dialy"),
        dictgen::InsensitiveStr::Ascii("diate"),
        dictgen::InsensitiveStr::Ascii("diately"),
        dictgen::InsensitiveStr::Ascii("diatly"),
        dictgen::InsensitiveStr::Ascii("nse"),
        dictgen::InsensitiveStr::Ascii("xperience"),
    ],
    values: &[
        &["immediately"],
        &["immediately"],
        &["immediate"],
        &["immediately"],
        &["immediately"],
        &["immense"],
        &["inexperience"],
    ],
    range: 3..=9,
};

static WORD_IMC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_IMC_CHILDREN),
    value: None,
};

pub static WORD_IMC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("oming"),
        dictgen::InsensitiveStr::Ascii("omming"),
        dictgen::InsensitiveStr::Ascii("ompatibility"),
        dictgen::InsensitiveStr::Ascii("ompatible"),
        dictgen::InsensitiveStr::Ascii("ompetence"),
        dictgen::InsensitiveStr::Ascii("omplete"),
        dictgen::InsensitiveStr::Ascii("omprehensible"),
    ],
    values: &[
        &["incoming"],
        &["incoming"],
        &["incompatibility"],
        &["incompatible"],
        &["incompetence"],
        &["incomplete"],
        &["incomprehensible"],
    ],
    range: 5..=13,
};

static WORD_IMB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_IMB_CHILDREN),
    value: None,
};

pub static WORD_IMB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("alanaced"),
        dictgen::InsensitiveStr::Ascii("alanaces"),
        dictgen::InsensitiveStr::Ascii("alancers"),
        dictgen::InsensitiveStr::Ascii("alenced"),
        dictgen::InsensitiveStr::Ascii("alences"),
        dictgen::InsensitiveStr::Ascii("aress"),
        dictgen::InsensitiveStr::Ascii("lance"),
        dictgen::InsensitiveStr::Ascii("race"),
        dictgen::InsensitiveStr::Ascii("raced"),
        dictgen::InsensitiveStr::Ascii("racer"),
        dictgen::InsensitiveStr::Ascii("races"),
        dictgen::InsensitiveStr::Ascii("racing"),
        dictgen::InsensitiveStr::Ascii("rase"),
        dictgen::InsensitiveStr::Ascii("rased"),
        dictgen::InsensitiveStr::Ascii("raser"),
        dictgen::InsensitiveStr::Ascii("rases"),
        dictgen::InsensitiveStr::Ascii("rasing"),
    ],
    values: &[
        &["imbalanced"],
        &["imbalances"],
        &["imbalances"],
        &["imbalanced"],
        &["imbalances"],
        &["embarrass"],
        &["imbalance"],
        &["embrace"],
        &["embraced"],
        &["embracer"],
        &["embraces"],
        &["embracing"],
        &["embrace"],
        &["embraced"],
        &["embracer"],
        &["embraces"],
        &["embracing"],
    ],
    range: 4..=8,
};

static WORD_IMA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_IMA_CHILDREN),
    value: None,
};

pub static WORD_IMA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("blanced"),
        dictgen::InsensitiveStr::Ascii("blances"),
        dictgen::InsensitiveStr::Ascii("ganative"),
        dictgen::InsensitiveStr::Ascii("ganitive"),
        dictgen::InsensitiveStr::Ascii("genary"),
        dictgen::InsensitiveStr::Ascii("ghe"),
        dictgen::InsensitiveStr::Ascii("gin"),
        dictgen::InsensitiveStr::Ascii("ginacion"),
        dictgen::InsensitiveStr::Ascii("ginatie"),
        dictgen::InsensitiveStr::Ascii("ginatiei"),
        dictgen::InsensitiveStr::Ascii("ginating"),
        dictgen::InsensitiveStr::Ascii("ginativo"),
        dictgen::InsensitiveStr::Ascii("ginaton"),
        dictgen::InsensitiveStr::Ascii("ginery"),
        dictgen::InsensitiveStr::Ascii("ginitave"),
        dictgen::InsensitiveStr::Ascii("ginitve"),
        dictgen::InsensitiveStr::Ascii("kes"),
        dictgen::InsensitiveStr::Ascii("nent"),
        dictgen::InsensitiveStr::Ascii("pct"),
        dictgen::InsensitiveStr::Ascii("pcted"),
        dictgen::InsensitiveStr::Ascii("pcting"),
        dictgen::InsensitiveStr::Ascii("pcts"),
        dictgen::InsensitiveStr::Ascii("pge"),
        dictgen::InsensitiveStr::Ascii("pired"),
        dictgen::InsensitiveStr::Ascii("ptient"),
    ],
    values: &[
        &["imbalanced"],
        &["imbalances"],
        &["imaginative"],
        &["imaginative"],
        &["imaginary"],
        &["image"],
        &["imagine"],
        &["imagination"],
        &["imaginative"],
        &["imaginative"],
        &["imagination"],
        &["imagination"],
        &["imagination"],
        &["imaginary", "imagery"],
        &["imaginative"],
        &["imaginative"],
        &["makes"],
        &["eminent", "imminent"],
        &["impact"],
        &["impacted"],
        &["impacting"],
        &["impacts"],
        &["image"],
        &["impaired"],
        &["impatient"],
    ],
    range: 3..=8,
};

static WORD_IL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_IL_CHILDREN),
    value: None,
};

static WORD_IL_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_ILA_NODE),
    None,
    None,
    None,
    Some(&WORD_ILE_NODE),
    None,
    None,
    None,
    Some(&WORD_ILI_NODE),
    None,
    None,
    Some(&WORD_ILL_NODE),
    None,
    Some(&WORD_ILN_NODE),
    Some(&WORD_ILO_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_ILT_NODE),
    Some(&WORD_ILU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_ILU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ILU_CHILDREN),
    value: None,
};

pub static WORD_ILU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("minate"),
        dictgen::InsensitiveStr::Ascii("minated"),
        dictgen::InsensitiveStr::Ascii("minates"),
        dictgen::InsensitiveStr::Ascii("mination"),
        dictgen::InsensitiveStr::Ascii("minations"),
        dictgen::InsensitiveStr::Ascii("strate"),
        dictgen::InsensitiveStr::Ascii("strated"),
        dictgen::InsensitiveStr::Ascii("stration"),
    ],
    values: &[
        &["illuminate"],
        &["illuminated"],
        &["illuminates"],
        &["illumination"],
        &["illuminations"],
        &["illustrate"],
        &["illustrated"],
        &["illustration"],
    ],
    range: 6..=9,
};

static WORD_ILT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ILT_CHILDREN),
    value: None,
};

pub static WORD_ILT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("erate")],
    values: &[&["literate"]],
    range: 5..=5,
};

static WORD_ILO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ILO_CHILDREN),
    value: None,
};

pub static WORD_ILO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("gical")],
    values: &[&["illogical"]],
    range: 5..=5,
};

static WORD_ILN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ILN_CHILDREN),
    value: None,
};

pub static WORD_ILN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ess")],
    values: &[&["illness"]],
    range: 3..=3,
};

static WORD_ILL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_ILL_CHILDREN),
    value: None,
};

static WORD_ILL_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    None,
    None,
    Some(&WORD_ILLE_NODE),
    None,
    Some(&WORD_ILLG_NODE),
    None,
    Some(&WORD_ILLI_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_ILLN_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_ILLS_NODE),
    None,
    Some(&WORD_ILLU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_ILLU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ILLU_CHILDREN),
    value: None,
};

pub static WORD_ILLU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("manati"),
        dictgen::InsensitiveStr::Ascii("maniti"),
        dictgen::InsensitiveStr::Ascii("mianti"),
        dictgen::InsensitiveStr::Ascii("mimati"),
        dictgen::InsensitiveStr::Ascii("minaci"),
        dictgen::InsensitiveStr::Ascii("minadi"),
        dictgen::InsensitiveStr::Ascii("minai"),
        dictgen::InsensitiveStr::Ascii("minami"),
        dictgen::InsensitiveStr::Ascii("minanti"),
        dictgen::InsensitiveStr::Ascii("minarti"),
        dictgen::InsensitiveStr::Ascii("minatti"),
        dictgen::InsensitiveStr::Ascii("minauti"),
        dictgen::InsensitiveStr::Ascii("minazi"),
        dictgen::InsensitiveStr::Ascii("mini"),
        dictgen::InsensitiveStr::Ascii("miniati"),
        dictgen::InsensitiveStr::Ascii("minista"),
        dictgen::InsensitiveStr::Ascii("minite"),
        dictgen::InsensitiveStr::Ascii("miniti"),
        dictgen::InsensitiveStr::Ascii("minoti"),
        dictgen::InsensitiveStr::Ascii("mintati"),
        dictgen::InsensitiveStr::Ascii("minuti"),
        dictgen::InsensitiveStr::Ascii("mniati"),
        dictgen::InsensitiveStr::Ascii("munati"),
        dictgen::InsensitiveStr::Ascii("ninati"),
        dictgen::InsensitiveStr::Ascii("siones"),
        dictgen::InsensitiveStr::Ascii("started"),
        dictgen::InsensitiveStr::Ascii("startion"),
        dictgen::InsensitiveStr::Ascii("startions"),
        dictgen::InsensitiveStr::Ascii("startor"),
        dictgen::InsensitiveStr::Ascii("straded"),
        dictgen::InsensitiveStr::Ascii("straion"),
        dictgen::InsensitiveStr::Ascii("straitor"),
        dictgen::InsensitiveStr::Ascii("strant"),
        dictgen::InsensitiveStr::Ascii("strare"),
        dictgen::InsensitiveStr::Ascii("strasion"),
        dictgen::InsensitiveStr::Ascii("strater"),
        dictgen::InsensitiveStr::Ascii("stratie"),
        dictgen::InsensitiveStr::Ascii("straties"),
        dictgen::InsensitiveStr::Ascii("stratin"),
        dictgen::InsensitiveStr::Ascii("stratior"),
        dictgen::InsensitiveStr::Ascii("strato"),
        dictgen::InsensitiveStr::Ascii("straton"),
        dictgen::InsensitiveStr::Ascii("stre"),
        dictgen::InsensitiveStr::Ascii("tion"),
    ],
    values: &[
        &["illuminati"],
        &["illuminati"],
        &["illuminati"],
        &["illuminati"],
        &["illuminati"],
        &["illuminati"],
        &["illuminati"],
        &["illuminati"],
        &["illuminati"],
        &["illuminati"],
        &["illuminati"],
        &["illuminati"],
        &["illuminati"],
        &["illuminati"],
        &["illuminati"],
        &["illuminati"],
        &["illuminati"],
        &["illuminati"],
        &["illuminati"],
        &["illuminati"],
        &["illuminati"],
        &["illuminati"],
        &["illuminati"],
        &["illuminati"],
        &["illusions"],
        &["illustrated"],
        &["illustration"],
        &["illustrations"],
        &["illustrator"],
        &["illustrated"],
        &["illustration"],
        &["illustrator"],
        &["illustrate"],
        &["illustrate"],
        &["illustration"],
        &["illustrator"],
        &["illustrate"],
        &["illustrate"],
        &["illustrations"],
        &["illustrator"],
        &["illustration"],
        &["illustration"],
        &["illustrate"],
        &["illusion"],
    ],
    range: 4..=9,
};

static WORD_ILLS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ILLS_CHILDREN),
    value: None,
};

pub static WORD_ILLS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("uions"),
        dictgen::InsensitiveStr::Ascii("utration"),
        dictgen::InsensitiveStr::Ascii("utrator"),
    ],
    values: &[&["illusions"], &["illustrations"], &["illustrator"]],
    range: 5..=8,
};

static WORD_ILLN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ILLN_CHILDREN),
    value: None,
};

pub static WORD_ILLN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("esess"),
        dictgen::InsensitiveStr::Ascii("esss"),
    ],
    values: &[&["illnesses"], &["illnesses"]],
    range: 4..=5,
};

static WORD_ILLI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ILLI_CHILDREN),
    value: None,
};

pub static WORD_ILLI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("egal"),
        dictgen::InsensitiveStr::Ascii("gal"),
        dictgen::InsensitiveStr::Ascii("getimate"),
        dictgen::InsensitiveStr::Ascii("gitament"),
        dictgen::InsensitiveStr::Ascii("gitemate"),
        dictgen::InsensitiveStr::Ascii("munati"),
        dictgen::InsensitiveStr::Ascii("nios"),
        dictgen::InsensitiveStr::Ascii("noians"),
        dictgen::InsensitiveStr::Ascii("nos"),
        dictgen::InsensitiveStr::Ascii("onis"),
        dictgen::InsensitiveStr::Ascii("strate"),
        dictgen::InsensitiveStr::Ascii("stration"),
        dictgen::InsensitiveStr::Ascii("strations"),
        dictgen::InsensitiveStr::Ascii("tarate"),
        dictgen::InsensitiveStr::Ascii("tirate"),
    ],
    values: &[
        &["illegal"],
        &["illegal"],
        &["illegitimate"],
        &["illegitimate"],
        &["illegitimate"],
        &["illuminati"],
        &["illinois"],
        &["illinois"],
        &["illinois"],
        &["illinois"],
        &["illiterate", "illustrate"],
        &["illustration"],
        &["illustrations"],
        &["illiterate"],
        &["illiterate"],
    ],
    range: 3..=9,
};

static WORD_ILLG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ILLG_CHILDREN),
    value: None,
};

pub static WORD_ILLG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("al")],
    values: &[&["illegal"]],
    range: 2..=2,
};

static WORD_ILLE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ILLE_CHILDREN),
    value: None,
};

pub static WORD_ILLE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("gales"),
        dictgen::InsensitiveStr::Ascii("galest"),
        dictgen::InsensitiveStr::Ascii("galis"),
        dictgen::InsensitiveStr::Ascii("gallity"),
        dictgen::InsensitiveStr::Ascii("gallly"),
        dictgen::InsensitiveStr::Ascii("galls"),
        dictgen::InsensitiveStr::Ascii("galy"),
        dictgen::InsensitiveStr::Ascii("gas"),
        dictgen::InsensitiveStr::Ascii("getimate"),
        dictgen::InsensitiveStr::Ascii("gimacy"),
        dictgen::InsensitiveStr::Ascii("gitamate"),
        dictgen::InsensitiveStr::Ascii("gitamite"),
        dictgen::InsensitiveStr::Ascii("gitamte"),
        dictgen::InsensitiveStr::Ascii("gitemate"),
        dictgen::InsensitiveStr::Ascii("gitime"),
        dictgen::InsensitiveStr::Ascii("gitimite"),
        dictgen::InsensitiveStr::Ascii("gitimt"),
        dictgen::InsensitiveStr::Ascii("gitmate"),
        dictgen::InsensitiveStr::Ascii("gsl"),
        dictgen::InsensitiveStr::Ascii("ss"),
    ],
    values: &[
        &["illegals"],
        &["illegals"],
        &["illegals"],
        &["illegally"],
        &["illegally"],
        &["illegals"],
        &["illegally"],
        &["illegals"],
        &["illegitimate"],
        &["illegitimacy"],
        &["illegitimate"],
        &["illegitimate"],
        &["illegitimate"],
        &["illegitimate"],
        &["illegitimate"],
        &["illegitimate"],
        &["illegitimate"],
        &["illegitimate"],
        &["illegals"],
        &["illness"],
    ],
    range: 2..=8,
};

static WORD_ILI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ILI_CHILDREN),
    value: None,
};

pub static WORD_ILI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("gal")],
    values: &[&["illegal"]],
    range: 3..=3,
};

static WORD_ILE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ILE_CHILDREN),
    value: None,
};

pub static WORD_ILE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("agle"),
        dictgen::InsensitiveStr::Ascii("gal"),
        dictgen::InsensitiveStr::Ascii("gle"),
    ],
    values: &[&["illegal"], &["illegal"], &["illegal"]],
    range: 3..=4,
};

static WORD_ILA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ILA_CHILDREN),
    value: None,
};

pub static WORD_ILA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("nd")],
    values: &[&["island"]],
    range: 2..=2,
};

static WORD_II_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_II_CHILDREN),
    value: None,
};

pub static WORD_II_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("f"),
        dictgen::InsensitiveStr::Ascii("mmune"),
        dictgen::InsensitiveStr::Ascii("nclude"),
        dictgen::InsensitiveStr::Ascii("nterval"),
        dictgen::InsensitiveStr::Ascii("terator"),
    ],
    values: &[
        &["if"],
        &["immune"],
        &["include"],
        &["interval"],
        &["iterator"],
    ],
    range: 1..=7,
};

static WORD_IH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_IH_CHILDREN),
    value: None,
};

pub static WORD_IH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aca"),
        dictgen::InsensitiveStr::Ascii("s"),
    ],
    values: &[&["ithaca"], &["his"]],
    range: 1..=3,
};

static WORD_IG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_IG_CHILDREN),
    value: None,
};

static WORD_IG_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_IGN_NODE),
    Some(&WORD_IGO_NODE),
    None,
    None,
    Some(&WORD_IGR_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_IGZ_NODE),
];

static WORD_IGZ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_IGZ_CHILDREN),
    value: None,
};

pub static WORD_IGZ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ort"),
        dictgen::InsensitiveStr::Ascii("orted"),
        dictgen::InsensitiveStr::Ascii("orter"),
        dictgen::InsensitiveStr::Ascii("orting"),
        dictgen::InsensitiveStr::Ascii("orts"),
    ],
    values: &[
        &["exhort"],
        &["exhorted"],
        &["exhorter"],
        &["exhorting"],
        &["exhorts"],
    ],
    range: 3..=6,
};

static WORD_IGR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_IGR_CHILDREN),
    value: None,
};

pub static WORD_IGR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("nore")],
    values: &[&["ignore"]],
    range: 4..=4,
};

static WORD_IGO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_IGO_CHILDREN),
    value: None,
};

pub static WORD_IGO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ned"),
        dictgen::InsensitiveStr::Ascii("norando"),
        dictgen::InsensitiveStr::Ascii("nore"),
        dictgen::InsensitiveStr::Ascii("re"),
        dictgen::InsensitiveStr::Ascii("red"),
        dictgen::InsensitiveStr::Ascii("res"),
        dictgen::InsensitiveStr::Ascii("ring"),
        dictgen::InsensitiveStr::Ascii("rned"),
    ],
    values: &[
        &["ignored"],
        &["ignorando"],
        &["ignore"],
        &["ignore"],
        &["ignored"],
        &["ignores"],
        &["ignoring"],
        &["ignored"],
    ],
    range: 2..=7,
};

static WORD_IGN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_IGN_CHILDREN),
    value: None,
};

pub static WORD_IGN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("est"),
        dictgen::InsensitiveStr::Ascii("ested"),
        dictgen::InsensitiveStr::Ascii("esting"),
        dictgen::InsensitiveStr::Ascii("ests"),
        dictgen::InsensitiveStr::Ascii("itin"),
        dictgen::InsensitiveStr::Ascii("nore"),
        dictgen::InsensitiveStr::Ascii("oded"),
        dictgen::InsensitiveStr::Ascii("onre"),
        dictgen::InsensitiveStr::Ascii("ora"),
        dictgen::InsensitiveStr::Ascii("orat"),
        dictgen::InsensitiveStr::Ascii("ord"),
        dictgen::InsensitiveStr::Ascii("oreing"),
        dictgen::InsensitiveStr::Ascii("orence"),
        dictgen::InsensitiveStr::Ascii("orgable"),
        dictgen::InsensitiveStr::Ascii("orgd"),
        dictgen::InsensitiveStr::Ascii("orge"),
        dictgen::InsensitiveStr::Ascii("orged"),
        dictgen::InsensitiveStr::Ascii("orgg"),
        dictgen::InsensitiveStr::Ascii("orgig"),
        dictgen::InsensitiveStr::Ascii("orging"),
        dictgen::InsensitiveStr::Ascii("orgs"),
        dictgen::InsensitiveStr::Ascii("ormable"),
        dictgen::InsensitiveStr::Ascii("ormd"),
        dictgen::InsensitiveStr::Ascii("orme"),
        dictgen::InsensitiveStr::Ascii("ormed"),
        dictgen::InsensitiveStr::Ascii("ormg"),
        dictgen::InsensitiveStr::Ascii("ormig"),
        dictgen::InsensitiveStr::Ascii("orming"),
        dictgen::InsensitiveStr::Ascii("orms"),
        dictgen::InsensitiveStr::Ascii("ornable"),
        dictgen::InsensitiveStr::Ascii("ornace"),
        dictgen::InsensitiveStr::Ascii("ornd"),
        dictgen::InsensitiveStr::Ascii("orne"),
        dictgen::InsensitiveStr::Ascii("orned"),
        dictgen::InsensitiveStr::Ascii("orng"),
        dictgen::InsensitiveStr::Ascii("ornig"),
        dictgen::InsensitiveStr::Ascii("orning"),
        dictgen::InsensitiveStr::Ascii("orns"),
        dictgen::InsensitiveStr::Ascii("orrable"),
        dictgen::InsensitiveStr::Ascii("orrd"),
        dictgen::InsensitiveStr::Ascii("orre"),
        dictgen::InsensitiveStr::Ascii("orred"),
        dictgen::InsensitiveStr::Ascii("orrg"),
        dictgen::InsensitiveStr::Ascii("orrig"),
        dictgen::InsensitiveStr::Ascii("orring"),
        dictgen::InsensitiveStr::Ascii("orrs"),
        dictgen::InsensitiveStr::Ascii("ors"),
        dictgen::InsensitiveStr::Ascii("ortable"),
        dictgen::InsensitiveStr::Ascii("ortd"),
        dictgen::InsensitiveStr::Ascii("orte"),
        dictgen::InsensitiveStr::Ascii("orted"),
        dictgen::InsensitiveStr::Ascii("ortg"),
        dictgen::InsensitiveStr::Ascii("ortig"),
        dictgen::InsensitiveStr::Ascii("orting"),
        dictgen::InsensitiveStr::Ascii("orts"),
        dictgen::InsensitiveStr::Ascii("ory"),
        dictgen::InsensitiveStr::Ascii("roed"),
        dictgen::InsensitiveStr::Ascii("roing"),
    ],
    values: &[
        &["ingest"],
        &["ingested"],
        &["ingesting"],
        &["ingests"],
        &["ignition"],
        &["ignore"],
        &["ignored"],
        &["ignore"],
        &["ignore"],
        &["ignorant"],
        &["ignored"],
        &["ignoring"],
        &["ignorance"],
        &["ignorable"],
        &["ignored"],
        &["ignore"],
        &["ignored"],
        &["ignoring"],
        &["ignoring"],
        &["ignoring"],
        &["ignores"],
        &["ignorable"],
        &["ignored"],
        &["ignore"],
        &["ignored"],
        &["ignoring"],
        &["ignoring"],
        &["ignoring"],
        &["ignores"],
        &["ignorable"],
        &["ignorance"],
        &["ignored"],
        &["ignore"],
        &["ignored"],
        &["ignoring"],
        &["ignoring"],
        &["ignoring"],
        &["ignores"],
        &["ignorable"],
        &["ignored"],
        &["ignore"],
        &["ignored"],
        &["ignoring"],
        &["ignoring"],
        &["ignoring"],
        &["ignores"],
        &["ignores"],
        &["ignorable"],
        &["ignored"],
        &["ignore"],
        &["ignored"],
        &["ignoring"],
        &["ignoring"],
        &["ignoring"],
        &["ignores"],
        &["ignore"],
        &["ignored"],
        &["ignoring"],
    ],
    range: 3..=7,
};

static WORD_IF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_IF_CHILDREN),
    value: None,
};

pub static WORD_IF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ormation"),
        dictgen::InsensitiveStr::Ascii("self"),
    ],
    values: &[&["information"], &["itself"]],
    range: 4..=8,
};

static WORD_IE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_IE_CHILDREN),
    value: None,
};

pub static WORD_IE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("chart"),
        dictgen::InsensitiveStr::Ascii("rland"),
    ],
    values: &[&["piechart"], &["ireland"]],
    range: 5..=5,
};

static WORD_ID_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_ID_CHILDREN),
    value: None,
};

static WORD_ID_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_IDA_NODE),
    None,
    None,
    None,
    Some(&WORD_IDE_NODE),
    None,
    None,
    None,
    Some(&WORD_IDI_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_IDO_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_IDO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_IDO_CHILDREN),
    value: None,
};

pub static WORD_IDO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ns")],
    values: &[&["icons"]],
    range: 2..=2,
};

static WORD_IDI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_IDI_CHILDREN),
    value: None,
};

pub static WORD_IDI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cate"),
        dictgen::InsensitiveStr::Ascii("cated"),
        dictgen::InsensitiveStr::Ascii("cates"),
        dictgen::InsensitiveStr::Ascii("cating"),
        dictgen::InsensitiveStr::Ascii("ces"),
        dictgen::InsensitiveStr::Ascii("ologically"),
        dictgen::InsensitiveStr::Ascii("osincracies"),
        dictgen::InsensitiveStr::Ascii("osincracy"),
        dictgen::InsensitiveStr::Ascii("osincratic"),
        dictgen::InsensitiveStr::Ascii("osynchracies"),
        dictgen::InsensitiveStr::Ascii("osynchrasies"),
        dictgen::InsensitiveStr::Ascii("osynchrasy"),
        dictgen::InsensitiveStr::Ascii("osynchratic"),
        dictgen::InsensitiveStr::Ascii("osyncracies"),
        dictgen::InsensitiveStr::Ascii("osyncracy"),
        dictgen::InsensitiveStr::Ascii("vidual"),
        dictgen::InsensitiveStr::Ascii("vidually"),
        dictgen::InsensitiveStr::Ascii("viduals"),
    ],
    values: &[
        &["indicate"],
        &["indicated"],
        &["indicates"],
        &["indicating"],
        &["indices"],
        &["ideologically"],
        &["idiosyncrasies"],
        &["idiosyncrasy"],
        &["idiosyncratic"],
        &["idiosyncrasies"],
        &["idiosyncrasies"],
        &["idiosyncrasy"],
        &["idiosyncratic"],
        &["idiosyncrasies"],
        &["idiosyncrasy"],
        &["individual"],
        &["individually"],
        &["individuals"],
    ],
    range: 3..=12,
};

static WORD_IDE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_IDE_CHILDREN),
    value: None,
};

static WORD_IDE_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_IDEA_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_IDEF_NODE),
    None,
    None,
    Some(&WORD_IDEI_NODE),
    None,
    None,
    Some(&WORD_IDEL_NODE),
    Some(&WORD_IDEM_NODE),
    Some(&WORD_IDEN_NODE),
    Some(&WORD_IDEO_NODE),
    Some(&WORD_IDEP_NODE),
    None,
    None,
    Some(&WORD_IDES_NODE),
    Some(&WORD_IDET_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_IDET_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_IDET_CHILDREN),
    value: None,
};

pub static WORD_IDET_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ifier"),
        dictgen::InsensitiveStr::Ascii("ifiers"),
        dictgen::InsensitiveStr::Ascii("ifies"),
    ],
    values: &[&["identifier"], &["identifiers"], &["identifies"]],
    range: 5..=6,
};

static WORD_IDES_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_IDES_CHILDREN),
    value: None,
};

pub static WORD_IDES_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("a")],
    values: &[&["ideas", "ides"]],
    range: 1..=1,
};

static WORD_IDEP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_IDEP_CHILDREN),
    value: None,
};

pub static WORD_IDEP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("endently")],
    values: &[&["independently"]],
    range: 8..=8,
};

static WORD_IDEO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_IDEO_CHILDREN),
    value: None,
};

pub static WORD_IDEO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("lagies"),
        dictgen::InsensitiveStr::Ascii("ligically"),
        dictgen::InsensitiveStr::Ascii("ligies"),
        dictgen::InsensitiveStr::Ascii("loge"),
        dictgen::InsensitiveStr::Ascii("logias"),
        dictgen::InsensitiveStr::Ascii("logicaly"),
        dictgen::InsensitiveStr::Ascii("logice"),
        dictgen::InsensitiveStr::Ascii("logiers"),
        dictgen::InsensitiveStr::Ascii("logije"),
        dictgen::InsensitiveStr::Ascii("logins"),
        dictgen::InsensitiveStr::Ascii("logis"),
        dictgen::InsensitiveStr::Ascii("logisen"),
        dictgen::InsensitiveStr::Ascii("logiset"),
        dictgen::InsensitiveStr::Ascii("logisk"),
        dictgen::InsensitiveStr::Ascii("logiske"),
        dictgen::InsensitiveStr::Ascii("louges"),
        dictgen::InsensitiveStr::Ascii("sincracies"),
        dictgen::InsensitiveStr::Ascii("sincracy"),
        dictgen::InsensitiveStr::Ascii("sincratic"),
        dictgen::InsensitiveStr::Ascii("syncracies"),
        dictgen::InsensitiveStr::Ascii("syncracy"),
        dictgen::InsensitiveStr::Ascii("syncratic"),
    ],
    values: &[
        &["ideologies"],
        &["ideologically"],
        &["ideologies"],
        &["ideologies"],
        &["ideologies"],
        &["ideologically"],
        &["ideologies"],
        &["ideologies"],
        &["ideologies"],
        &["ideologies"],
        &["ideologies"],
        &["ideologies"],
        &["ideologies"],
        &["ideologies"],
        &["ideologies"],
        &["ideologies"],
        &["idiosyncrasies"],
        &["idiosyncrasy"],
        &["idiosyncratic"],
        &["ideosyncrasies", "idiosyncrasies"],
        &["idiosyncrasy"],
        &["idiosyncratic"],
    ],
    range: 4..=10,
};

static WORD_IDEN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_IDEN_CHILDREN),
    value: None,
};

static WORD_IDEN_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    None,
    Some(&WORD_IDEND_NODE),
    None,
    Some(&WORD_IDENF_NODE),
    None,
    None,
    Some(&WORD_IDENI_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_IDENT_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_IDENT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_IDENT_CHILDREN),
    value: None,
};

pub static WORD_IDENT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ation"),
        dictgen::InsensitiveStr::Ascii("cial"),
        dictgen::InsensitiveStr::Ascii("fied"),
        dictgen::InsensitiveStr::Ascii("fier"),
        dictgen::InsensitiveStr::Ascii("fiers"),
        dictgen::InsensitiveStr::Ascii("iable"),
        dictgen::InsensitiveStr::Ascii("ial"),
        dictgen::InsensitiveStr::Ascii("ic"),
        dictgen::InsensitiveStr::Ascii("icial"),
        dictgen::InsensitiveStr::Ascii("idier"),
        dictgen::InsensitiveStr::Ascii("ies"),
        dictgen::InsensitiveStr::Ascii("ifaction"),
        dictgen::InsensitiveStr::Ascii("ifcation"),
        dictgen::InsensitiveStr::Ascii("ifeir"),
        dictgen::InsensitiveStr::Ascii("ifeirs"),
        dictgen::InsensitiveStr::Ascii("ifer"),
        dictgen::InsensitiveStr::Ascii("ifers"),
        dictgen::InsensitiveStr::Ascii("ifible"),
        dictgen::InsensitiveStr::Ascii("ificable"),
        dictgen::InsensitiveStr::Ascii("ificacion"),
        dictgen::InsensitiveStr::Ascii("ificaiton"),
        dictgen::InsensitiveStr::Ascii("ificativo"),
        dictgen::InsensitiveStr::Ascii("ificato"),
        dictgen::InsensitiveStr::Ascii("ificaton"),
        dictgen::InsensitiveStr::Ascii("ifictaion"),
        dictgen::InsensitiveStr::Ascii("ifieer"),
        dictgen::InsensitiveStr::Ascii("ifield"),
        dictgen::InsensitiveStr::Ascii("ifierad"),
        dictgen::InsensitiveStr::Ascii("ifieras"),
        dictgen::InsensitiveStr::Ascii("ifikation"),
        dictgen::InsensitiveStr::Ascii("ifiler"),
        dictgen::InsensitiveStr::Ascii("ifilers"),
        dictgen::InsensitiveStr::Ascii("ifing"),
        dictgen::InsensitiveStr::Ascii("ifiter"),
        dictgen::InsensitiveStr::Ascii("ifiters"),
        dictgen::InsensitiveStr::Ascii("ifiy"),
        dictgen::InsensitiveStr::Ascii("ifyable"),
        dictgen::InsensitiveStr::Ascii("ifyed"),
        dictgen::InsensitiveStr::Ascii("iies"),
        dictgen::InsensitiveStr::Ascii("ite"),
        dictgen::InsensitiveStr::Ascii("ites"),
        dictgen::InsensitiveStr::Ascii("itets"),
        dictgen::InsensitiveStr::Ascii("itites"),
        dictgen::InsensitiveStr::Ascii("itiy"),
        dictgen::InsensitiveStr::Ascii("itties"),
        dictgen::InsensitiveStr::Ascii("iviert"),
        dictgen::InsensitiveStr::Ascii("iy"),
        dictgen::InsensitiveStr::Ascii("tation"),
        dictgen::InsensitiveStr::Ascii("ties"),
        dictgen::InsensitiveStr::Ascii("tifier"),
        dictgen::InsensitiveStr::Ascii("ty"),
    ],
    values: &[
        &["indentation"],
        &["identical"],
        &["identified"],
        &["identifier"],
        &["identifiers"],
        &["identifiable"],
        &["identical"],
        &["identical"],
        &["identical"],
        &["identifier"],
        &["identities"],
        &["identification"],
        &["identification"],
        &["identifier"],
        &["identifiers"],
        &["identifier"],
        &["identifiers"],
        &["identifiable"],
        &["identifiable"],
        &["identification"],
        &["identification"],
        &["identification"],
        &["identification"],
        &["identification"],
        &["identification"],
        &["identifier"],
        &["identified"],
        &["identified"],
        &["identifies"],
        &["identification"],
        &["identifier"],
        &["identifiers"],
        &["identifying"],
        &["identifier"],
        &["identifier"],
        &["identify"],
        &["identifiable"],
        &["identified"],
        &["identities"],
        &["identities"],
        &["identities"],
        &["identities"],
        &["identities"],
        &["identity"],
        &["identities"],
        &["identifiers"],
        &["identify", "identity"],
        &["indentation"],
        &["identities"],
        &["identifier"],
        &["identity"],
    ],
    range: 2..=9,
};

static WORD_IDENI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_IDENI_CHILDREN),
    value: None,
};

pub static WORD_IDENI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("fiable"),
        dictgen::InsensitiveStr::Ascii("tfy"),
        dictgen::InsensitiveStr::Ascii("ties"),
        dictgen::InsensitiveStr::Ascii("tify"),
        dictgen::InsensitiveStr::Ascii("ty"),
    ],
    values: &[
        &["identifiable"],
        &["identify"],
        &["identities"],
        &["identify"],
        &["identity"],
    ],
    range: 2..=6,
};

static WORD_IDENF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_IDENF_CHILDREN),
    value: None,
};

pub static WORD_IDENF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ied"),
        dictgen::InsensitiveStr::Ascii("ifier"),
        dictgen::InsensitiveStr::Ascii("ifiers"),
        dictgen::InsensitiveStr::Ascii("itifer"),
        dictgen::InsensitiveStr::Ascii("itifers"),
        dictgen::InsensitiveStr::Ascii("itify"),
        dictgen::InsensitiveStr::Ascii("ity"),
    ],
    values: &[
        &["identified"],
        &["identifier"],
        &["identifiers"],
        &["identifier"],
        &["identifiers"],
        &["identify"],
        &["identify"],
    ],
    range: 3..=7,
};

static WORD_IDEND_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_IDEND_CHILDREN),
    value: None,
};

pub static WORD_IDEND_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ified"),
        dictgen::InsensitiveStr::Ascii("ifier"),
        dictgen::InsensitiveStr::Ascii("ifiers"),
    ],
    values: &[&["identified"], &["identifier"], &["identifiers"]],
    range: 5..=6,
};

static WORD_IDEM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_IDEM_CHILDREN),
    value: None,
};

pub static WORD_IDEM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("opotent")],
    values: &[&["idempotent"]],
    range: 7..=7,
};

static WORD_IDEL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_IDEL_CHILDREN),
    value: Some(&["idle"]),
};

pub static WORD_IDEL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ogy")],
    values: &[&["ideology"]],
    range: 3..=3,
};

static WORD_IDEI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_IDEI_CHILDREN),
    value: None,
};

pub static WORD_IDEI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ntify")],
    values: &[&["identify"]],
    range: 5..=5,
};

static WORD_IDEF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_IDEF_CHILDREN),
    value: None,
};

pub static WORD_IDEF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("inite")],
    values: &[&["indefinite"]],
    range: 5..=5,
};

static WORD_IDEA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_IDEA_CHILDREN),
    value: None,
};

pub static WORD_IDEA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("lisim"),
        dictgen::InsensitiveStr::Ascii("lisitc"),
        dictgen::InsensitiveStr::Ascii("lisitic"),
        dictgen::InsensitiveStr::Ascii("listc"),
        dictgen::InsensitiveStr::Ascii("listisch"),
        dictgen::InsensitiveStr::Ascii("logies"),
        dictgen::InsensitiveStr::Ascii("logy"),
        dictgen::InsensitiveStr::Ascii("lsim"),
    ],
    values: &[
        &["idealism"],
        &["idealistic"],
        &["idealistic"],
        &["idealistic"],
        &["idealistic"],
        &["ideologies"],
        &["ideology"],
        &["idealism"],
    ],
    range: 4..=8,
};

static WORD_IDA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_IDA_CHILDREN),
    value: None,
};

pub static WORD_IDA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("eidae"),
        dictgen::InsensitiveStr::Ascii("es"),
    ],
    values: &[&["idea"], &["idea"], &["ideas"]],
    range: 1..=5,
};

static WORD_IC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_IC_CHILDREN),
    value: None,
};

pub static WORD_IC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eforg"),
        dictgen::InsensitiveStr::Ascii("efrong"),
        dictgen::InsensitiveStr::Ascii("elandinc"),
        dictgen::InsensitiveStr::Ascii("elings"),
        dictgen::InsensitiveStr::Ascii("esickle"),
        dictgen::InsensitiveStr::Ascii("leandic"),
        dictgen::InsensitiveStr::Ascii("lude"),
        dictgen::InsensitiveStr::Ascii("luded"),
        dictgen::InsensitiveStr::Ascii("ludes"),
        dictgen::InsensitiveStr::Ascii("luding"),
        dictgen::InsensitiveStr::Ascii("onclastic"),
        dictgen::InsensitiveStr::Ascii("ongnito"),
        dictgen::InsensitiveStr::Ascii("onifie"),
        dictgen::InsensitiveStr::Ascii("rease"),
        dictgen::InsensitiveStr::Ascii("reased"),
        dictgen::InsensitiveStr::Ascii("reases"),
        dictgen::InsensitiveStr::Ascii("reasing"),
        dictgen::InsensitiveStr::Ascii("rement"),
        dictgen::InsensitiveStr::Ascii("rementally"),
        dictgen::InsensitiveStr::Ascii("remented"),
        dictgen::InsensitiveStr::Ascii("rementing"),
        dictgen::InsensitiveStr::Ascii("rements"),
    ],
    values: &[
        &["icefrog"],
        &["icefrog"],
        &["icelandic"],
        &["ceilings"],
        &["icicle"],
        &["icelandic"],
        &["include"],
        &["included"],
        &["includes"],
        &["including"],
        &["iconoclastic"],
        &["incognito"],
        &["iconify"],
        &["increase"],
        &["increased"],
        &["increases"],
        &["increasing"],
        &["increment"],
        &["incrementally"],
        &["incremented"],
        &["incrementing"],
        &["increments"],
    ],
    range: 4..=10,
};

static WORD_IB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_IB_CHILDREN),
    value: None,
};

pub static WORD_IB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ject"),
        dictgen::InsensitiveStr::Ascii("jects"),
        dictgen::InsensitiveStr::Ascii("rary"),
        dictgen::InsensitiveStr::Ascii("uprofein"),
        dictgen::InsensitiveStr::Ascii("uprofine"),
        dictgen::InsensitiveStr::Ascii("urpofen"),
    ],
    values: &[
        &["object"],
        &["objects"],
        &["library"],
        &["ibuprofen"],
        &["ibuprofen"],
        &["ibuprofen"],
    ],
    range: 4..=8,
};

static WORD_IA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_IA_CHILDREN),
    value: None,
};

pub static WORD_IA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("mge")],
    values: &[&["image"]],
    range: 3..=3,
};

static WORD_H_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_H_CHILDREN),
    value: None,
};

static WORD_H_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_HA_NODE),
    None,
    None,
    Some(&WORD_HD_NODE),
    Some(&WORD_HE_NODE),
    None,
    Some(&WORD_HG_NODE),
    Some(&WORD_HH_NODE),
    Some(&WORD_HI_NODE),
    None,
    None,
    None,
    Some(&WORD_HM_NODE),
    Some(&WORD_HN_NODE),
    Some(&WORD_HO_NODE),
    None,
    None,
    Some(&WORD_HR_NODE),
    Some(&WORD_HS_NODE),
    Some(&WORD_HT_NODE),
    Some(&WORD_HU_NODE),
    Some(&WORD_HV_NODE),
    Some(&WORD_HW_NODE),
    None,
    Some(&WORD_HY_NODE),
    None,
];

static WORD_HY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_HY_CHILDREN),
    value: None,
};

static WORD_HY_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    Some(&WORD_HYB_NODE),
    None,
    Some(&WORD_HYD_NODE),
    Some(&WORD_HYE_NODE),
    None,
    Some(&WORD_HYG_NODE),
    None,
    None,
    Some(&WORD_HYJ_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_HYO_NODE),
    Some(&WORD_HYP_NODE),
    None,
    Some(&WORD_HYR_NODE),
    Some(&WORD_HYS_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_HYS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HYS_CHILDREN),
    value: None,
};

pub static WORD_HYS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("tarical"),
        dictgen::InsensitiveStr::Ascii("tarically"),
        dictgen::InsensitiveStr::Ascii("tera"),
        dictgen::InsensitiveStr::Ascii("terica"),
        dictgen::InsensitiveStr::Ascii("tericallly"),
        dictgen::InsensitiveStr::Ascii("tericaly"),
        dictgen::InsensitiveStr::Ascii("tericlly"),
        dictgen::InsensitiveStr::Ascii("tericly"),
        dictgen::InsensitiveStr::Ascii("teriia"),
        dictgen::InsensitiveStr::Ascii("teriska"),
        dictgen::InsensitiveStr::Ascii("torically"),
    ],
    values: &[
        &["hysterical"],
        &["hysterically"],
        &["hysteria"],
        &["hysteria"],
        &["hysterically"],
        &["hysterically"],
        &["hysterically"],
        &["hysterical"],
        &["hysteria"],
        &["hysteria"],
        &["hysterically"],
    ],
    range: 4..=10,
};

static WORD_HYR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HYR_CHILDREN),
    value: None,
};

pub static WORD_HYR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("bids"),
        dictgen::InsensitiveStr::Ascii("dation"),
        dictgen::InsensitiveStr::Ascii("daulic"),
        dictgen::InsensitiveStr::Ascii("dogen"),
    ],
    values: &[&["hybrids"], &["hydration"], &["hydraulic"], &["hydrogen"]],
    range: 4..=6,
};

static WORD_HYP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_HYP_CHILDREN),
    value: None,
};

static WORD_HYP_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_HYPA_NODE),
    None,
    Some(&WORD_HYPC_NODE),
    None,
    Some(&WORD_HYPE_NODE),
    None,
    None,
    Some(&WORD_HYPH_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_HYPN_NODE),
    Some(&WORD_HYPO_NODE),
    None,
    None,
    Some(&WORD_HYPR_NODE),
    None,
    Some(&WORD_HYPT_NODE),
    None,
    Some(&WORD_HYPV_NODE),
    None,
    None,
    None,
    None,
];

static WORD_HYPV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HYPV_CHILDREN),
    value: None,
};

pub static WORD_HYPV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ervisor"),
        dictgen::InsensitiveStr::Ascii("ervisors"),
        dictgen::InsensitiveStr::Ascii("isor"),
        dictgen::InsensitiveStr::Ascii("isors"),
    ],
    values: &[
        &["hypervisor"],
        &["hypervisors"],
        &["hypervisor"],
        &["hypervisors"],
    ],
    range: 4..=8,
};

static WORD_HYPT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HYPT_CHILDREN),
    value: None,
};

pub static WORD_HYPT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("er"),
        dictgen::InsensitiveStr::Ascii("othetical"),
        dictgen::InsensitiveStr::Ascii("othetically"),
    ],
    values: &[&["hyper"], &["hypothetical"], &["hypothetically"]],
    range: 2..=11,
};

static WORD_HYPR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HYPR_CHILDREN),
    value: None,
};

pub static WORD_HYPR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ocisy"),
        dictgen::InsensitiveStr::Ascii("ocite"),
        dictgen::InsensitiveStr::Ascii("ocites"),
    ],
    values: &[&["hypocrisy"], &["hypocrite"], &["hypocrites"]],
    range: 5..=6,
};

static WORD_HYPO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HYPO_CHILDREN),
    value: None,
};

pub static WORD_HYPO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cracy"),
        dictgen::InsensitiveStr::Ascii("crasy"),
        dictgen::InsensitiveStr::Ascii("crates"),
        dictgen::InsensitiveStr::Ascii("cricy"),
        dictgen::InsensitiveStr::Ascii("criet"),
        dictgen::InsensitiveStr::Ascii("criscy"),
        dictgen::InsensitiveStr::Ascii("crises"),
        dictgen::InsensitiveStr::Ascii("crit"),
        dictgen::InsensitiveStr::Ascii("critcal"),
        dictgen::InsensitiveStr::Ascii("critial"),
        dictgen::InsensitiveStr::Ascii("criticial"),
        dictgen::InsensitiveStr::Ascii("crities"),
        dictgen::InsensitiveStr::Ascii("crits"),
        dictgen::InsensitiveStr::Ascii("critus"),
        dictgen::InsensitiveStr::Ascii("crticial"),
        dictgen::InsensitiveStr::Ascii("crties"),
        dictgen::InsensitiveStr::Ascii("crytes"),
        dictgen::InsensitiveStr::Ascii("crytical"),
        dictgen::InsensitiveStr::Ascii("krites"),
        dictgen::InsensitiveStr::Ascii("nsis"),
        dictgen::InsensitiveStr::Ascii("rcite"),
        dictgen::InsensitiveStr::Ascii("seses"),
        dictgen::InsensitiveStr::Ascii("sesis"),
        dictgen::InsensitiveStr::Ascii("tehtical"),
        dictgen::InsensitiveStr::Ascii("tehtically"),
        dictgen::InsensitiveStr::Ascii("teses"),
        dictgen::InsensitiveStr::Ascii("tesis"),
        dictgen::InsensitiveStr::Ascii("tethical"),
        dictgen::InsensitiveStr::Ascii("tethically"),
        dictgen::InsensitiveStr::Ascii("thecis"),
        dictgen::InsensitiveStr::Ascii("theiss"),
        dictgen::InsensitiveStr::Ascii("thenuse"),
        dictgen::InsensitiveStr::Ascii("thenuses"),
        dictgen::InsensitiveStr::Ascii("therical"),
        dictgen::InsensitiveStr::Ascii("thesees"),
        dictgen::InsensitiveStr::Ascii("thesies"),
        dictgen::InsensitiveStr::Ascii("thess"),
        dictgen::InsensitiveStr::Ascii("thesus"),
        dictgen::InsensitiveStr::Ascii("theticaly"),
        dictgen::InsensitiveStr::Ascii("theticly"),
        dictgen::InsensitiveStr::Ascii("thises"),
        dictgen::InsensitiveStr::Ascii("thisis"),
        dictgen::InsensitiveStr::Ascii("thosis"),
    ],
    values: &[
        &["hypocrisy"],
        &["hypocrisy"],
        &["hypocrites"],
        &["hypocrisy"],
        &["hypocrite"],
        &["hypocrisy"],
        &["hypocrites"],
        &["hypocrite"],
        &["hypocritical"],
        &["hypocritical"],
        &["hypocritical"],
        &["hypocrite"],
        &["hypocrites"],
        &["hypocrites"],
        &["hypocritical"],
        &["hypocrites"],
        &["hypocrites"],
        &["hypocritical"],
        &["hypocrites"],
        &["hypnosis"],
        &["hypocrite"],
        &["hypotheses"],
        &["hypothesis"],
        &["hypothetical"],
        &["hypothetically"],
        &["hypotheses"],
        &["hypothesis"],
        &["hypothetical"],
        &["hypothetically"],
        &["hypothesis"],
        &["hypotheses"],
        &["hypotenuse"],
        &["hypotenuses"],
        &["hypothetical"],
        &["hypotheses"],
        &["hypothesis"],
        &["hypotheses"],
        &["hypotheses"],
        &["hypothetically"],
        &["hypothetical"],
        &["hypotheses"],
        &["hypothesis"],
        &["hypothesis"],
    ],
    range: 4..=10,
};

static WORD_HYPN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HYPN_CHILDREN),
    value: None,
};

pub static WORD_HYPN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("oss")],
    values: &[&["hypnosis"]],
    range: 3..=3,
};

static WORD_HYPH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HYPH_CHILDREN),
    value: None,
};

pub static WORD_HYPH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("otesis")],
    values: &[&["hypothesis"]],
    range: 6..=6,
};

static WORD_HYPE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HYPE_CHILDREN),
    value: None,
};

pub static WORD_HYPE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("n"),
        dictgen::InsensitiveStr::Ascii("nate"),
        dictgen::InsensitiveStr::Ascii("nated"),
        dictgen::InsensitiveStr::Ascii("nates"),
        dictgen::InsensitiveStr::Ascii("nating"),
        dictgen::InsensitiveStr::Ascii("nation"),
        dictgen::InsensitiveStr::Ascii("ns"),
        dictgen::InsensitiveStr::Ascii("rbel"),
        dictgen::InsensitiveStr::Ascii("rbolie"),
        dictgen::InsensitiveStr::Ascii("rbollic"),
        dictgen::InsensitiveStr::Ascii("rboly"),
        dictgen::InsensitiveStr::Ascii("rbrophy"),
        dictgen::InsensitiveStr::Ascii("rldger"),
        dictgen::InsensitiveStr::Ascii("rlobic"),
        dictgen::InsensitiveStr::Ascii("rlogic"),
        dictgen::InsensitiveStr::Ascii("roble"),
        dictgen::InsensitiveStr::Ascii("rthropy"),
        dictgen::InsensitiveStr::Ascii("rtorphy"),
        dictgen::InsensitiveStr::Ascii("rtrohpy"),
        dictgen::InsensitiveStr::Ascii("rtrohy"),
        dictgen::InsensitiveStr::Ascii("rtrophey"),
        dictgen::InsensitiveStr::Ascii("rtropy"),
        dictgen::InsensitiveStr::Ascii("rvior"),
        dictgen::InsensitiveStr::Ascii("thetical"),
        dictgen::InsensitiveStr::Ascii("thetically"),
        dictgen::InsensitiveStr::Ascii("visor"),
    ],
    values: &[
        &["hyphen"],
        &["hyphenate"],
        &["hyphenated"],
        &["hyphenates"],
        &["hyphenating"],
        &["hyphenation"],
        &["hyphens"],
        &["hyperbole"],
        &["hyperbole"],
        &["hyperbolic"],
        &["hyperbole"],
        &["hypertrophy"],
        &["hyperledger"],
        &["hyperbolic"],
        &["hyperbolic"],
        &["hyperbole"],
        &["hypertrophy"],
        &["hypertrophy"],
        &["hypertrophy"],
        &["hypertrophy"],
        &["hypertrophy"],
        &["hypertrophy"],
        &["hypervisor"],
        &["hypothetical"],
        &["hypothetically"],
        &["hypervisor"],
    ],
    range: 1..=10,
};

static WORD_HYPC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HYPC_CHILDREN),
    value: None,
};

pub static WORD_HYPC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("orite")],
    values: &[&["hypocrite"]],
    range: 5..=5,
};

static WORD_HYPA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HYPA_CHILDREN),
    value: None,
};

pub static WORD_HYPA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("thetical"),
        dictgen::InsensitiveStr::Ascii("thetically"),
    ],
    values: &[&["hypothetical"], &["hypothetically"]],
    range: 8..=10,
};

static WORD_HYO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HYO_CHILDREN),
    value: None,
};

pub static WORD_HYO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("pcrite"),
        dictgen::InsensitiveStr::Ascii("pthetical"),
        dictgen::InsensitiveStr::Ascii("pthetically"),
    ],
    values: &[&["hypocrite"], &["hypothetical"], &["hypothetically"]],
    range: 6..=11,
};

static WORD_HYJ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HYJ_CHILDREN),
    value: None,
};

pub static WORD_HYJ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ack"),
        dictgen::InsensitiveStr::Ascii("acking"),
    ],
    values: &[&["hijack"], &["hijacking"]],
    range: 3..=6,
};

static WORD_HYG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HYG_CHILDREN),
    value: None,
};

pub static WORD_HYG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eine"),
        dictgen::InsensitiveStr::Ascii("ene"),
        dictgen::InsensitiveStr::Ascii("enic"),
        dictgen::InsensitiveStr::Ascii("ience"),
        dictgen::InsensitiveStr::Ascii("ienne"),
        dictgen::InsensitiveStr::Ascii("ine"),
    ],
    values: &[
        &["hygiene"],
        &["hygiene"],
        &["hygienic"],
        &["hygiene"],
        &["hygiene"],
        &["hygiene"],
    ],
    range: 3..=5,
};

static WORD_HYE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HYE_CHILDREN),
    value: None,
};

pub static WORD_HYE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("rarchy"),
        dictgen::InsensitiveStr::Ascii("rlink"),
    ],
    values: &[&["hierarchy"], &["hyperlink"]],
    range: 5..=6,
};

static WORD_HYD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HYD_CHILDREN),
    value: None,
};

pub static WORD_HYD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ogen"),
        dictgen::InsensitiveStr::Ascii("orgen"),
        dictgen::InsensitiveStr::Ascii("raluic"),
        dictgen::InsensitiveStr::Ascii("ratin"),
        dictgen::InsensitiveStr::Ascii("regon"),
        dictgen::InsensitiveStr::Ascii("rolic"),
        dictgen::InsensitiveStr::Ascii("rolics"),
        dictgen::InsensitiveStr::Ascii("ropile"),
        dictgen::InsensitiveStr::Ascii("ropilic"),
        dictgen::InsensitiveStr::Ascii("ropobe"),
        dictgen::InsensitiveStr::Ascii("ropobic"),
        dictgen::InsensitiveStr::Ascii("rualic"),
    ],
    values: &[
        &["hydrogen"],
        &["hydrogen"],
        &["hydraulic"],
        &["hydration"],
        &["hydrogen"],
        &["hydraulic"],
        &["hydraulics"],
        &["hydrophile"],
        &["hydrophilic"],
        &["hydrophobe"],
        &["hydrophobic"],
        &["hydraulic"],
    ],
    range: 4..=7,
};

static WORD_HYB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HYB_CHILDREN),
    value: None,
};

pub static WORD_HYB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ernate"),
        dictgen::InsensitiveStr::Ascii("irds"),
        dictgen::InsensitiveStr::Ascii("rides"),
        dictgen::InsensitiveStr::Ascii("ridus"),
    ],
    values: &[&["hibernate"], &["hybrids"], &["hybrids"], &["hybrids"]],
    range: 4..=6,
};

static WORD_HW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HW_CHILDREN),
    value: None,
};

pub static WORD_HW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eaton"),
        dictgen::InsensitiveStr::Ascii("ihc"),
        dictgen::InsensitiveStr::Ascii("ile"),
        dictgen::InsensitiveStr::Ascii("ole"),
    ],
    values: &[&["wheaton"], &["which"], &["while"], &["whole"]],
    range: 3..=5,
};

static WORD_HV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HV_CHILDREN),
    value: None,
};

pub static WORD_HV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ae"),
        dictgen::InsensitiveStr::Ascii("aing"),
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("ea"),
    ],
    values: &[&["have"], &["having"], &["have"], &["have", "heave"]],
    range: 1..=4,
};

static WORD_HU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_HU_CHILDREN),
    value: None,
};

static WORD_HU_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_HUA_NODE),
    None,
    None,
    None,
    Some(&WORD_HUE_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_HUL_NODE),
    Some(&WORD_HUM_NODE),
    Some(&WORD_HUN_NODE),
    None,
    None,
    None,
    Some(&WORD_HUR_NODE),
    Some(&WORD_HUS_NODE),
    Some(&WORD_HUT_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_HUT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HUT_CHILDREN),
    value: None,
};

pub static WORD_HUT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("nsman")],
    values: &[&["huntsman"]],
    range: 5..=5,
};

static WORD_HUS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HUS_CHILDREN),
    value: None,
};

pub static WORD_HUS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ban"),
        dictgen::InsensitiveStr::Ascii("bandos"),
        dictgen::InsensitiveStr::Ascii("bans"),
        dictgen::InsensitiveStr::Ascii("sel"),
    ],
    values: &[
        &["husband"],
        &["husbands"],
        &["husbands"],
        &["hustle", "mussel"],
    ],
    range: 3..=6,
};

static WORD_HUR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HUR_CHILDREN),
    value: None,
};

pub static WORD_HUR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("dels"),
        dictgen::InsensitiveStr::Ascii("icane"),
        dictgen::InsensitiveStr::Ascii("istic"),
        dictgen::InsensitiveStr::Ascii("ldes"),
        dictgen::InsensitiveStr::Ascii("riance"),
        dictgen::InsensitiveStr::Ascii("ricaines"),
        dictgen::InsensitiveStr::Ascii("ricance"),
        dictgen::InsensitiveStr::Ascii("ricances"),
        dictgen::InsensitiveStr::Ascii("ricanefps"),
        dictgen::InsensitiveStr::Ascii("ricanger"),
        dictgen::InsensitiveStr::Ascii("ricans"),
        dictgen::InsensitiveStr::Ascii("riganes"),
        dictgen::InsensitiveStr::Ascii("rikanes"),
        dictgen::InsensitiveStr::Ascii("rycanes"),
        dictgen::InsensitiveStr::Ascii("se"),
    ],
    values: &[
        &["hurdles"],
        &["hurricane"],
        &["heuristic"],
        &["hurdles"],
        &["hurricane"],
        &["hurricanes"],
        &["hurricane"],
        &["hurricanes"],
        &["hurricanes"],
        &["hurricane"],
        &["hurricanes"],
        &["hurricanes"],
        &["hurricanes"],
        &["hurricanes"],
        &["hearse", "nurse"],
    ],
    range: 2..=9,
};

static WORD_HUN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HUN_CHILDREN),
    value: None,
};

pub static WORD_HUN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("agrian"),
        dictgen::InsensitiveStr::Ascii("agry"),
        dictgen::InsensitiveStr::Ascii("derd"),
        dictgen::InsensitiveStr::Ascii("derds"),
        dictgen::InsensitiveStr::Ascii("dread"),
        dictgen::InsensitiveStr::Ascii("dres"),
        dictgen::InsensitiveStr::Ascii("dret"),
        dictgen::InsensitiveStr::Ascii("dreths"),
        dictgen::InsensitiveStr::Ascii("drets"),
        dictgen::InsensitiveStr::Ascii("garin"),
        dictgen::InsensitiveStr::Ascii("gray"),
        dictgen::InsensitiveStr::Ascii("gs"),
        dictgen::InsensitiveStr::Ascii("man"),
        dictgen::InsensitiveStr::Ascii("rgy"),
        dictgen::InsensitiveStr::Ascii("tmsan"),
    ],
    values: &[
        &["hungarian"],
        &["hungary"],
        &["hundred"],
        &["hundreds"],
        &["hundred"],
        &["hundreds"],
        &["hundred", "hundreds"],
        &["hundredths"],
        &["hundreds"],
        &["hungarian"],
        &["hungary"],
        &["hangs", "hung"],
        &["human"],
        &["hungry"],
        &["huntsman"],
    ],
    range: 2..=6,
};

static WORD_HUM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HUM_CHILDREN),
    value: None,
};

pub static WORD_HUM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("anaties"),
        dictgen::InsensitiveStr::Ascii("aniod"),
        dictgen::InsensitiveStr::Ascii("anit"),
        dictgen::InsensitiveStr::Ascii("anitarien"),
        dictgen::InsensitiveStr::Ascii("anitarion"),
        dictgen::InsensitiveStr::Ascii("anitarna"),
        dictgen::InsensitiveStr::Ascii("anitary"),
        dictgen::InsensitiveStr::Ascii("anitatian"),
        dictgen::InsensitiveStr::Ascii("anite"),
        dictgen::InsensitiveStr::Ascii("aniterian"),
        dictgen::InsensitiveStr::Ascii("anitis"),
        dictgen::InsensitiveStr::Ascii("anitites"),
        dictgen::InsensitiveStr::Ascii("anoind"),
        dictgen::InsensitiveStr::Ascii("antiarian"),
        dictgen::InsensitiveStr::Ascii("antiy"),
        dictgen::InsensitiveStr::Ascii("ants"),
        dictgen::InsensitiveStr::Ascii("ber"),
        dictgen::InsensitiveStr::Ascii("er"),
        dictgen::InsensitiveStr::Ascii("erous"),
        dictgen::InsensitiveStr::Ascii("iditiy"),
        dictgen::InsensitiveStr::Ascii("idiy"),
        dictgen::InsensitiveStr::Ascii("iliatin"),
        dictgen::InsensitiveStr::Ascii("iliaton"),
        dictgen::InsensitiveStr::Ascii("ilitaing"),
        dictgen::InsensitiveStr::Ascii("ilitaion"),
        dictgen::InsensitiveStr::Ascii("ilitied"),
        dictgen::InsensitiveStr::Ascii("illated"),
        dictgen::InsensitiveStr::Ascii("illating"),
        dictgen::InsensitiveStr::Ascii("illation"),
        dictgen::InsensitiveStr::Ascii("inatarian"),
        dictgen::InsensitiveStr::Ascii("inoid"),
        dictgen::InsensitiveStr::Ascii("itidy"),
        dictgen::InsensitiveStr::Ascii("oros"),
        dictgen::InsensitiveStr::Ascii("ouros"),
        dictgen::InsensitiveStr::Ascii("urous"),
    ],
    values: &[
        &["humanities"],
        &["humanoid"],
        &["humanist"],
        &["humanitarian"],
        &["humanitarian"],
        &["humanitarian"],
        &["humanity"],
        &["humanitarian"],
        &["humanities"],
        &["humanitarian"],
        &["humanities"],
        &["humanities"],
        &["humanoid"],
        &["humanitarian"],
        &["humanity"],
        &["humanist"],
        &["number"],
        &["humor"],
        &["humorous", "humerus"],
        &["humidity"],
        &["humidity"],
        &["humiliation"],
        &["humiliation"],
        &["humiliating"],
        &["humiliation"],
        &["humiliated"],
        &["humiliated"],
        &["humiliating"],
        &["humiliation"],
        &["humanitarian"],
        &["humanoid"],
        &["humidity"],
        &["humorous"],
        &["humorous"],
        &["humorous"],
    ],
    range: 2..=9,
};

static WORD_HUL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HUL_CHILDREN),
    value: None,
};

pub static WORD_HUL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("d"),
        dictgen::InsensitiveStr::Ascii("lucination"),
        dictgen::InsensitiveStr::Ascii("lucinations"),
    ],
    values: &[&["held", "hold"], &["hallucination"], &["hallucinations"]],
    range: 1..=11,
};

static WORD_HUE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HUE_CHILDREN),
    value: None,
};

pub static WORD_HUE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ristic")],
    values: &[&["heuristic"]],
    range: 6..=6,
};

static WORD_HUA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HUA_CHILDREN),
    value: None,
};

pub static WORD_HUA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("nted"),
        dictgen::InsensitiveStr::Ascii("nting"),
    ],
    values: &[&["haunted"], &["haunting"]],
    range: 4..=5,
};

static WORD_HT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HT_CHILDREN),
    value: None,
};

pub static WORD_HT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("acccess"),
        dictgen::InsensitiveStr::Ascii("aching"),
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("en"),
        dictgen::InsensitiveStr::Ascii("ere"),
        dictgen::InsensitiveStr::Ascii("ey"),
        dictgen::InsensitiveStr::Ascii("iboxes"),
        dictgen::InsensitiveStr::Ascii("ikn"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("ink"),
        dictgen::InsensitiveStr::Ascii("is"),
        dictgen::InsensitiveStr::Ascii("lm"),
        dictgen::InsensitiveStr::Ascii("mp"),
        dictgen::InsensitiveStr::Ascii("ose"),
        dictgen::InsensitiveStr::Ascii("pt"),
        dictgen::InsensitiveStr::Ascii("pts"),
        dictgen::InsensitiveStr::Ascii("ting"),
    ],
    values: &[
        &["htaccess"],
        &["hatching"],
        &["the"],
        &["then", "hen", "the"],
        &["there", "here"],
        &["they"],
        &["hitboxes"],
        &["think"],
        &["thing"],
        &["think"],
        &["this"],
        &["html"],
        &["html"],
        &["these", "those"],
        &["http"],
        &["https"],
        &["hitting"],
    ],
    range: 1..=7,
};

static WORD_HS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HS_CHILDREN),
    value: None,
};

pub static WORD_HS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("a"),
        dictgen::InsensitiveStr::Ascii("eldon"),
        dictgen::InsensitiveStr::Ascii("ell"),
        dictgen::InsensitiveStr::Ascii("i"),
        dictgen::InsensitiveStr::Ascii("itorians"),
        dictgen::InsensitiveStr::Ascii("otname"),
        dictgen::InsensitiveStr::Ascii("ould"),
        dictgen::InsensitiveStr::Ascii("tory"),
        dictgen::InsensitiveStr::Ascii("yteria"),
    ],
    values: &[
        &["has"],
        &["sheldon"],
        &["shell"],
        &["his"],
        &["historians"],
        &["hostname"],
        &["should"],
        &["history"],
        &["hysteria"],
    ],
    range: 1..=8,
};

static WORD_HR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HR_CHILDREN),
    value: None,
};

pub static WORD_HR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("adware"),
        dictgen::InsensitiveStr::Ascii("adwares"),
        dictgen::InsensitiveStr::Ascii("lp"),
        dictgen::InsensitiveStr::Ascii("lped"),
        dictgen::InsensitiveStr::Ascii("lper"),
        dictgen::InsensitiveStr::Ascii("lpers"),
        dictgen::InsensitiveStr::Ascii("lping"),
        dictgen::InsensitiveStr::Ascii("lps"),
        dictgen::InsensitiveStr::Ascii("ough"),
    ],
    values: &[
        &["hardware"],
        &["hardwares"],
        &["help"],
        &["helped"],
        &["helper"],
        &["helpers"],
        &["helping"],
        &["helps"],
        &["through"],
    ],
    range: 2..=7,
};

static WORD_HO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_HO_CHILDREN),
    value: None,
};

static WORD_HO_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    None,
    Some(&WORD_HOD_NODE),
    Some(&WORD_HOE_NODE),
    None,
    None,
    None,
    Some(&WORD_HOI_NODE),
    None,
    Some(&WORD_HOK_NODE),
    Some(&WORD_HOL_NODE),
    Some(&WORD_HOM_NODE),
    Some(&WORD_HON_NODE),
    Some(&WORD_HOO_NODE),
    Some(&WORD_HOP_NODE),
    None,
    Some(&WORD_HOR_NODE),
    Some(&WORD_HOS_NODE),
    Some(&WORD_HOT_NODE),
    Some(&WORD_HOU_NODE),
    Some(&WORD_HOV_NODE),
    Some(&WORD_HOW_NODE),
    None,
    None,
    None,
];

static WORD_HOW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HOW_CHILDREN),
    value: None,
};

pub static WORD_HOW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eever"),
        dictgen::InsensitiveStr::Ascii("erver"),
        dictgen::InsensitiveStr::Ascii("everm"),
        dictgen::InsensitiveStr::Ascii("ewer"),
        dictgen::InsensitiveStr::Ascii("over"),
        dictgen::InsensitiveStr::Ascii("ver"),
        dictgen::InsensitiveStr::Ascii("vere"),
    ],
    values: &[
        &["however"],
        &["however"],
        &["however"],
        &["however"],
        &["however"],
        &["however"],
        &["however"],
    ],
    range: 3..=5,
};

static WORD_HOV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HOV_CHILDREN),
    value: None,
};

pub static WORD_HOV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ever"),
        dictgen::InsensitiveStr::Ascii("ewer"),
    ],
    values: &[&["however"], &["however"]],
    range: 4..=4,
};

static WORD_HOU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HOU_CHILDREN),
    value: None,
};

pub static WORD_HOU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ld"),
        dictgen::InsensitiveStr::Ascii("nour"),
        dictgen::InsensitiveStr::Ascii("res"),
        dictgen::InsensitiveStr::Ascii("rgalss"),
        dictgen::InsensitiveStr::Ascii("rlgass"),
        dictgen::InsensitiveStr::Ascii("sand"),
        dictgen::InsensitiveStr::Ascii("sehols"),
        dictgen::InsensitiveStr::Ascii("sehoulds"),
        dictgen::InsensitiveStr::Ascii("skeeping"),
        dictgen::InsensitiveStr::Ascii("sr"),
    ],
    values: &[
        &["hold", "should"],
        &["honour"],
        &["hours"],
        &["hourglass"],
        &["hourglass"],
        &["thousand"],
        &["households"],
        &["households"],
        &["housekeeping"],
        &["hours", "house"],
    ],
    range: 2..=8,
};

static WORD_HOT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HOT_CHILDREN),
    value: None,
};

pub static WORD_HOT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("hsot"),
        dictgen::InsensitiveStr::Ascii("izontal"),
        dictgen::InsensitiveStr::Ascii("name"),
        dictgen::InsensitiveStr::Ascii("psot"),
        dictgen::InsensitiveStr::Ascii("shoot"),
        dictgen::InsensitiveStr::Ascii("sopt"),
        dictgen::InsensitiveStr::Ascii("sport"),
    ],
    values: &[
        &["hotshot"],
        &["horizontal"],
        &["hostname"],
        &["hotspot"],
        &["hotshot"],
        &["hotspot"],
        &["hotspot"],
    ],
    range: 4..=7,
};

static WORD_HOS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HOS_CHILDREN),
    value: None,
};

pub static WORD_HOS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ited"),
        dictgen::InsensitiveStr::Ascii("itlity"),
        dictgen::InsensitiveStr::Ascii("pitales"),
        dictgen::InsensitiveStr::Ascii("pitallity"),
        dictgen::InsensitiveStr::Ascii("pitalty"),
        dictgen::InsensitiveStr::Ascii("pitaly"),
        dictgen::InsensitiveStr::Ascii("pitalzed"),
        dictgen::InsensitiveStr::Ascii("pitible"),
        dictgen::InsensitiveStr::Ascii("pitilized"),
        dictgen::InsensitiveStr::Ascii("pitolized"),
        dictgen::InsensitiveStr::Ascii("potality"),
        dictgen::InsensitiveStr::Ascii("ptial"),
        dictgen::InsensitiveStr::Ascii("ptialized"),
        dictgen::InsensitiveStr::Ascii("ptials"),
        dictgen::InsensitiveStr::Ascii("tanme"),
        dictgen::InsensitiveStr::Ascii("teles"),
        dictgen::InsensitiveStr::Ascii("thot"),
        dictgen::InsensitiveStr::Ascii("tiliy"),
        dictgen::InsensitiveStr::Ascii("tles"),
        dictgen::InsensitiveStr::Ascii("torical"),
        dictgen::InsensitiveStr::Ascii("tories"),
        dictgen::InsensitiveStr::Ascii("tory"),
        dictgen::InsensitiveStr::Ascii("tpot"),
        dictgen::InsensitiveStr::Ascii("tspot"),
        dictgen::InsensitiveStr::Ascii("tspots"),
    ],
    values: &[
        &["hoisted"],
        &["hostility"],
        &["hospitals"],
        &["hospitality"],
        &["hospitality"],
        &["hospitality"],
        &["hospitalized"],
        &["hospitable"],
        &["hospitalized"],
        &["hospitalized"],
        &["hospitality"],
        &["hospital"],
        &["hospitalized"],
        &["hospitals"],
        &["hostname"],
        &["hostels"],
        &["hotshot"],
        &["hostility"],
        &["hostels"],
        &["historical"],
        &["histories"],
        &["history"],
        &["hotspot"],
        &["hotspot"],
        &["hotspots"],
    ],
    range: 4..=9,
};

static WORD_HOR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HOR_CHILDREN),
    value: None,
};

pub static WORD_HOR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ader"),
        dictgen::InsensitiveStr::Ascii("ading"),
        dictgen::InsensitiveStr::Ascii("icontal"),
        dictgen::InsensitiveStr::Ascii("icontally"),
        dictgen::InsensitiveStr::Ascii("inzontal"),
        dictgen::InsensitiveStr::Ascii("ishima"),
        dictgen::InsensitiveStr::Ascii("isontal"),
        dictgen::InsensitiveStr::Ascii("isontally"),
        dictgen::InsensitiveStr::Ascii("izantal"),
        dictgen::InsensitiveStr::Ascii("izantally"),
        dictgen::InsensitiveStr::Ascii("izntal"),
        dictgen::InsensitiveStr::Ascii("izonal"),
        dictgen::InsensitiveStr::Ascii("izonally"),
        dictgen::InsensitiveStr::Ascii("izonatal"),
        dictgen::InsensitiveStr::Ascii("izones"),
        dictgen::InsensitiveStr::Ascii("izontaal"),
        dictgen::InsensitiveStr::Ascii("izontale"),
        dictgen::InsensitiveStr::Ascii("izontallly"),
        dictgen::InsensitiveStr::Ascii("izontaly"),
        dictgen::InsensitiveStr::Ascii("izontes"),
        dictgen::InsensitiveStr::Ascii("izonts"),
        dictgen::InsensitiveStr::Ascii("iztonal"),
        dictgen::InsensitiveStr::Ascii("iztonally"),
        dictgen::InsensitiveStr::Ascii("ozontally"),
        dictgen::InsensitiveStr::Ascii("phan"),
        dictgen::InsensitiveStr::Ascii("rable"),
        dictgen::InsensitiveStr::Ascii("rendeous"),
        dictgen::InsensitiveStr::Ascii("rendeus"),
        dictgen::InsensitiveStr::Ascii("rendious"),
        dictgen::InsensitiveStr::Ascii("rendos"),
        dictgen::InsensitiveStr::Ascii("renduous"),
        dictgen::InsensitiveStr::Ascii("riblely"),
        dictgen::InsensitiveStr::Ascii("ribley"),
        dictgen::InsensitiveStr::Ascii("riblly"),
        dictgen::InsensitiveStr::Ascii("rifing"),
        dictgen::InsensitiveStr::Ascii("yzontally"),
        dictgen::InsensitiveStr::Ascii("zions"),
        dictgen::InsensitiveStr::Ascii("ziontal"),
        dictgen::InsensitiveStr::Ascii("ziontally"),
        dictgen::InsensitiveStr::Ascii("zontal"),
        dictgen::InsensitiveStr::Ascii("zontally"),
    ],
    values: &[
        &["hoarder"],
        &["hoarding"],
        &["horizontal"],
        &["horizontally"],
        &["horizontal"],
        &["hiroshima"],
        &["horizontal"],
        &["horizontally"],
        &["horizontal"],
        &["horizontally"],
        &["horizontal"],
        &["horizontal"],
        &["horizontally"],
        &["horizontal"],
        &["horizons"],
        &["horizontal"],
        &["horizontal"],
        &["horizontally"],
        &["horizontally"],
        &["horizons"],
        &["horizons"],
        &["horizontal"],
        &["horizontally"],
        &["horizontally"],
        &["orphan"],
        &["horrible"],
        &["horrendous"],
        &["horrendous"],
        &["horrendous"],
        &["horrendous"],
        &["horrendous"],
        &["horribly"],
        &["horribly"],
        &["horribly"],
        &["horrifying"],
        &["horizontally"],
        &["horizons"],
        &["horizontal"],
        &["horizontally"],
        &["horizontal"],
        &["horizontally"],
    ],
    range: 4..=10,
};

static WORD_HOP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HOP_CHILDREN),
    value: None,
};

pub static WORD_HOP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("efull"),
        dictgen::InsensitiveStr::Ascii("efulle"),
        dictgen::InsensitiveStr::Ascii("efullly"),
        dictgen::InsensitiveStr::Ascii("efullt"),
        dictgen::InsensitiveStr::Ascii("efullu"),
        dictgen::InsensitiveStr::Ascii("efuly"),
        dictgen::InsensitiveStr::Ascii("eing"),
        dictgen::InsensitiveStr::Ascii("eleslly"),
        dictgen::InsensitiveStr::Ascii("elessely"),
        dictgen::InsensitiveStr::Ascii("elessley"),
        dictgen::InsensitiveStr::Ascii("elessy"),
        dictgen::InsensitiveStr::Ascii("ful"),
        dictgen::InsensitiveStr::Ascii("full"),
        dictgen::InsensitiveStr::Ascii("fully"),
        dictgen::InsensitiveStr::Ascii("kings"),
        dictgen::InsensitiveStr::Ascii("mepage"),
        dictgen::InsensitiveStr::Ascii("mepages"),
        dictgen::InsensitiveStr::Ascii("pefully"),
        dictgen::InsensitiveStr::Ascii("sital"),
        dictgen::InsensitiveStr::Ascii("sitality"),
        dictgen::InsensitiveStr::Ascii("sitalized"),
        dictgen::InsensitiveStr::Ascii("sitals"),
        dictgen::InsensitiveStr::Ascii("yfully"),
    ],
    values: &[
        &["hopeful", "hopefully"],
        &["hopefully"],
        &["hopefully"],
        &["hopefully"],
        &["hopefully"],
        &["hopefully"],
        &["hoping"],
        &["hopelessly"],
        &["hopelessly"],
        &["hopelessly"],
        &["hopelessly"],
        &["hopeful"],
        &["hopeful", "hopefully"],
        &["hopefully"],
        &["hopkins"],
        &["homepage"],
        &["homepages"],
        &["hopefully"],
        &["hospital"],
        &["hospitality"],
        &["hospitalized"],
        &["hospitals"],
        &["hopefully"],
    ],
    range: 3..=9,
};

static WORD_HOO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HOO_CHILDREN),
    value: None,
};

pub static WORD_HOO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ok"),
        dictgen::InsensitiveStr::Ascii("oks"),
        dictgen::InsensitiveStr::Ascii("tsba"),
    ],
    values: &[&["hook"], &["hooks"], &["hutzpa"]],
    range: 2..=4,
};

static WORD_HON_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HON_CHILDREN),
    value: None,
};

pub static WORD_HON_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eslty"),
        dictgen::InsensitiveStr::Ascii("eymon"),
        dictgen::InsensitiveStr::Ascii("eymooon"),
        dictgen::InsensitiveStr::Ascii("ory"),
        dictgen::InsensitiveStr::Ascii("setly"),
    ],
    values: &[
        &["honestly"],
        &["honeymoon"],
        &["honeymoon"],
        &["honorary"],
        &["honestly"],
    ],
    range: 3..=7,
};

static WORD_HOM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HOM_CHILDREN),
    value: None,
};

pub static WORD_HOM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("apage"),
        dictgen::InsensitiveStr::Ascii("ecomeing"),
        dictgen::InsensitiveStr::Ascii("ecomming"),
        dictgen::InsensitiveStr::Ascii("ecuming"),
        dictgen::InsensitiveStr::Ascii("egeneous"),
        dictgen::InsensitiveStr::Ascii("elesness"),
        dictgen::InsensitiveStr::Ascii("elessess"),
        dictgen::InsensitiveStr::Ascii("eoapthy"),
        dictgen::InsensitiveStr::Ascii("eonwer"),
        dictgen::InsensitiveStr::Ascii("eonwers"),
        dictgen::InsensitiveStr::Ascii("eopahty"),
        dictgen::InsensitiveStr::Ascii("eopaty"),
        dictgen::InsensitiveStr::Ascii("eophaty"),
        dictgen::InsensitiveStr::Ascii("eopothy"),
        dictgen::InsensitiveStr::Ascii("eothapy"),
        dictgen::InsensitiveStr::Ascii("eowneris"),
        dictgen::InsensitiveStr::Ascii("epoathy"),
        dictgen::InsensitiveStr::Ascii("esexuality"),
        dictgen::InsensitiveStr::Ascii("ewolrd"),
        dictgen::InsensitiveStr::Ascii("ewoner"),
        dictgen::InsensitiveStr::Ascii("ewoners"),
        dictgen::InsensitiveStr::Ascii("eword"),
        dictgen::InsensitiveStr::Ascii("ewrold"),
        dictgen::InsensitiveStr::Ascii("ineim"),
        dictgen::InsensitiveStr::Ascii("ineum"),
        dictgen::InsensitiveStr::Ascii("niem"),
        dictgen::InsensitiveStr::Ascii("oegenous"),
        dictgen::InsensitiveStr::Ascii("oepathy"),
        dictgen::InsensitiveStr::Ascii("ogeneize"),
        dictgen::InsensitiveStr::Ascii("ogeneized"),
        dictgen::InsensitiveStr::Ascii("ogenenous"),
        dictgen::InsensitiveStr::Ascii("ogeneos"),
        dictgen::InsensitiveStr::Ascii("ogenes"),
        dictgen::InsensitiveStr::Ascii("ogeneus"),
        dictgen::InsensitiveStr::Ascii("ogenious"),
        dictgen::InsensitiveStr::Ascii("ogeniously"),
        dictgen::InsensitiveStr::Ascii("ogenity"),
        dictgen::InsensitiveStr::Ascii("ogenius"),
        dictgen::InsensitiveStr::Ascii("ogeniusly"),
        dictgen::InsensitiveStr::Ascii("ogenoues"),
        dictgen::InsensitiveStr::Ascii("ogenous"),
        dictgen::InsensitiveStr::Ascii("ogenously"),
        dictgen::InsensitiveStr::Ascii("ogenuous"),
        dictgen::InsensitiveStr::Ascii("ophibia"),
        dictgen::InsensitiveStr::Ascii("ophibic"),
        dictgen::InsensitiveStr::Ascii("ophobie"),
        dictgen::InsensitiveStr::Ascii("ophoboes"),
        dictgen::InsensitiveStr::Ascii("ophonia"),
        dictgen::InsensitiveStr::Ascii("ophopia"),
        dictgen::InsensitiveStr::Ascii("ophopic"),
        dictgen::InsensitiveStr::Ascii("osexaul"),
        dictgen::InsensitiveStr::Ascii("osexuais"),
        dictgen::InsensitiveStr::Ascii("osexuales"),
        dictgen::InsensitiveStr::Ascii("osexualiy"),
        dictgen::InsensitiveStr::Ascii("osexuallity"),
        dictgen::InsensitiveStr::Ascii("osexualls"),
        dictgen::InsensitiveStr::Ascii("osexualtiy"),
        dictgen::InsensitiveStr::Ascii("osexualty"),
        dictgen::InsensitiveStr::Ascii("osexuel"),
        dictgen::InsensitiveStr::Ascii("osexuella"),
        dictgen::InsensitiveStr::Ascii("osexuels"),
        dictgen::InsensitiveStr::Ascii("osexul"),
        dictgen::InsensitiveStr::Ascii("osexulaity"),
    ],
    values: &[
        &["homepage"],
        &["homecoming"],
        &["homecoming"],
        &["homecoming"],
        &["homogeneous"],
        &["homelessness"],
        &["homelessness"],
        &["homeopathy"],
        &["homeowner"],
        &["homeowners"],
        &["homeopathy"],
        &["homeopathy"],
        &["homeopathy"],
        &["homeopathy"],
        &["homeopathy"],
        &["homeowners"],
        &["homeopathy"],
        &["homosexuality"],
        &["homeworld"],
        &["homeowner"],
        &["homeowners"],
        &["homeworld"],
        &["homeworld"],
        &["hominem"],
        &["hominem"],
        &["hominem"],
        &["homogeneous"],
        &["homoeopathy"],
        &["homogenize"],
        &["homogenized"],
        &["homogeneous"],
        &["homogeneous"],
        &["homogeneous"],
        &["homogeneous"],
        &["homogeneous"],
        &["homogeneously"],
        &["homogeneity"],
        &["homogeneous"],
        &["homogeneously"],
        &["homogeneous"],
        &["homogeneous"],
        &["homogeneously"],
        &["homogeneous"],
        &["homophobia"],
        &["homophobic"],
        &["homophobe"],
        &["homophobe"],
        &["homophobia"],
        &["homophobia"],
        &["homophobic"],
        &["homosexual"],
        &["homosexuals"],
        &["homosexuals"],
        &["homosexuality"],
        &["homosexuality"],
        &["homosexuals"],
        &["homosexuality"],
        &["homosexuality"],
        &["homosexual"],
        &["homosexual"],
        &["homosexuals"],
        &["homosexuals"],
        &["homosexuality"],
    ],
    range: 4..=11,
};

static WORD_HOL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HOL_CHILDREN),
    value: None,
};

pub static WORD_HOL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("diay"),
        dictgen::InsensitiveStr::Ascii("diays"),
        dictgen::InsensitiveStr::Ascii("dins"),
        dictgen::InsensitiveStr::Ascii("f"),
        dictgen::InsensitiveStr::Ascii("liday"),
        dictgen::InsensitiveStr::Ascii("lowcost"),
        dictgen::InsensitiveStr::Ascii("lywod"),
        dictgen::InsensitiveStr::Ascii("lywoood"),
        dictgen::InsensitiveStr::Ascii("ocasut"),
        dictgen::InsensitiveStr::Ascii("ocuast"),
    ],
    values: &[
        &["holiday"],
        &["holidays"],
        &["holdings"],
        &["hold"],
        &["holiday"],
        &["holocaust"],
        &["hollywood"],
        &["hollywood"],
        &["holocaust"],
        &["holocaust"],
    ],
    range: 1..=7,
};

static WORD_HOK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HOK_CHILDREN),
    value: None,
};

pub static WORD_HOK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ay"),
        dictgen::InsensitiveStr::Ascii("pins"),
    ],
    values: &[&["okay"], &["hopkins"]],
    range: 2..=4,
};

static WORD_HOI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HOI_CHILDREN),
    value: None,
};

pub static WORD_HOI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("lday"),
        dictgen::InsensitiveStr::Ascii("ldays"),
    ],
    values: &[&["holiday"], &["holidays"]],
    range: 4..=5,
};

static WORD_HOE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HOE_CHILDREN),
    value: None,
};

pub static WORD_HOE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ks"),
        dictgen::InsensitiveStr::Ascii("mopathy"),
        dictgen::InsensitiveStr::Ascii("nstly"),
        dictgen::InsensitiveStr::Ascii("pfully"),
        dictgen::InsensitiveStr::Ascii("ver"),
    ],
    values: &[
        &["hoax"],
        &["homeopathy"],
        &["honestly"],
        &["hopefully"],
        &["however"],
    ],
    range: 2..=7,
};

static WORD_HOD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HOD_CHILDREN),
    value: None,
};

pub static WORD_HOD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("lings"),
    ],
    values: &[&["holding"], &["holdings"]],
    range: 3..=5,
};

static WORD_HN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HN_CHILDREN),
    value: None,
};

pub static WORD_HN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("alder")],
    values: &[&["handler"]],
    range: 5..=5,
};

static WORD_HM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HM_CHILDREN),
    value: None,
};

pub static WORD_HM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("di"),
        dictgen::InsensitiveStr::Ascii("tl"),
    ],
    values: &[&["hdmi"], &["html"]],
    range: 2..=2,
};

static WORD_HI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_HI_CHILDREN),
    value: None,
};

static WORD_HI_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_HIA_NODE),
    None,
    None,
    Some(&WORD_HID_NODE),
    Some(&WORD_HIE_NODE),
    None,
    Some(&WORD_HIG_NODE),
    Some(&WORD_HIH_NODE),
    None,
    Some(&WORD_HIJ_NODE),
    None,
    Some(&WORD_HIL_NODE),
    Some(&WORD_HIM_NODE),
    Some(&WORD_HIN_NODE),
    None,
    Some(&WORD_HIP_NODE),
    None,
    Some(&WORD_HIR_NODE),
    Some(&WORD_HIS_NODE),
    Some(&WORD_HIT_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_HIY_NODE),
    None,
];

static WORD_HIY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HIY_CHILDREN),
    value: None,
};

pub static WORD_HIY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("geine")],
    values: &[&["hygiene"]],
    range: 5..=5,
};

static WORD_HIT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HIT_CHILDREN),
    value: None,
};

pub static WORD_HIT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("boxers"),
        dictgen::InsensitiveStr::Ascii("boxs"),
        dictgen::InsensitiveStr::Ascii("ogram"),
        dictgen::InsensitiveStr::Ascii("ories"),
        dictgen::InsensitiveStr::Ascii("ory"),
    ],
    values: &[
        &["hitboxes"],
        &["hitboxes"],
        &["histogram"],
        &["histories"],
        &["history"],
    ],
    range: 3..=6,
};

static WORD_HIS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HIS_CHILDREN),
    value: None,
};

pub static WORD_HIS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("melf"),
        dictgen::InsensitiveStr::Ascii("ory"),
        dictgen::InsensitiveStr::Ascii("pancis"),
        dictgen::InsensitiveStr::Ascii("panicos"),
        dictgen::InsensitiveStr::Ascii("panicus"),
        dictgen::InsensitiveStr::Ascii("panis"),
        dictgen::InsensitiveStr::Ascii("pter"),
        dictgen::InsensitiveStr::Ascii("pters"),
        dictgen::InsensitiveStr::Ascii("tarical"),
        dictgen::InsensitiveStr::Ascii("tarically"),
        dictgen::InsensitiveStr::Ascii("terical"),
        dictgen::InsensitiveStr::Ascii("terically"),
        dictgen::InsensitiveStr::Ascii("tgram"),
        dictgen::InsensitiveStr::Ascii("tocompatability"),
        dictgen::InsensitiveStr::Ascii("torgram"),
        dictgen::InsensitiveStr::Ascii("torgrams"),
        dictgen::InsensitiveStr::Ascii("tori"),
        dictgen::InsensitiveStr::Ascii("toriaan"),
        dictgen::InsensitiveStr::Ascii("torial"),
        dictgen::InsensitiveStr::Ascii("toricaly"),
        dictgen::InsensitiveStr::Ascii("toricans"),
        dictgen::InsensitiveStr::Ascii("toricas"),
        dictgen::InsensitiveStr::Ascii("toricians"),
        dictgen::InsensitiveStr::Ascii("toricly"),
        dictgen::InsensitiveStr::Ascii("toriens"),
        dictgen::InsensitiveStr::Ascii("torietas"),
        dictgen::InsensitiveStr::Ascii("torinhas"),
        dictgen::InsensitiveStr::Ascii("torisch"),
        dictgen::InsensitiveStr::Ascii("toryan"),
        dictgen::InsensitiveStr::Ascii("toryans"),
        dictgen::InsensitiveStr::Ascii("torycal"),
        dictgen::InsensitiveStr::Ascii("torycally"),
        dictgen::InsensitiveStr::Ascii("torycaly"),
        dictgen::InsensitiveStr::Ascii("troian"),
        dictgen::InsensitiveStr::Ascii("troians"),
        dictgen::InsensitiveStr::Ascii("troic"),
        dictgen::InsensitiveStr::Ascii("troical"),
        dictgen::InsensitiveStr::Ascii("troically"),
        dictgen::InsensitiveStr::Ascii("troicaly"),
        dictgen::InsensitiveStr::Ascii("troies"),
        dictgen::InsensitiveStr::Ascii("troy"),
        dictgen::InsensitiveStr::Ascii("try"),
    ],
    values: &[
        &["himself"],
        &["history"],
        &["hispanics"],
        &["hispanics"],
        &["hispanics"],
        &["hispanics"],
        &["hipster"],
        &["hipsters"],
        &["historical"],
        &["historically"],
        &["historical", "hysterical"],
        &["historically"],
        &["histogram"],
        &["histocompatibility"],
        &["histogram"],
        &["histograms"],
        &["history", "historic"],
        &["historians"],
        &["historical"],
        &["historically"],
        &["historians"],
        &["historians"],
        &["historians"],
        &["historical"],
        &["histories"],
        &["histories"],
        &["historians"],
        &["historic"],
        &["historian"],
        &["historians"],
        &["historical"],
        &["historically"],
        &["historically"],
        &["historian"],
        &["historians"],
        &["historic"],
        &["historical"],
        &["historically"],
        &["historically"],
        &["histories"],
        &["history"],
        &["history"],
    ],
    range: 3..=15,
};

static WORD_HIR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HIR_CHILDREN),
    value: None,
};

pub static WORD_HIR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("achy"),
        dictgen::InsensitiveStr::Ascii("archies"),
        dictgen::InsensitiveStr::Ascii("archy"),
        dictgen::InsensitiveStr::Ascii("arcies"),
        dictgen::InsensitiveStr::Ascii("earchy"),
        dictgen::InsensitiveStr::Ascii("earcy"),
        dictgen::InsensitiveStr::Ascii("sohima"),
    ],
    values: &[
        &["hierarchy"],
        &["hierarchies"],
        &["hierarchy"],
        &["hierarchies"],
        &["hierarchy"],
        &["hierarchy"],
        &["hiroshima"],
    ],
    range: 4..=7,
};

static WORD_HIP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HIP_CHILDREN),
    value: None,
};

pub static WORD_HIP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ocritical"),
        dictgen::InsensitiveStr::Ascii("opotamus"),
        dictgen::InsensitiveStr::Ascii("otetical"),
        dictgen::InsensitiveStr::Ascii("othetical"),
        dictgen::InsensitiveStr::Ascii("othetically"),
        dictgen::InsensitiveStr::Ascii("sanics"),
        dictgen::InsensitiveStr::Ascii("sterest"),
        dictgen::InsensitiveStr::Ascii("tser"),
        dictgen::InsensitiveStr::Ascii("tsers"),
    ],
    values: &[
        &["hypocritical"],
        &["hippopotamus"],
        &["hypothetical"],
        &["hypothetical"],
        &["hypothetically"],
        &["hispanics"],
        &["hipsters"],
        &["hipster"],
        &["hipsters"],
    ],
    range: 4..=11,
};

static WORD_HIN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HIN_CHILDREN),
    value: None,
};

pub static WORD_HIN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("derance"),
        dictgen::InsensitiveStr::Ascii("derence"),
        dictgen::InsensitiveStr::Ascii("disght"),
        dictgen::InsensitiveStr::Ascii("diusm"),
        dictgen::InsensitiveStr::Ascii("drence"),
        dictgen::InsensitiveStr::Ascii("duisim"),
        dictgen::InsensitiveStr::Ascii("duisum"),
        dictgen::InsensitiveStr::Ascii("dusim"),
        dictgen::InsensitiveStr::Ascii("udism"),
    ],
    values: &[
        &["hindrance"],
        &["hindrance"],
        &["hindsight"],
        &["hinduism"],
        &["hindrance"],
        &["hinduism"],
        &["hinduism"],
        &["hinduism"],
        &["hinduism"],
    ],
    range: 5..=7,
};

static WORD_HIM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HIM_CHILDREN),
    value: None,
};

pub static WORD_HIM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("selv")],
    values: &[&["himself"]],
    range: 4..=4,
};

static WORD_HIL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HIL_CHILDREN),
    value: None,
};

pub static WORD_HIL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ight"),
        dictgen::InsensitiveStr::Ascii("ighted"),
        dictgen::InsensitiveStr::Ascii("ighting"),
        dictgen::InsensitiveStr::Ascii("ights"),
        dictgen::InsensitiveStr::Ascii("larious"),
    ],
    values: &[
        &["highlight"],
        &["highlighted"],
        &["highlighting"],
        &["highlights"],
        &["hilarious"],
    ],
    range: 4..=7,
};

static WORD_HIJ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HIJ_CHILDREN),
    value: None,
};

pub static WORD_HIJ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("kack"),
        dictgen::InsensitiveStr::Ascii("kacked"),
        dictgen::InsensitiveStr::Ascii("kacking"),
        dictgen::InsensitiveStr::Ascii("kacks"),
    ],
    values: &[&["hijack"], &["hijacked"], &["hijacking"], &["hijacks"]],
    range: 4..=7,
};

static WORD_HIH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HIH_CHILDREN),
    value: None,
};

pub static WORD_HIH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("glight"),
        dictgen::InsensitiveStr::Ascii("glights"),
    ],
    values: &[&["highlight"], &["highlights"]],
    range: 6..=7,
};

static WORD_HIG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HIG_CHILDREN),
    value: None,
};

pub static WORD_HIG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eine"),
        dictgen::InsensitiveStr::Ascii("er"),
        dictgen::InsensitiveStr::Ascii("est"),
        dictgen::InsensitiveStr::Ascii("halnder"),
        dictgen::InsensitiveStr::Ascii("he"),
        dictgen::InsensitiveStr::Ascii("hes"),
        dictgen::InsensitiveStr::Ascii("hight"),
        dictgen::InsensitiveStr::Ascii("highted"),
        dictgen::InsensitiveStr::Ascii("highter"),
        dictgen::InsensitiveStr::Ascii("highters"),
        dictgen::InsensitiveStr::Ascii("hights"),
        dictgen::InsensitiveStr::Ascii("hlane"),
        dictgen::InsensitiveStr::Ascii("hligh"),
        dictgen::InsensitiveStr::Ascii("hlighed"),
        dictgen::InsensitiveStr::Ascii("hligher"),
        dictgen::InsensitiveStr::Ascii("hlighers"),
        dictgen::InsensitiveStr::Ascii("hlighing"),
        dictgen::InsensitiveStr::Ascii("hlighs"),
        dictgen::InsensitiveStr::Ascii("hlightin"),
        dictgen::InsensitiveStr::Ascii("hlightning"),
        dictgen::InsensitiveStr::Ascii("hligjt"),
        dictgen::InsensitiveStr::Ascii("hligjted"),
        dictgen::InsensitiveStr::Ascii("hligjtes"),
        dictgen::InsensitiveStr::Ascii("hligjting"),
        dictgen::InsensitiveStr::Ascii("hligjts"),
        dictgen::InsensitiveStr::Ascii("hligt"),
        dictgen::InsensitiveStr::Ascii("hligted"),
        dictgen::InsensitiveStr::Ascii("hligth"),
        dictgen::InsensitiveStr::Ascii("hligthing"),
        dictgen::InsensitiveStr::Ascii("hligting"),
        dictgen::InsensitiveStr::Ascii("hligts"),
        dictgen::InsensitiveStr::Ascii("hloader"),
        dictgen::InsensitiveStr::Ascii("hpander"),
        dictgen::InsensitiveStr::Ascii("hschol"),
        dictgen::InsensitiveStr::Ascii("hscholl"),
        dictgen::InsensitiveStr::Ascii("hschoool"),
        dictgen::InsensitiveStr::Ascii("hshcool"),
        dictgen::InsensitiveStr::Ascii("ht"),
        dictgen::InsensitiveStr::Ascii("hter"),
        dictgen::InsensitiveStr::Ascii("htest"),
        dictgen::InsensitiveStr::Ascii("htlight"),
        dictgen::InsensitiveStr::Ascii("htlighted"),
        dictgen::InsensitiveStr::Ascii("htlighting"),
        dictgen::InsensitiveStr::Ascii("htlights"),
        dictgen::InsensitiveStr::Ascii("hts"),
        dictgen::InsensitiveStr::Ascii("light"),
        dictgen::InsensitiveStr::Ascii("lighted"),
        dictgen::InsensitiveStr::Ascii("lighting"),
        dictgen::InsensitiveStr::Ascii("lights"),
        dictgen::InsensitiveStr::Ascii("ly"),
        dictgen::InsensitiveStr::Ascii("th"),
        dictgen::InsensitiveStr::Ascii("way"),
    ],
    values: &[
        &["hygiene"],
        &["higher"],
        &["highest"],
        &["highlander"],
        &["high", "higher", "highs"],
        &["highest", "highs"],
        &["highlight"],
        &["highlighted"],
        &["highlighter"],
        &["highlighters"],
        &["highlights"],
        &["highlander"],
        &["highlight"],
        &["highlighted"],
        &["highlighter"],
        &["highlighters"],
        &["highlighting"],
        &["highlights"],
        &["highlighting"],
        &["highlighting"],
        &["highlight"],
        &["highlighted"],
        &["highlights"],
        &["highlighting"],
        &["highlights"],
        &["highlight"],
        &["highlighted"],
        &["highlight"],
        &["highlighting"],
        &["highlighting"],
        &["highlights"],
        &["highlander"],
        &["highlander"],
        &["highschool"],
        &["highschool"],
        &["highschool"],
        &["highschool"],
        &["height", "high"],
        &["higher"],
        &["highest"],
        &["highlight"],
        &["highlighted"],
        &["highlighting"],
        &["highlights"],
        &["height", "heights"],
        &["highlight"],
        &["highlighted"],
        &["highlighting"],
        &["highlights"],
        &["highly"],
        &["height"],
        &["highway"],
    ],
    range: 2..=10,
};

static WORD_HIE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HIE_CHILDREN),
    value: None,
};

pub static WORD_HIE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("archies"),
        dictgen::InsensitiveStr::Ascii("archy"),
        dictgen::InsensitiveStr::Ascii("ght"),
        dictgen::InsensitiveStr::Ascii("ghtened"),
        dictgen::InsensitiveStr::Ascii("ghts"),
        dictgen::InsensitiveStr::Ascii("na"),
        dictgen::InsensitiveStr::Ascii("nous"),
        dictgen::InsensitiveStr::Ascii("rachical"),
        dictgen::InsensitiveStr::Ascii("rachies"),
        dictgen::InsensitiveStr::Ascii("rachries"),
        dictgen::InsensitiveStr::Ascii("rachry"),
        dictgen::InsensitiveStr::Ascii("rachy"),
        dictgen::InsensitiveStr::Ascii("rachycal"),
        dictgen::InsensitiveStr::Ascii("rarachical"),
        dictgen::InsensitiveStr::Ascii("rarachy"),
        dictgen::InsensitiveStr::Ascii("rarchichal"),
        dictgen::InsensitiveStr::Ascii("rarchichally"),
        dictgen::InsensitiveStr::Ascii("rarchie"),
        dictgen::InsensitiveStr::Ascii("rarcical"),
        dictgen::InsensitiveStr::Ascii("rarcy"),
        dictgen::InsensitiveStr::Ascii("rarhcical"),
        dictgen::InsensitiveStr::Ascii("rarhcically"),
        dictgen::InsensitiveStr::Ascii("rarhcies"),
        dictgen::InsensitiveStr::Ascii("rarhcy"),
        dictgen::InsensitiveStr::Ascii("rchy"),
        dictgen::InsensitiveStr::Ascii("roglph"),
        dictgen::InsensitiveStr::Ascii("roglphs"),
        dictgen::InsensitiveStr::Ascii("sman"),
        dictgen::InsensitiveStr::Ascii("tus"),
    ],
    values: &[
        &["hierarchies"],
        &["hierarchy"],
        &["height"],
        &["heightened"],
        &["heights"],
        &["hyena"],
        &["heinous"],
        &["hierarchical"],
        &["hierarchies"],
        &["hierarchies"],
        &["hierarchy"],
        &["hierarchy"],
        &["hierarchical"],
        &["hierarchical"],
        &["hierarchy"],
        &["hierarchical"],
        &["hierarchically"],
        &["hierarchy"],
        &["hierarchical"],
        &["hierarchy"],
        &["hierarchical"],
        &["hierarchically"],
        &["hierarchies"],
        &["hierarchy"],
        &["hierarchy"],
        &["hieroglyph"],
        &["hieroglyphs"],
        &["heisman"],
        &["hiatus"],
    ],
    range: 2..=12,
};

static WORD_HID_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HID_CHILDREN),
    value: None,
};

pub static WORD_HID_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("dden"),
        dictgen::InsensitiveStr::Ascii("ded"),
        dictgen::InsensitiveStr::Ascii("din"),
        dictgen::InsensitiveStr::Ascii("ding"),
        dictgen::InsensitiveStr::Ascii("een"),
        dictgen::InsensitiveStr::Ascii("en"),
    ],
    values: &[
        &["hidden"],
        &["hidden"],
        &["hidden", "hiding"],
        &["hiding", "hidden"],
        &["hidden"],
        &["hidden"],
    ],
    range: 2..=4,
};

static WORD_HIA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HIA_CHILDREN),
    value: None,
};

pub static WORD_HIA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("rchical"),
        dictgen::InsensitiveStr::Ascii("rchically"),
        dictgen::InsensitiveStr::Ascii("rchy"),
    ],
    values: &[&["hierarchical"], &["hierarchically"], &["hierarchy"]],
    range: 4..=9,
};

static WORD_HH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HH_CHILDREN),
    value: None,
};

pub static WORD_HH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ader"),
        dictgen::InsensitiveStr::Ascii("ttp"),
    ],
    values: &[&["header"], &["http"]],
    range: 3..=4,
};

static WORD_HG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HG_CHILDREN),
    value: None,
};

pub static WORD_HG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("e")],
    values: &[&["he"]],
    range: 1..=1,
};

static WORD_HE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_HE_CHILDREN),
    value: None,
};

static WORD_HE_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_HEA_NODE),
    None,
    None,
    Some(&WORD_HED_NODE),
    None,
    Some(&WORD_HEF_NODE),
    Some(&WORD_HEG_NODE),
    None,
    Some(&WORD_HEI_NODE),
    None,
    None,
    Some(&WORD_HEL_NODE),
    Some(&WORD_HEM_NODE),
    Some(&WORD_HEN_NODE),
    Some(&WORD_HEO_NODE),
    Some(&WORD_HEP_NODE),
    None,
    Some(&WORD_HER_NODE),
    Some(&WORD_HES_NODE),
    Some(&WORD_HET_NODE),
    Some(&WORD_HEU_NODE),
    Some(&WORD_HEV_NODE),
    None,
    Some(&WORD_HEX_NODE),
    None,
    None,
];

static WORD_HEX_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HEX_CHILDREN),
    value: None,
};

pub static WORD_HEX_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ademical"),
        dictgen::InsensitiveStr::Ascii("decimal"),
        dictgen::InsensitiveStr::Ascii("gaon"),
        dictgen::InsensitiveStr::Ascii("gaonal"),
        dictgen::InsensitiveStr::Ascii("gaons"),
        dictgen::InsensitiveStr::Ascii("idecimal"),
        dictgen::InsensitiveStr::Ascii("idecimals"),
    ],
    values: &[
        &["hexadecimal"],
        &["hexadecimal"],
        &["hexagon"],
        &["hexagonal"],
        &["hexagons"],
        &["hexadecimal"],
        &["hexadecimals"],
    ],
    range: 4..=9,
};

static WORD_HEV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HEV_CHILDREN),
    value: None,
};

pub static WORD_HEV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eanly"),
        dictgen::InsensitiveStr::Ascii("y"),
    ],
    values: &[&["heavenly"], &["heavy"]],
    range: 1..=5,
};

static WORD_HEU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HEU_CHILDREN),
    value: None,
};

pub static WORD_HEU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ristc"),
        dictgen::InsensitiveStr::Ascii("ristcs"),
        dictgen::InsensitiveStr::Ascii("rsitics"),
        dictgen::InsensitiveStr::Ascii("sitic"),
    ],
    values: &[
        &["heuristic"],
        &["heuristics"],
        &["heuristics"],
        &["heuristic"],
    ],
    range: 5..=7,
};

static WORD_HET_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HET_CHILDREN),
    value: None,
};

pub static WORD_HET_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eresexual"),
        dictgen::InsensitiveStr::Ascii("erosexal"),
        dictgen::InsensitiveStr::Ascii("erosexuella"),
        dictgen::InsensitiveStr::Ascii("reosexual"),
        dictgen::InsensitiveStr::Ascii("rogeneous"),
        dictgen::InsensitiveStr::Ascii("rogenous"),
    ],
    values: &[
        &["heterosexual"],
        &["heterosexual"],
        &["heterosexual"],
        &["heterosexual"],
        &["heterogeneous"],
        &["heterogenous", "heterogeneous"],
    ],
    range: 8..=11,
};

static WORD_HES_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HES_CHILDREN),
    value: None,
};

pub static WORD_HES_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("iate"),
        dictgen::InsensitiveStr::Ascii("iman"),
        dictgen::InsensitiveStr::Ascii("istant"),
        dictgen::InsensitiveStr::Ascii("istate"),
        dictgen::InsensitiveStr::Ascii("istated"),
        dictgen::InsensitiveStr::Ascii("istates"),
        dictgen::InsensitiveStr::Ascii("istating"),
        dictgen::InsensitiveStr::Ascii("istation"),
        dictgen::InsensitiveStr::Ascii("istations"),
        dictgen::InsensitiveStr::Ascii("itatin"),
        dictgen::InsensitiveStr::Ascii("itstion"),
        dictgen::InsensitiveStr::Ascii("tiant"),
        dictgen::InsensitiveStr::Ascii("tiate"),
        dictgen::InsensitiveStr::Ascii("tiation"),
    ],
    values: &[
        &["these"],
        &["hesitate"],
        &["heisman"],
        &["hesitant"],
        &["hesitate"],
        &["hesitated"],
        &["hesitates"],
        &["hesitating"],
        &["hesitation"],
        &["hesitations"],
        &["hesitation"],
        &["hesitation"],
        &["hesitant"],
        &["hesitate"],
        &["hesitation"],
    ],
    range: 1..=9,
};

static WORD_HER_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HER_CHILDREN),
    value: None,
};

pub static WORD_HER_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ad"),
        dictgen::InsensitiveStr::Ascii("archy"),
        dictgen::InsensitiveStr::Ascii("at"),
        dictgen::InsensitiveStr::Ascii("athstone"),
        dictgen::InsensitiveStr::Ascii("atige"),
        dictgen::InsensitiveStr::Ascii("clues"),
        dictgen::InsensitiveStr::Ascii("culase"),
        dictgen::InsensitiveStr::Ascii("culeans"),
        dictgen::InsensitiveStr::Ascii("culeas"),
        dictgen::InsensitiveStr::Ascii("culeasy"),
        dictgen::InsensitiveStr::Ascii("culeees"),
        dictgen::InsensitiveStr::Ascii("culees"),
        dictgen::InsensitiveStr::Ascii("culeus"),
        dictgen::InsensitiveStr::Ascii("ee"),
        dictgen::InsensitiveStr::Ascii("erosexual"),
        dictgen::InsensitiveStr::Ascii("etosexual"),
        dictgen::InsensitiveStr::Ascii("iarchy"),
        dictgen::InsensitiveStr::Ascii("idity"),
        dictgen::InsensitiveStr::Ascii("iocs"),
        dictgen::InsensitiveStr::Ascii("ione"),
        dictgen::InsensitiveStr::Ascii("ocis"),
        dictgen::InsensitiveStr::Ascii("oe"),
        dictgen::InsensitiveStr::Ascii("oicas"),
        dictgen::InsensitiveStr::Ascii("oices"),
        dictgen::InsensitiveStr::Ascii("oicos"),
        dictgen::InsensitiveStr::Ascii("oicus"),
        dictgen::InsensitiveStr::Ascii("onie"),
        dictgen::InsensitiveStr::Ascii("os"),
        dictgen::InsensitiveStr::Ascii("selv"),
        dictgen::InsensitiveStr::Ascii("tiage"),
        dictgen::InsensitiveStr::Ascii("tically"),
        dictgen::InsensitiveStr::Ascii("tzs"),
        dictgen::InsensitiveStr::Ascii("ucles"),
    ],
    values: &[
        &["heard", "hera"],
        &["hierarchy"],
        &["heart"],
        &["hearthstone"],
        &["heritage"],
        &["hercules"],
        &["hercules"],
        &["hercules"],
        &["hercules"],
        &["hercules"],
        &["hercules"],
        &["hercules"],
        &["hercules"],
        &["here"],
        &["heterosexual"],
        &["heterosexual"],
        &["hierarchy"],
        &["heredity"],
        &["heroics"],
        &["heroine"],
        &["heroics"],
        &["hero"],
        &["heroics"],
        &["heroics"],
        &["heroics"],
        &["heroics"],
        &["heroine"],
        &["heroes"],
        &["herself"],
        &["heritage"],
        &["hectically"],
        &["hertz"],
        &["hercules"],
    ],
    range: 2..=9,
};

static WORD_HEP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HEP_CHILDREN),
    value: None,
};

pub static WORD_HEP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ler")],
    values: &[&["helper"]],
    range: 3..=3,
};

static WORD_HEO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HEO_CHILDREN),
    value: None,
};

pub static WORD_HEO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("rics"),
        dictgen::InsensitiveStr::Ascii("rine"),
    ],
    values: &[&["heroics"], &["heroine"]],
    range: 4..=4,
};

static WORD_HEN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HEN_CHILDREN),
    value: None,
};

pub static WORD_HEN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("c"),
        dictgen::InsensitiveStr::Ascii("derence"),
        dictgen::InsensitiveStr::Ascii("dler"),
        dictgen::InsensitiveStr::Ascii("ious"),
        dictgen::InsensitiveStr::Ascii("se"),
    ],
    values: &[
        &["hence"],
        &["hindrance"],
        &["handler"],
        &["heinous"],
        &["hence"],
    ],
    range: 1..=7,
};

static WORD_HEM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HEM_CHILDREN),
    value: None,
};

pub static WORD_HEM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ingwary"),
        dictgen::InsensitiveStr::Ascii("ingwavy"),
        dictgen::InsensitiveStr::Ascii("ipshere"),
        dictgen::InsensitiveStr::Ascii("ipsheres"),
        dictgen::InsensitiveStr::Ascii("ishpere"),
        dictgen::InsensitiveStr::Ascii("ishperes"),
        dictgen::InsensitiveStr::Ascii("lets"),
        dictgen::InsensitiveStr::Ascii("morhage"),
        dictgen::InsensitiveStr::Ascii("morhaged"),
        dictgen::InsensitiveStr::Ascii("morhages"),
        dictgen::InsensitiveStr::Ascii("morhagic"),
        dictgen::InsensitiveStr::Ascii("morhaging"),
        dictgen::InsensitiveStr::Ascii("orage"),
        dictgen::InsensitiveStr::Ascii("oraged"),
        dictgen::InsensitiveStr::Ascii("orages"),
        dictgen::InsensitiveStr::Ascii("oragic"),
        dictgen::InsensitiveStr::Ascii("oraging"),
        dictgen::InsensitiveStr::Ascii("pishere"),
    ],
    values: &[
        &["hemingway"],
        &["hemingway"],
        &["hemisphere"],
        &["hemisphere", "hemispheres"],
        &["hemisphere"],
        &["hemisphere", "hemispheres"],
        &["helmets"],
        &["hemorrhage"],
        &["hemorrhaged"],
        &["hemorrhages"],
        &["haemorrhagic", "hemorrhagic"],
        &["hemorrhaging"],
        &["hemorrhage"],
        &["hemorrhaged"],
        &["hemorrhages"],
        &["haemorrhagic", "hemorrhagic"],
        &["hemorrhaging"],
        &["hemisphere"],
    ],
    range: 4..=9,
};

static WORD_HEL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HEL_CHILDREN),
    value: Some(&["help", "hell", "heal"]),
};

pub static WORD_HEL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("athcare"),
        dictgen::InsensitiveStr::Ascii("emts"),
        dictgen::InsensitiveStr::Ascii("erps"),
        dictgen::InsensitiveStr::Ascii("icopers"),
        dictgen::InsensitiveStr::Ascii("icopteros"),
        dictgen::InsensitiveStr::Ascii("icoptor"),
        dictgen::InsensitiveStr::Ascii("icoptors"),
        dictgen::InsensitiveStr::Ascii("icotper"),
        dictgen::InsensitiveStr::Ascii("icotpers"),
        dictgen::InsensitiveStr::Ascii("icpoter"),
        dictgen::InsensitiveStr::Ascii("icpoters"),
        dictgen::InsensitiveStr::Ascii("ictoper"),
        dictgen::InsensitiveStr::Ascii("ictopers"),
        dictgen::InsensitiveStr::Ascii("ikopter"),
        dictgen::InsensitiveStr::Ascii("ikopters"),
        dictgen::InsensitiveStr::Ascii("lfie"),
        dictgen::InsensitiveStr::Ascii("lifre"),
        dictgen::InsensitiveStr::Ascii("low"),
        dictgen::InsensitiveStr::Ascii("lucination"),
        dictgen::InsensitiveStr::Ascii("lucinations"),
        dictgen::InsensitiveStr::Ascii("luvva"),
        dictgen::InsensitiveStr::Ascii("lvua"),
        dictgen::InsensitiveStr::Ascii("ment"),
        dictgen::InsensitiveStr::Ascii("o"),
        dictgen::InsensitiveStr::Ascii("oer"),
        dictgen::InsensitiveStr::Ascii("oers"),
        dictgen::InsensitiveStr::Ascii("pe"),
        dictgen::InsensitiveStr::Ascii("pfull"),
        dictgen::InsensitiveStr::Ascii("pfuly"),
        dictgen::InsensitiveStr::Ascii("pped"),
        dictgen::InsensitiveStr::Ascii("pying"),
    ],
    values: &[
        &["healthcare"],
        &["helmets"],
        &["helpers"],
        &["helicopters"],
        &["helicopters"],
        &["helicopter"],
        &["helicopters"],
        &["helicopters"],
        &["helicopters"],
        &["helicopter"],
        &["helicopters"],
        &["helicopters"],
        &["helicopters"],
        &["helicopter"],
        &["helicopters"],
        &["hellfire"],
        &["hellfire"],
        &["hello"],
        &["hallucination"],
        &["hallucinations"],
        &["helluva"],
        &["helluva"],
        &["helmet"],
        &["hello"],
        &["helper"],
        &["helpers"],
        &["helper"],
        &["helpful"],
        &["helpfully"],
        &["helped"],
        &["helping"],
    ],
    range: 1..=11,
};

static WORD_HEI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HEI_CHILDREN),
    value: None,
};

pub static WORD_HEI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("delburg"),
        dictgen::InsensitiveStr::Ascii("gest"),
        dictgen::InsensitiveStr::Ascii("gh"),
        dictgen::InsensitiveStr::Ascii("gher"),
        dictgen::InsensitiveStr::Ascii("ghest"),
        dictgen::InsensitiveStr::Ascii("ghit"),
        dictgen::InsensitiveStr::Ascii("ghted"),
        dictgen::InsensitiveStr::Ascii("ghteen"),
        dictgen::InsensitiveStr::Ascii("ghtend"),
        dictgen::InsensitiveStr::Ascii("gt"),
        dictgen::InsensitiveStr::Ascii("gth"),
        dictgen::InsensitiveStr::Ascii("gthened"),
        dictgen::InsensitiveStr::Ascii("gths"),
        dictgen::InsensitiveStr::Ascii("rachies"),
        dictgen::InsensitiveStr::Ascii("rachy"),
        dictgen::InsensitiveStr::Ascii("rarchic"),
        dictgen::InsensitiveStr::Ascii("rarchical"),
        dictgen::InsensitiveStr::Ascii("rarchically"),
        dictgen::InsensitiveStr::Ascii("rarchies"),
        dictgen::InsensitiveStr::Ascii("rarchy"),
        dictgen::InsensitiveStr::Ascii("roglyphics"),
        dictgen::InsensitiveStr::Ascii("stant"),
        dictgen::InsensitiveStr::Ascii("state"),
        dictgen::InsensitiveStr::Ascii("station"),
    ],
    values: &[
        &["heidelberg"],
        &["highest"],
        &["height", "high"],
        &["higher"],
        &["heights", "highest"],
        &["height"],
        &["heightened"],
        &["eighteen"],
        &["heightened"],
        &["height"],
        &["height"],
        &["heightened"],
        &["heights"],
        &["hierarchies"],
        &["hierarchy"],
        &["hierarchic"],
        &["hierarchical"],
        &["hierarchically"],
        &["hierarchies"],
        &["hierarchy"],
        &["hieroglyphics"],
        &["hesitant"],
        &["hesitate"],
        &["hesitation"],
    ],
    range: 2..=11,
};

static WORD_HEG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HEG_CHILDREN),
    value: None,
};

pub static WORD_HEG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("dehog")],
    values: &[&["hedgehog"]],
    range: 5..=5,
};

static WORD_HEF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HEF_CHILDREN),
    value: None,
};

pub static WORD_HEF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("er")],
    values: &[&["heifer"]],
    range: 2..=2,
};

static WORD_HED_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HED_CHILDREN),
    value: None,
};

pub static WORD_HED_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aer"),
        dictgen::InsensitiveStr::Ascii("aers"),
        dictgen::InsensitiveStr::Ascii("eghog"),
        dictgen::InsensitiveStr::Ascii("er"),
        dictgen::InsensitiveStr::Ascii("ers"),
        dictgen::InsensitiveStr::Ascii("gehodge"),
        dictgen::InsensitiveStr::Ascii("gehoog"),
        dictgen::InsensitiveStr::Ascii("gehorg"),
    ],
    values: &[
        &["header"],
        &["headers"],
        &["hedgehog"],
        &["header"],
        &["headers"],
        &["hedgehog"],
        &["hedgehog"],
        &["hedgehog"],
    ],
    range: 2..=7,
};

static WORD_HEA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_HEA_CHILDREN),
    value: None,
};

static WORD_HEA_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    None,
    Some(&WORD_HEAD_NODE),
    Some(&WORD_HEAE_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_HEAL_NODE),
    None,
    None,
    None,
    Some(&WORD_HEAP_NODE),
    None,
    Some(&WORD_HEAR_NODE),
    Some(&WORD_HEAS_NODE),
    Some(&WORD_HEAT_NODE),
    None,
    Some(&WORD_HEAV_NODE),
    None,
    None,
    None,
    None,
];

static WORD_HEAV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HEAV_CHILDREN),
    value: None,
};

pub static WORD_HEAV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eny"),
        dictgen::InsensitiveStr::Ascii("iliy"),
        dictgen::InsensitiveStr::Ascii("illy"),
        dictgen::InsensitiveStr::Ascii("iweight"),
        dictgen::InsensitiveStr::Ascii("nely"),
        dictgen::InsensitiveStr::Ascii("yweght"),
        dictgen::InsensitiveStr::Ascii("yweigt"),
        dictgen::InsensitiveStr::Ascii("yweigth"),
        dictgen::InsensitiveStr::Ascii("ywieght"),
        dictgen::InsensitiveStr::Ascii("ywieghts"),
    ],
    values: &[
        &["heavenly"],
        &["heavily"],
        &["heavily"],
        &["heavyweight"],
        &["heavenly"],
        &["heavyweight"],
        &["heavyweight"],
        &["heavyweight"],
        &["heavyweight"],
        &["heavyweight"],
    ],
    range: 3..=8,
};

static WORD_HEAT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HEAT_CHILDREN),
    value: None,
};

pub static WORD_HEAT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("hern"),
        dictgen::InsensitiveStr::Ascii("hy"),
        dictgen::InsensitiveStr::Ascii("lhcare"),
        dictgen::InsensitiveStr::Ascii("skin"),
    ],
    values: &[&["heathen"], &["healthy"], &["healthcare"], &["heatsink"]],
    range: 2..=6,
};

static WORD_HEAS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HEAS_CHILDREN),
    value: None,
};

pub static WORD_HEAS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("tink")],
    values: &[&["heatsink"]],
    range: 4..=4,
};

static WORD_HEAR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HEAR_CHILDREN),
    value: None,
};

pub static WORD_HEAR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("beat"),
        dictgen::InsensitiveStr::Ascii("der"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("htstone"),
        dictgen::InsensitiveStr::Ascii("tbeart"),
        dictgen::InsensitiveStr::Ascii("tbeast"),
        dictgen::InsensitiveStr::Ascii("tborken"),
        dictgen::InsensitiveStr::Ascii("tborne"),
        dictgen::InsensitiveStr::Ascii("tbrake"),
        dictgen::InsensitiveStr::Ascii("tbraker"),
        dictgen::InsensitiveStr::Ascii("tbrakes"),
        dictgen::InsensitiveStr::Ascii("thsone"),
        dictgen::InsensitiveStr::Ascii("tsthone"),
    ],
    values: &[
        &["heartbeat"],
        &["header"],
        &["heard", "header"],
        &["hearthstone"],
        &["heartbeat"],
        &["heartbeat"],
        &["heartbroken"],
        &["heartbroken"],
        &["heartbreak"],
        &["heartbreak"],
        &["heartbreak"],
        &["hearthstone"],
        &["hearthstone"],
    ],
    range: 2..=7,
};

static WORD_HEAP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HEAP_CHILDREN),
    value: None,
};

pub static WORD_HEAP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("dhone"),
        dictgen::InsensitiveStr::Ascii("dhones"),
    ],
    values: &[&["headphone"], &["headphones"]],
    range: 5..=6,
};

static WORD_HEAL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HEAL_CHILDREN),
    value: None,
};

pub static WORD_HEAL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ither"),
        dictgen::InsensitiveStr::Ascii("tchare"),
        dictgen::InsensitiveStr::Ascii("theast"),
        dictgen::InsensitiveStr::Ascii("their"),
        dictgen::InsensitiveStr::Ascii("thercare"),
        dictgen::InsensitiveStr::Ascii("thiet"),
        dictgen::InsensitiveStr::Ascii("thire"),
        dictgen::InsensitiveStr::Ascii("thit"),
        dictgen::InsensitiveStr::Ascii("thyest"),
        dictgen::InsensitiveStr::Ascii("ty"),
    ],
    values: &[
        &["healthier"],
        &["healthcare"],
        &["healthiest"],
        &["healthier"],
        &["healthcare"],
        &["healthiest"],
        &["healthier"],
        &["healthiest"],
        &["healthiest"],
        &["healthy"],
    ],
    range: 2..=8,
};

static WORD_HEAE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HEAE_CHILDREN),
    value: None,
};

pub static WORD_HEAE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("r")],
    values: &[&["header"]],
    range: 1..=1,
};

static WORD_HEAD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HEAD_CHILDREN),
    value: None,
};

pub static WORD_HEAD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("achs"),
        dictgen::InsensitiveStr::Ascii("ahces"),
        dictgen::InsensitiveStr::Ascii("der"),
        dictgen::InsensitiveStr::Ascii("ders"),
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("err"),
        dictgen::InsensitiveStr::Ascii("errs"),
        dictgen::InsensitiveStr::Ascii("est"),
        dictgen::InsensitiveStr::Ascii("ests"),
        dictgen::InsensitiveStr::Ascii("hpone"),
        dictgen::InsensitiveStr::Ascii("hpones"),
        dictgen::InsensitiveStr::Ascii("hsot"),
        dictgen::InsensitiveStr::Ascii("le"),
        dictgen::InsensitiveStr::Ascii("ong"),
        dictgen::InsensitiveStr::Ascii("phoens"),
        dictgen::InsensitiveStr::Ascii("qaurters"),
        dictgen::InsensitiveStr::Ascii("quarer"),
        dictgen::InsensitiveStr::Ascii("quartes"),
        dictgen::InsensitiveStr::Ascii("quater"),
        dictgen::InsensitiveStr::Ascii("quatered"),
        dictgen::InsensitiveStr::Ascii("quaters"),
        dictgen::InsensitiveStr::Ascii("rom"),
        dictgen::InsensitiveStr::Ascii("seat"),
        dictgen::InsensitiveStr::Ascii("ses"),
        dictgen::InsensitiveStr::Ascii("shoot"),
        dictgen::InsensitiveStr::Ascii("shoots"),
    ],
    values: &[
        &["headaches"],
        &["headaches"],
        &["header"],
        &["headers"],
        &["head", "header"],
        &["header"],
        &["headers"],
        &["headset"],
        &["headsets"],
        &["headphone"],
        &["headphones"],
        &["headshot"],
        &["handle"],
        &["heading"],
        &["headphones"],
        &["headquarters"],
        &["headquarter"],
        &["headquarters"],
        &["headquarter"],
        &["headquartered"],
        &["headquarters"],
        &["headroom", "bedroom"],
        &["headset"],
        &["headsets"],
        &["headshot"],
        &["headshot"],
    ],
    range: 1..=8,
};

static WORD_HD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HD_CHILDREN),
    value: None,
};

pub static WORD_HD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("a"),
        dictgen::InsensitiveStr::Ascii("insight"),
    ],
    values: &[&["had"], &["hindsight"]],
    range: 1..=7,
};

static WORD_HA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_HA_CHILDREN),
    value: None,
};

static WORD_HA_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_HAA_NODE),
    Some(&WORD_HAB_NODE),
    Some(&WORD_HAC_NODE),
    Some(&WORD_HAD_NODE),
    Some(&WORD_HAE_NODE),
    Some(&WORD_HAF_NODE),
    Some(&WORD_HAG_NODE),
    Some(&WORD_HAH_NODE),
    Some(&WORD_HAI_NODE),
    None,
    None,
    Some(&WORD_HAL_NODE),
    Some(&WORD_HAM_NODE),
    Some(&WORD_HAN_NODE),
    Some(&WORD_HAO_NODE),
    Some(&WORD_HAP_NODE),
    None,
    Some(&WORD_HAR_NODE),
    Some(&WORD_HAS_NODE),
    Some(&WORD_HAT_NODE),
    Some(&WORD_HAU_NODE),
    Some(&WORD_HAV_NODE),
    None,
    Some(&WORD_HAX_NODE),
    Some(&WORD_HAY_NODE),
    Some(&WORD_HAZ_NODE),
];

static WORD_HAZ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HAZ_CHILDREN),
    value: None,
};

pub static WORD_HAZ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("zle")],
    values: &[&["hassle"]],
    range: 3..=3,
};

static WORD_HAY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HAY_CHILDREN),
    value: None,
};

pub static WORD_HAY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("nus")],
    values: &[&["heinous"]],
    range: 3..=3,
};

static WORD_HAX_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HAX_CHILDREN),
    value: Some(&["hex"]),
};

pub static WORD_HAX_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[],
    values: &[],
    range: 0..=0,
};

static WORD_HAV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HAV_CHILDREN),
    value: Some(&["have", "half"]),
};

pub static WORD_HAV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("a"),
        dictgen::InsensitiveStr::Ascii("ea"),
        dictgen::InsensitiveStr::Ascii("ee"),
        dictgen::InsensitiveStr::Ascii("eing"),
        dictgen::InsensitiveStr::Ascii("ersting"),
        dictgen::InsensitiveStr::Ascii("ew"),
        dictgen::InsensitiveStr::Ascii("iest"),
        dictgen::InsensitiveStr::Ascii("ind"),
        dictgen::InsensitiveStr::Ascii("ve"),
    ],
    values: &[
        &["have"],
        &["have"],
        &["have"],
        &["having"],
        &["harvesting"],
        &["have"],
        &["heaviest"],
        &["having"],
        &["have"],
    ],
    range: 1..=7,
};

static WORD_HAU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HAU_CHILDREN),
    value: None,
};

pub static WORD_HAU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ntig"),
        dictgen::InsensitiveStr::Ascii("ty"),
    ],
    values: &[&["haunting"], &["haughty"]],
    range: 2..=4,
};

static WORD_HAT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HAT_CHILDREN),
    value: None,
};

pub static WORD_HAT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("chig"),
        dictgen::InsensitiveStr::Ascii("chign"),
        dictgen::InsensitiveStr::Ascii("esink"),
        dictgen::InsensitiveStr::Ascii("hcing"),
        dictgen::InsensitiveStr::Ascii("ian"),
    ],
    values: &[
        &["hatching"],
        &["hatching"],
        &["heatsink"],
        &["hatching"],
        &["haitian"],
    ],
    range: 3..=5,
};

static WORD_HAS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HAS_CHILDREN),
    value: None,
};

pub static WORD_HAS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("hi"),
        dictgen::InsensitiveStr::Ascii("hs"),
        dictgen::InsensitiveStr::Ascii("hses"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("k"),
        dictgen::InsensitiveStr::Ascii("s"),
        dictgen::InsensitiveStr::Ascii("table"),
        dictgen::InsensitiveStr::Ascii("tables"),
    ],
    values: &[
        &["hashes"],
        &["hash"],
        &["hashes"],
        &["hashes"],
        &["hashing"],
        &["hash"],
        &["hash"],
        &["hashtable"],
        &["hashtables"],
    ],
    range: 1..=6,
};

static WORD_HAR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HAR_CHILDREN),
    value: None,
};

pub static WORD_HAR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ased"),
        dictgen::InsensitiveStr::Ascii("ases"),
        dictgen::InsensitiveStr::Ascii("asment"),
        dictgen::InsensitiveStr::Ascii("asments"),
        dictgen::InsensitiveStr::Ascii("assement"),
        dictgen::InsensitiveStr::Ascii("code"),
        dictgen::InsensitiveStr::Ascii("coded"),
        dictgen::InsensitiveStr::Ascii("codes"),
        dictgen::InsensitiveStr::Ascii("coding"),
        dictgen::InsensitiveStr::Ascii("dare"),
        dictgen::InsensitiveStr::Ascii("dend"),
        dictgen::InsensitiveStr::Ascii("denend"),
        dictgen::InsensitiveStr::Ascii("docde"),
        dictgen::InsensitiveStr::Ascii("dward"),
        dictgen::InsensitiveStr::Ascii("dwdare"),
        dictgen::InsensitiveStr::Ascii("dwirted"),
        dictgen::InsensitiveStr::Ascii("dwod"),
        dictgen::InsensitiveStr::Ascii("dwoord"),
        dictgen::InsensitiveStr::Ascii("ge"),
        dictgen::InsensitiveStr::Ascii("icut"),
        dictgen::InsensitiveStr::Ascii("istyle"),
        dictgen::InsensitiveStr::Ascii("ldine"),
        dictgen::InsensitiveStr::Ascii("moniacs"),
        dictgen::InsensitiveStr::Ascii("monisch"),
        dictgen::InsensitiveStr::Ascii("rang"),
        dictgen::InsensitiveStr::Ascii("range"),
        dictgen::InsensitiveStr::Ascii("ranged"),
        dictgen::InsensitiveStr::Ascii("ranger"),
        dictgen::InsensitiveStr::Ascii("ranges"),
        dictgen::InsensitiveStr::Ascii("ranging"),
        dictgen::InsensitiveStr::Ascii("ras"),
        dictgen::InsensitiveStr::Ascii("rased"),
        dictgen::InsensitiveStr::Ascii("rases"),
        dictgen::InsensitiveStr::Ascii("rasing"),
        dictgen::InsensitiveStr::Ascii("rasment"),
        dictgen::InsensitiveStr::Ascii("rasments"),
        dictgen::InsensitiveStr::Ascii("rass"),
        dictgen::InsensitiveStr::Ascii("rassed"),
        dictgen::InsensitiveStr::Ascii("rasses"),
        dictgen::InsensitiveStr::Ascii("rassing"),
        dictgen::InsensitiveStr::Ascii("rassment"),
        dictgen::InsensitiveStr::Ascii("rassments"),
        dictgen::InsensitiveStr::Ascii("th"),
        dictgen::InsensitiveStr::Ascii("vasting"),
        dictgen::InsensitiveStr::Ascii("vestgain"),
        dictgen::InsensitiveStr::Ascii("ware"),
        dictgen::InsensitiveStr::Ascii("wdare"),
    ],
    values: &[
        &["harassed"],
        &["harasses"],
        &["harassment"],
        &["harassments"],
        &["harassment"],
        &["hardcode", "charcode"],
        &["hardcoded"],
        &["hardcodes", "charcodes"],
        &["hardcoding"],
        &["hardware"],
        &["hardened"],
        &["hardened"],
        &["hardcode"],
        &["hardware"],
        &["hardware"],
        &["hardwired"],
        &["hardwood"],
        &["hardwood"],
        &["charge"],
        &["haircut"],
        &["hairstyle"],
        &["hardline"],
        &["harmonic"],
        &["harmonic"],
        &["harangue"],
        &["arrange", "harangue"],
        &["arranged", "harangued"],
        &["arranger", "haranguer"],
        &["arranges", "harangues"],
        &["arranging", "haranguing"],
        &["harass"],
        &["harassed"],
        &["harasses"],
        &["harassing"],
        &["harassment"],
        &["harassments"],
        &["harass"],
        &["harassed"],
        &["harassed"],
        &["harassing"],
        &["harassment"],
        &["harassments"],
        &["hearth"],
        &["harvesting"],
        &["harvesting"],
        &["hardware"],
        &["hardware"],
    ],
    range: 2..=9,
};

static WORD_HAP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HAP_CHILDREN),
    value: None,
};

pub static WORD_HAP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("en"),
        dictgen::InsensitiveStr::Ascii("end"),
        dictgen::InsensitiveStr::Ascii("ends"),
        dictgen::InsensitiveStr::Ascii("ened"),
        dictgen::InsensitiveStr::Ascii("ening"),
        dictgen::InsensitiveStr::Ascii("enn"),
        dictgen::InsensitiveStr::Ascii("enned"),
        dictgen::InsensitiveStr::Ascii("enning"),
        dictgen::InsensitiveStr::Ascii("enns"),
        dictgen::InsensitiveStr::Ascii("ens"),
        dictgen::InsensitiveStr::Ascii("mshire"),
        dictgen::InsensitiveStr::Ascii("paned"),
        dictgen::InsensitiveStr::Ascii("pend"),
        dictgen::InsensitiveStr::Ascii("pended"),
        dictgen::InsensitiveStr::Ascii("pends"),
        dictgen::InsensitiveStr::Ascii("penend"),
        dictgen::InsensitiveStr::Ascii("penes"),
        dictgen::InsensitiveStr::Ascii("penned"),
        dictgen::InsensitiveStr::Ascii("penning"),
        dictgen::InsensitiveStr::Ascii("pennings"),
        dictgen::InsensitiveStr::Ascii("penns"),
        dictgen::InsensitiveStr::Ascii("pilly"),
        dictgen::InsensitiveStr::Ascii("ping"),
        dictgen::InsensitiveStr::Ascii("pliy"),
        dictgen::InsensitiveStr::Ascii("pne"),
        dictgen::InsensitiveStr::Ascii("pnes"),
        dictgen::InsensitiveStr::Ascii("ppen"),
        dictgen::InsensitiveStr::Ascii("ppened"),
        dictgen::InsensitiveStr::Ascii("ppening"),
        dictgen::InsensitiveStr::Ascii("ppenings"),
        dictgen::InsensitiveStr::Ascii("ppens"),
    ],
    values: &[
        &["happen"],
        &["happened"],
        &["happens"],
        &["happened"],
        &["happening"],
        &["happen"],
        &["happened"],
        &["happening"],
        &["happens"],
        &["happens"],
        &["hampshire"],
        &["happened"],
        &["happened", "happens", "happen"],
        &["happened"],
        &["happens"],
        &["happened"],
        &["happens"],
        &["happened"],
        &["happening"],
        &["happenings"],
        &["happens"],
        &["happily"],
        &["happening", "happen"],
        &["happily"],
        &["happen"],
        &["happens", "happiness"],
        &["happen"],
        &["happened"],
        &["happening"],
        &["happenings"],
        &["happens"],
    ],
    range: 2..=8,
};

static WORD_HAO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HAO_CHILDREN),
    value: None,
};

pub static WORD_HAO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("rder"),
        dictgen::InsensitiveStr::Ascii("rding"),
    ],
    values: &[&["hoarder"], &["hoarding"]],
    range: 4..=5,
};

static WORD_HAN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_HAN_CHILDREN),
    value: None,
};

static WORD_HAN_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    None,
    Some(&WORD_HAND_NODE),
    Some(&WORD_HANE_NODE),
    None,
    Some(&WORD_HANG_NODE),
    None,
    Some(&WORD_HANI_NODE),
    None,
    Some(&WORD_HANK_NODE),
    Some(&WORD_HANL_NODE),
    None,
    Some(&WORD_HANN_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_HANS_NODE),
    None,
    Some(&WORD_HANU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_HANU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HANU_CHILDREN),
    value: None,
};

pub static WORD_HANU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ted")],
    values: &[&["haunted"]],
    range: 3..=3,
};

static WORD_HANS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HANS_CHILDREN),
    value: None,
};

pub static WORD_HANS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("hake"),
        dictgen::InsensitiveStr::Ascii("hakes"),
        dictgen::InsensitiveStr::Ascii("ome"),
    ],
    values: &[&["handshake"], &["handshakes"], &["handsome"]],
    range: 3..=5,
};

static WORD_HANN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HANN_CHILDREN),
    value: None,
};

pub static WORD_HANN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("bial"),
        dictgen::InsensitiveStr::Ascii("ging"),
        dictgen::InsensitiveStr::Ascii("ibl"),
    ],
    values: &[&["hannibal"], &["hanging"], &["hannibal"]],
    range: 3..=4,
};

static WORD_HANL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HANL_CHILDREN),
    value: None,
};

pub static WORD_HANL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("de"),
        dictgen::InsensitiveStr::Ascii("ded"),
        dictgen::InsensitiveStr::Ascii("der"),
        dictgen::InsensitiveStr::Ascii("ders"),
        dictgen::InsensitiveStr::Ascii("des"),
        dictgen::InsensitiveStr::Ascii("ding"),
        dictgen::InsensitiveStr::Ascii("dle"),
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("ing"),
    ],
    values: &[
        &["handle"],
        &["handled"],
        &["handler"],
        &["handlers"],
        &["handles"],
        &["handling"],
        &["handle"],
        &["handle"],
        &["handled"],
        &["handles"],
        &["handling"],
    ],
    range: 1..=4,
};

static WORD_HANK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HANK_CHILDREN),
    value: None,
};

pub static WORD_HANK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("erchif"),
        dictgen::InsensitiveStr::Ascii("erchifs"),
    ],
    values: &[&["handkerchief"], &["handkerchiefs"]],
    range: 6..=7,
};

static WORD_HANI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HANI_CHILDREN),
    value: None,
};

pub static WORD_HANI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("dcapped")],
    values: &[&["handicapped"]],
    range: 7..=7,
};

static WORD_HANG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HANG_CHILDREN),
    value: None,
};

pub static WORD_HANG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ig")],
    values: &[&["hanging"]],
    range: 2..=2,
};

static WORD_HANE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HANE_CHILDREN),
    value: None,
};

pub static WORD_HANE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("l")],
    values: &[&["handle"]],
    range: 1..=1,
};

static WORD_HAND_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_HAND_CHILDREN),
    value: None,
};

static WORD_HAND_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    Some(&WORD_HANDB_NODE),
    Some(&WORD_HANDC_NODE),
    None,
    Some(&WORD_HANDE_NODE),
    Some(&WORD_HANDF_NODE),
    None,
    Some(&WORD_HANDH_NODE),
    Some(&WORD_HANDI_NODE),
    None,
    Some(&WORD_HANDK_NODE),
    Some(&WORD_HANDL_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_HANDR_NODE),
    Some(&WORD_HANDS_NODE),
    None,
    None,
    None,
    Some(&WORD_HANDW_NODE),
    None,
    Some(&WORD_HANDY_NODE),
    None,
];

static WORD_HANDY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HANDY_CHILDREN),
    value: None,
};

pub static WORD_HANDY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("capped")],
    values: &[&["handicapped"]],
    range: 6..=6,
};

static WORD_HANDW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HANDW_CHILDREN),
    value: None,
};

pub static WORD_HANDW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("irting"),
        dictgen::InsensitiveStr::Ascii("ritng"),
        dictgen::InsensitiveStr::Ascii("ritting"),
    ],
    values: &[&["handwriting"], &["handwriting"], &["handwriting"]],
    range: 5..=7,
};

static WORD_HANDS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HANDS_CHILDREN),
    value: None,
};

pub static WORD_HANDS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ake"),
        dictgen::InsensitiveStr::Ascii("hacke"),
        dictgen::InsensitiveStr::Ascii("hackes"),
        dictgen::InsensitiveStr::Ascii("hacking"),
        dictgen::InsensitiveStr::Ascii("hage"),
        dictgen::InsensitiveStr::Ascii("hages"),
        dictgen::InsensitiveStr::Ascii("haging"),
        dictgen::InsensitiveStr::Ascii("hak"),
        dictgen::InsensitiveStr::Ascii("hakng"),
        dictgen::InsensitiveStr::Ascii("hakre"),
        dictgen::InsensitiveStr::Ascii("hakres"),
        dictgen::InsensitiveStr::Ascii("hakring"),
        dictgen::InsensitiveStr::Ascii("haks"),
        dictgen::InsensitiveStr::Ascii("hale"),
        dictgen::InsensitiveStr::Ascii("hales"),
        dictgen::InsensitiveStr::Ascii("haling"),
        dictgen::InsensitiveStr::Ascii("hare"),
        dictgen::InsensitiveStr::Ascii("hares"),
        dictgen::InsensitiveStr::Ascii("haring"),
        dictgen::InsensitiveStr::Ascii("hk"),
        dictgen::InsensitiveStr::Ascii("hke"),
        dictgen::InsensitiveStr::Ascii("hkes"),
        dictgen::InsensitiveStr::Ascii("hking"),
        dictgen::InsensitiveStr::Ascii("hkng"),
        dictgen::InsensitiveStr::Ascii("hks"),
        dictgen::InsensitiveStr::Ascii("kake"),
    ],
    values: &[
        &["handshake"],
        &["handshake"],
        &["handshakes"],
        &["handshaking"],
        &["handshake"],
        &["handshakes"],
        &["handshaking"],
        &["handshake"],
        &["handshaking"],
        &["handshake"],
        &["handshakes"],
        &["handshaking"],
        &["handshakes"],
        &["handshake"],
        &["handshakes"],
        &["handshaking"],
        &["handshake"],
        &["handshakes"],
        &["handshaking"],
        &["handshake"],
        &["handshake"],
        &["handshakes"],
        &["handshaking"],
        &["handshaking"],
        &["handshakes"],
        &["handshake"],
    ],
    range: 2..=7,
};

static WORD_HANDR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HANDR_CHILDREN),
    value: None,
};

pub static WORD_HANDR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("witing")],
    values: &[&["handwriting"]],
    range: 6..=6,
};

static WORD_HANDL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HANDL_CHILDREN),
    value: None,
};

pub static WORD_HANDL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ade"),
        dictgen::InsensitiveStr::Ascii("are"),
        dictgen::InsensitiveStr::Ascii("ebards"),
        dictgen::InsensitiveStr::Ascii("edy"),
        dictgen::InsensitiveStr::Ascii("eer"),
        dictgen::InsensitiveStr::Ascii("eing"),
        dictgen::InsensitiveStr::Ascii("ig"),
        dictgen::InsensitiveStr::Ascii("ling"),
    ],
    values: &[
        &["handled"],
        &["handler"],
        &["handlebars"],
        &["handedly"],
        &["handler"],
        &["handling"],
        &["handling"],
        &["handling"],
    ],
    range: 2..=6,
};

static WORD_HANDK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HANDK_CHILDREN),
    value: None,
};

pub static WORD_HANDK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("er"),
        dictgen::InsensitiveStr::Ascii("erchif"),
        dictgen::InsensitiveStr::Ascii("erchifs"),
    ],
    values: &[&["handler"], &["handkerchief"], &["handkerchiefs"]],
    range: 2..=7,
};

static WORD_HANDI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HANDI_CHILDREN),
    value: None,
};

pub static WORD_HANDI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cape"),
        dictgen::InsensitiveStr::Ascii("caped"),
    ],
    values: &[&["handicapped"], &["handicapped"]],
    range: 4..=5,
};

static WORD_HANDH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HANDH_CHILDREN),
    value: None,
};

pub static WORD_HANDH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ake")],
    values: &[&["handshake"]],
    range: 3..=3,
};

static WORD_HANDF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HANDF_CHILDREN),
    value: None,
};

pub static WORD_HANDF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ull")],
    values: &[&["handful"]],
    range: 3..=3,
};

static WORD_HANDE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HANDE_CHILDREN),
    value: Some(&["handle", "hand"]),
};

pub static WORD_HANDE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("dley"),
        dictgen::InsensitiveStr::Ascii("dlly"),
        dictgen::InsensitiveStr::Ascii("dy"),
        dictgen::InsensitiveStr::Ascii("l"),
        dictgen::InsensitiveStr::Ascii("lbars"),
        dictgen::InsensitiveStr::Ascii("ld"),
        dictgen::InsensitiveStr::Ascii("ldy"),
        dictgen::InsensitiveStr::Ascii("led"),
        dictgen::InsensitiveStr::Ascii("ler"),
        dictgen::InsensitiveStr::Ascii("les"),
        dictgen::InsensitiveStr::Ascii("ling"),
        dictgen::InsensitiveStr::Ascii("ls"),
        dictgen::InsensitiveStr::Ascii("r"),
    ],
    values: &[
        &["handedly"],
        &["handedly"],
        &["handedly"],
        &["handle"],
        &["handlebars"],
        &["handled", "handheld"],
        &["handedly"],
        &["handled", "handheld"],
        &["handler"],
        &["handles"],
        &["handling"],
        &["handles"],
        &["handler"],
    ],
    range: 1..=5,
};

static WORD_HANDC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HANDC_CHILDREN),
    value: None,
};

pub static WORD_HANDC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("uffes"),
        dictgen::InsensitiveStr::Ascii("ufs"),
    ],
    values: &[&["handcuffs"], &["handcuffs"]],
    range: 3..=5,
};

static WORD_HANDB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HANDB_CHILDREN),
    value: None,
};

pub static WORD_HANDB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ok"),
        dictgen::InsensitiveStr::Ascii("oook"),
    ],
    values: &[&["handbook"], &["handbook"]],
    range: 2..=4,
};

static WORD_HAM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HAM_CHILDREN),
    value: None,
};

pub static WORD_HAM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("bergers"),
        dictgen::InsensitiveStr::Ascii("bruger"),
        dictgen::InsensitiveStr::Ascii("burgare"),
        dictgen::InsensitiveStr::Ascii("burgaren"),
        dictgen::InsensitiveStr::Ascii("burgeres"),
        dictgen::InsensitiveStr::Ascii("burges"),
        dictgen::InsensitiveStr::Ascii("burgesa"),
        dictgen::InsensitiveStr::Ascii("burglers"),
        dictgen::InsensitiveStr::Ascii("burgles"),
        dictgen::InsensitiveStr::Ascii("burgr"),
        dictgen::InsensitiveStr::Ascii("burguers"),
        dictgen::InsensitiveStr::Ascii("burgurs"),
        dictgen::InsensitiveStr::Ascii("itlon"),
        dictgen::InsensitiveStr::Ascii("liton"),
        dictgen::InsensitiveStr::Ascii("mmer"),
        dictgen::InsensitiveStr::Ascii("phsire"),
        dictgen::InsensitiveStr::Ascii("pster"),
        dictgen::InsensitiveStr::Ascii("sphire"),
    ],
    values: &[
        &["hamburgers"],
        &["hamburger"],
        &["hamburger"],
        &["hamburger"],
        &["hamburgers"],
        &["hamburgers"],
        &["hamburgers"],
        &["hamburgers"],
        &["hamburgers"],
        &["hamburgers"],
        &["hamburgers"],
        &["hamburgers"],
        &["hamilton"],
        &["hamilton"],
        &["hammer"],
        &["hampshire"],
        &["hamster"],
        &["hampshire"],
    ],
    range: 4..=8,
};

static WORD_HAL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HAL_CHILDREN),
    value: None,
};

pub static WORD_HAL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("arious"),
        dictgen::InsensitiveStr::Ascii("d"),
        dictgen::InsensitiveStr::Ascii("fiax"),
        dictgen::InsensitiveStr::Ascii("fitme"),
        dictgen::InsensitiveStr::Ascii("fs"),
        dictgen::InsensitiveStr::Ascii("laluja"),
        dictgen::InsensitiveStr::Ascii("laluya"),
        dictgen::InsensitiveStr::Ascii("lcuination"),
        dictgen::InsensitiveStr::Ascii("lcuinations"),
        dictgen::InsensitiveStr::Ascii("licunation"),
        dictgen::InsensitiveStr::Ascii("licunations"),
        dictgen::InsensitiveStr::Ascii("lowean"),
        dictgen::InsensitiveStr::Ascii("loweeen"),
        dictgen::InsensitiveStr::Ascii("lowen"),
        dictgen::InsensitiveStr::Ascii("lucenation"),
        dictgen::InsensitiveStr::Ascii("lucenations"),
        dictgen::InsensitiveStr::Ascii("luciantion"),
        dictgen::InsensitiveStr::Ascii("luciantions"),
        dictgen::InsensitiveStr::Ascii("lucinaitons"),
        dictgen::InsensitiveStr::Ascii("lucinatin"),
        dictgen::InsensitiveStr::Ascii("lucinaton"),
        dictgen::InsensitiveStr::Ascii("lukination"),
        dictgen::InsensitiveStr::Ascii("lunication"),
        dictgen::InsensitiveStr::Ascii("lunications"),
        dictgen::InsensitiveStr::Ascii("lusination"),
        dictgen::InsensitiveStr::Ascii("lusinations"),
        dictgen::InsensitiveStr::Ascii("luzination"),
        dictgen::InsensitiveStr::Ascii("luzinations"),
        dictgen::InsensitiveStr::Ascii("p"),
        dictgen::InsensitiveStr::Ascii("points"),
    ],
    values: &[
        &["hilarious"],
        &["held", "half", "hall", "hold"],
        &["halifax"],
        &["halftime"],
        &["halves"],
        &["hallelujah"],
        &["hallelujah"],
        &["hallucination"],
        &["hallucination"],
        &["hallucination"],
        &["hallucinations"],
        &["halloween"],
        &["halloween"],
        &["halloween"],
        &["hallucination"],
        &["hallucinations"],
        &["hallucinations"],
        &["hallucinations"],
        &["hallucination"],
        &["hallucinations"],
        &["hallucination"],
        &["hallucination"],
        &["hallucination"],
        &["hallucinations"],
        &["hallucination"],
        &["hallucinations"],
        &["hallucination"],
        &["hallucinations"],
        &["help"],
        &["halfpoints"],
    ],
    range: 1..=11,
};

static WORD_HAI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HAI_CHILDREN),
    value: None,
};

pub static WORD_HAI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("lfax"),
        dictgen::InsensitiveStr::Ascii("rcuit"),
        dictgen::InsensitiveStr::Ascii("rstlye"),
        dictgen::InsensitiveStr::Ascii("rsytle"),
    ],
    values: &[&["halifax"], &["haircut"], &["hairstyle"], &["hairstyle"]],
    range: 4..=6,
};

static WORD_HAH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HAH_CHILDREN),
    value: None,
};

pub static WORD_HAH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ve")],
    values: &[&["have", "halve", "half"]],
    range: 2..=2,
};

static WORD_HAG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HAG_CHILDREN),
    value: None,
};

pub static WORD_HAG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("as"),
        dictgen::InsensitiveStr::Ascii("ases"),
        dictgen::InsensitiveStr::Ascii("asses"),
    ],
    values: &[&["haggis"], &["haggises"], &["haggises"]],
    range: 2..=5,
};

static WORD_HAF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HAF_CHILDREN),
    value: None,
};

pub static WORD_HAF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ltime")],
    values: &[&["halftime"]],
    range: 5..=5,
};

static WORD_HAE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HAE_CHILDREN),
    value: None,
};

pub static WORD_HAE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("der"),
        dictgen::InsensitiveStr::Ascii("morrage"),
        dictgen::InsensitiveStr::Ascii("then"),
        dictgen::InsensitiveStr::Ascii("v"),
    ],
    values: &[
        &["header"],
        &["haemorrhage"],
        &["heathen"],
        &["have", "heave"],
    ],
    range: 1..=7,
};

static WORD_HAD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HAD_CHILDREN),
    value: None,
};

pub static WORD_HAD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ers"),
        dictgen::InsensitiveStr::Ascii("lers"),
        dictgen::InsensitiveStr::Ascii("ling"),
        dictgen::InsensitiveStr::Ascii("nler"),
    ],
    values: &[
        &["headers", "shaders", "haters"],
        &["handler"],
        &["handling"],
        &["handler"],
    ],
    range: 3..=4,
};

static WORD_HAC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HAC_CHILDREN),
    value: None,
};

pub static WORD_HAC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("h"),
        dictgen::InsensitiveStr::Ascii("hish"),
        dictgen::InsensitiveStr::Ascii("thing"),
    ],
    values: &[
        &["have"],
        &["hatch", "hack", "hash"],
        &["hackish"],
        &["hatching"],
    ],
    range: 1..=5,
};

static WORD_HAB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HAB_CHILDREN),
    value: None,
};

pub static WORD_HAB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aeus"),
        dictgen::InsensitiveStr::Ascii("bit"),
        dictgen::InsensitiveStr::Ascii("eus"),
        dictgen::InsensitiveStr::Ascii("ility"),
        dictgen::InsensitiveStr::Ascii("sbourg"),
    ],
    values: &[
        &["habeas"],
        &["habit"],
        &["habeas"],
        &["ability"],
        &["habsburg"],
    ],
    range: 3..=6,
};

static WORD_HAA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_HAA_CHILDREN),
    value: Some(&["has"]),
};

pub static WORD_HAA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ve")],
    values: &[&["have"]],
    range: 2..=2,
};

static WORD_G_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_G_CHILDREN),
    value: None,
};

static WORD_G_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_GA_NODE),
    None,
    None,
    None,
    Some(&WORD_GE_NODE),
    None,
    Some(&WORD_GG_NODE),
    Some(&WORD_GH_NODE),
    Some(&WORD_GI_NODE),
    None,
    None,
    Some(&WORD_GL_NODE),
    Some(&WORD_GM_NODE),
    Some(&WORD_GN_NODE),
    Some(&WORD_GO_NODE),
    Some(&WORD_GP_NODE),
    None,
    Some(&WORD_GR_NODE),
    None,
    None,
    Some(&WORD_GU_NODE),
    None,
    Some(&WORD_GW_NODE),
    None,
    Some(&WORD_GY_NODE),
    Some(&WORD_GZ_NODE),
];

static WORD_GZ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_GZ_CHILDREN),
    value: None,
};

pub static WORD_GZ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("iniflate"),
        dictgen::InsensitiveStr::Ascii("iped"),
    ],
    values: &[&["gzinflate"], &["gzipped"]],
    range: 4..=8,
};

static WORD_GY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_GY_CHILDREN),
    value: None,
};

pub static WORD_GY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("lph"),
        dictgen::InsensitiveStr::Ascii("manstics"),
        dictgen::InsensitiveStr::Ascii("mnasitcs"),
        dictgen::InsensitiveStr::Ascii("mnist"),
        dictgen::InsensitiveStr::Ascii("mnistic"),
        dictgen::InsensitiveStr::Ascii("mnistics"),
        dictgen::InsensitiveStr::Ascii("mnists"),
        dictgen::InsensitiveStr::Ascii("nmastics"),
        dictgen::InsensitiveStr::Ascii("pises"),
        dictgen::InsensitiveStr::Ascii("spies"),
    ],
    values: &[
        &["glyph"],
        &["gymnastics"],
        &["gymnastics"],
        &["gymnast"],
        &["gymnastic"],
        &["gymnastics"],
        &["gymnasts"],
        &["gymnastics"],
        &["gypsies"],
        &["gypsies"],
    ],
    range: 3..=8,
};

static WORD_GW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_GW_CHILDREN),
    value: None,
};

pub static WORD_GW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ava")],
    values: &[&["guava"]],
    range: 3..=3,
};

static WORD_GU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_GU_CHILDREN),
    value: None,
};

static WORD_GU_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_GUA_NODE),
    Some(&WORD_GUB_NODE),
    None,
    Some(&WORD_GUD_NODE),
    Some(&WORD_GUE_NODE),
    None,
    None,
    None,
    Some(&WORD_GUI_NODE),
    None,
    None,
    Some(&WORD_GUL_NODE),
    None,
    Some(&WORD_GUN_NODE),
    None,
    None,
    None,
    Some(&WORD_GUR_NODE),
    None,
    Some(&WORD_GUT_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_GUY_NODE),
    None,
];

static WORD_GUY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_GUY_CHILDREN),
    value: None,
};

pub static WORD_GUY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ser"),
        dictgen::InsensitiveStr::Ascii("sers"),
        dictgen::InsensitiveStr::Ascii("zer"),
        dictgen::InsensitiveStr::Ascii("zers"),
    ],
    values: &[&["geyser"], &["geysers"], &["geyser"], &["geysers"]],
    range: 3..=4,
};

static WORD_GUT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_GUT_CHILDREN),
    value: None,
};

pub static WORD_GUT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("iarist"),
        dictgen::InsensitiveStr::Ascii("iars"),
        dictgen::InsensitiveStr::Ascii("taral"),
        dictgen::InsensitiveStr::Ascii("teral"),
    ],
    values: &[&["guitarist"], &["guitars"], &["guttural"], &["guttural"]],
    range: 4..=6,
};

static WORD_GUR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_GUR_CHILDREN),
    value: None,
};

pub static WORD_GUR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("adian"),
        dictgen::InsensitiveStr::Ascii("adians"),
        dictgen::InsensitiveStr::Ascii("ading"),
        dictgen::InsensitiveStr::Ascii("antee"),
        dictgen::InsensitiveStr::Ascii("anteed"),
        dictgen::InsensitiveStr::Ascii("anteeing"),
        dictgen::InsensitiveStr::Ascii("antees"),
        dictgen::InsensitiveStr::Ascii("esome"),
        dictgen::InsensitiveStr::Ascii("rantee"),
    ],
    values: &[
        &["guardian"],
        &["guardians"],
        &["guarding"],
        &["guarantee"],
        &["guaranteed"],
        &["guaranteeing"],
        &["guarantees"],
        &["gruesome"],
        &["guarantee"],
    ],
    range: 5..=8,
};

static WORD_GUN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_GUN_CHILDREN),
    value: None,
};

pub static WORD_GUN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("anine"),
        dictgen::InsensitiveStr::Ascii("atanamo"),
        dictgen::InsensitiveStr::Ascii("damentalists"),
        dictgen::InsensitiveStr::Ascii("iness"),
        dictgen::InsensitiveStr::Ascii("lsinger"),
        dictgen::InsensitiveStr::Ascii("niess"),
        dictgen::InsensitiveStr::Ascii("siinger"),
        dictgen::InsensitiveStr::Ascii("slanger"),
        dictgen::InsensitiveStr::Ascii("sligner"),
        dictgen::InsensitiveStr::Ascii("slingner"),
        dictgen::InsensitiveStr::Ascii("stinger"),
    ],
    values: &[
        &["guanine"],
        &["guantanamo"],
        &["fundamentalists"],
        &["guinness"],
        &["gunslinger"],
        &["guinness"],
        &["gunslinger"],
        &["gunslinger"],
        &["gunslinger"],
        &["gunslinger"],
        &["gunslinger"],
    ],
    range: 5..=12,
};

static WORD_GUL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_GUL_CHILDREN),
    value: None,
};

pub static WORD_GUL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("lbile"),
        dictgen::InsensitiveStr::Ascii("libe"),
    ],
    values: &[&["gullible"], &["gullible"]],
    range: 4..=5,
};

static WORD_GUI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_GUI_CHILDREN),
    value: None,
};

pub static WORD_GUI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("deded"),
        dictgen::InsensitiveStr::Ascii("dence"),
        dictgen::InsensitiveStr::Ascii("dline"),
        dictgen::InsensitiveStr::Ascii("dlines"),
        dictgen::InsensitiveStr::Ascii("lia"),
        dictgen::InsensitiveStr::Ascii("lio"),
        dictgen::InsensitiveStr::Ascii("ness"),
        dictgen::InsensitiveStr::Ascii("seppe"),
        dictgen::InsensitiveStr::Ascii("tards"),
        dictgen::InsensitiveStr::Ascii("tares"),
        dictgen::InsensitiveStr::Ascii("tarit"),
    ],
    values: &[
        &["guided"],
        &["guidance"],
        &["guideline"],
        &["guidelines"],
        &["giulia"],
        &["giulio"],
        &["guinness"],
        &["giuseppe"],
        &["guitars"],
        &["guitars"],
        &["guitarist"],
    ],
    range: 3..=6,
};

static WORD_GUE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_GUE_CHILDREN),
    value: None,
};

pub static WORD_GUE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("rrila"),
        dictgen::InsensitiveStr::Ascii("rrilas"),
        dictgen::InsensitiveStr::Ascii("rrillera"),
        dictgen::InsensitiveStr::Ascii("sss"),
        dictgen::InsensitiveStr::Ascii("swork"),
    ],
    values: &[
        &["guerrilla"],
        &["guerrillas"],
        &["guerrilla"],
        &["guess", "guesses"],
        &["guesswork"],
    ],
    range: 3..=8,
};

static WORD_GUD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_GUD_CHILDREN),
    value: Some(&["good"]),
};

pub static WORD_GUD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("e")],
    values: &[&["guide", "good"]],
    range: 1..=1,
};

static WORD_GUB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_GUB_CHILDREN),
    value: None,
};

pub static WORD_GUB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("natorial")],
    values: &[&["gubernatorial"]],
    range: 8..=8,
};

static WORD_GUA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_GUA_CHILDREN),
    value: None,
};

static WORD_GUA_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    None,
    Some(&WORD_GUAD_NODE),
    None,
    None,
    Some(&WORD_GUAG_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_GUAN_NODE),
    None,
    None,
    None,
    Some(&WORD_GUAR_NODE),
    Some(&WORD_GUAS_NODE),
    Some(&WORD_GUAT_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_GUAT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_GUAT_CHILDREN),
    value: None,
};

pub static WORD_GUAT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("amala"),
        dictgen::InsensitiveStr::Ascii("amalan"),
    ],
    values: &[&["guatemala"], &["guatemalan"]],
    range: 5..=6,
};

static WORD_GUAS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_GUAS_CHILDREN),
    value: Some(&["gauss"]),
};

pub static WORD_GUAS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("s"),
        dictgen::InsensitiveStr::Ascii("sian"),
    ],
    values: &[&["gauss"], &["gaussian"]],
    range: 1..=4,
};

static WORD_GUAR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_GUAR_CHILDREN),
    value: None,
};

static WORD_GUAR_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_GUARA_NODE),
    Some(&WORD_GUARB_NODE),
    None,
    Some(&WORD_GUARD_NODE),
    Some(&WORD_GUARE_NODE),
    None,
    Some(&WORD_GUARG_NODE),
    None,
    Some(&WORD_GUARI_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_GUARN_NODE),
    None,
    None,
    None,
    Some(&WORD_GUARR_NODE),
    None,
    None,
    Some(&WORD_GUARU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_GUARU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_GUARU_CHILDREN),
    value: None,
};

pub static WORD_GUARU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ante"),
        dictgen::InsensitiveStr::Ascii("anted"),
        dictgen::InsensitiveStr::Ascii("antee"),
        dictgen::InsensitiveStr::Ascii("anteed"),
        dictgen::InsensitiveStr::Ascii("anteeing"),
        dictgen::InsensitiveStr::Ascii("antees"),
        dictgen::InsensitiveStr::Ascii("anteing"),
        dictgen::InsensitiveStr::Ascii("antes"),
        dictgen::InsensitiveStr::Ascii("anty"),
        dictgen::InsensitiveStr::Ascii("nte"),
        dictgen::InsensitiveStr::Ascii("nted"),
        dictgen::InsensitiveStr::Ascii("ntee"),
        dictgen::InsensitiveStr::Ascii("nteed"),
        dictgen::InsensitiveStr::Ascii("nteeing"),
        dictgen::InsensitiveStr::Ascii("ntees"),
        dictgen::InsensitiveStr::Ascii("nteing"),
        dictgen::InsensitiveStr::Ascii("ntes"),
        dictgen::InsensitiveStr::Ascii("nty"),
    ],
    values: &[
        &["guarantee"],
        &["guaranteed"],
        &["guarantee"],
        &["guaranteed"],
        &["guaranteeing"],
        &["guarantees"],
        &["guaranteeing"],
        &["guarantees"],
        &["guaranty"],
        &["guarantee"],
        &["guaranteed"],
        &["guarantee"],
        &["guaranteed"],
        &["guaranteeing"],
        &["guarantees"],
        &["guaranteeing"],
        &["guarantees"],
        &["guaranty"],
    ],
    range: 3..=8,
};

static WORD_GUARR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_GUARR_CHILDREN),
    value: None,
};

pub static WORD_GUARR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ante"),
        dictgen::InsensitiveStr::Ascii("anted"),
        dictgen::InsensitiveStr::Ascii("antee"),
        dictgen::InsensitiveStr::Ascii("anteed"),
        dictgen::InsensitiveStr::Ascii("anteeing"),
        dictgen::InsensitiveStr::Ascii("antees"),
        dictgen::InsensitiveStr::Ascii("anteing"),
        dictgen::InsensitiveStr::Ascii("antes"),
        dictgen::InsensitiveStr::Ascii("antie"),
        dictgen::InsensitiveStr::Ascii("antied"),
        dictgen::InsensitiveStr::Ascii("antieing"),
        dictgen::InsensitiveStr::Ascii("anties"),
        dictgen::InsensitiveStr::Ascii("anty"),
        dictgen::InsensitiveStr::Ascii("antyd"),
        dictgen::InsensitiveStr::Ascii("antying"),
        dictgen::InsensitiveStr::Ascii("antys"),
        dictgen::InsensitiveStr::Ascii("ente"),
        dictgen::InsensitiveStr::Ascii("ented"),
        dictgen::InsensitiveStr::Ascii("entee"),
        dictgen::InsensitiveStr::Ascii("enteed"),
        dictgen::InsensitiveStr::Ascii("enteeing"),
        dictgen::InsensitiveStr::Ascii("entees"),
        dictgen::InsensitiveStr::Ascii("enteing"),
        dictgen::InsensitiveStr::Ascii("entes"),
        dictgen::InsensitiveStr::Ascii("enty"),
    ],
    values: &[
        &["guarantee"],
        &["guaranteed"],
        &["guarantee"],
        &["guaranteed"],
        &["guaranteeing"],
        &["guarantees"],
        &["guaranteeing"],
        &["guarantees"],
        &["guarantee"],
        &["guaranteed"],
        &["guaranteeing"],
        &["guarantees"],
        &["guaranty"],
        &["guaranteed"],
        &["guaranteeing"],
        &["guarantees"],
        &["guarantee"],
        &["guaranteed"],
        &["guarantee"],
        &["guaranteed"],
        &["guaranteeing"],
        &["guarantees"],
        &["guaranteeing"],
        &["guarantees"],
        &["guaranty"],
    ],
    range: 4..=8,
};

static WORD_GUARN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_GUARN_CHILDREN),
    value: None,
};

pub static WORD_GUARN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ante"),
        dictgen::InsensitiveStr::Ascii("anted"),
        dictgen::InsensitiveStr::Ascii("antee"),
        dictgen::InsensitiveStr::Ascii("anteed"),
        dictgen::InsensitiveStr::Ascii("anteeing"),
        dictgen::InsensitiveStr::Ascii("antees"),
        dictgen::InsensitiveStr::Ascii("anteing"),
        dictgen::InsensitiveStr::Ascii("antes"),
        dictgen::InsensitiveStr::Ascii("anty"),
        dictgen::InsensitiveStr::Ascii("ate"),
        dictgen::InsensitiveStr::Ascii("ated"),
        dictgen::InsensitiveStr::Ascii("atee"),
        dictgen::InsensitiveStr::Ascii("ateed"),
        dictgen::InsensitiveStr::Ascii("ateee"),
        dictgen::InsensitiveStr::Ascii("ateeed"),
        dictgen::InsensitiveStr::Ascii("ateeeing"),
        dictgen::InsensitiveStr::Ascii("ateees"),
        dictgen::InsensitiveStr::Ascii("ateeing"),
        dictgen::InsensitiveStr::Ascii("atees"),
        dictgen::InsensitiveStr::Ascii("ateing"),
        dictgen::InsensitiveStr::Ascii("ates"),
        dictgen::InsensitiveStr::Ascii("atey"),
        dictgen::InsensitiveStr::Ascii("aty"),
        dictgen::InsensitiveStr::Ascii("ete"),
        dictgen::InsensitiveStr::Ascii("eted"),
        dictgen::InsensitiveStr::Ascii("etee"),
        dictgen::InsensitiveStr::Ascii("eteed"),
        dictgen::InsensitiveStr::Ascii("eteeing"),
        dictgen::InsensitiveStr::Ascii("etees"),
        dictgen::InsensitiveStr::Ascii("eteing"),
        dictgen::InsensitiveStr::Ascii("etes"),
        dictgen::InsensitiveStr::Ascii("ety"),
        dictgen::InsensitiveStr::Ascii("te"),
        dictgen::InsensitiveStr::Ascii("ted"),
        dictgen::InsensitiveStr::Ascii("tee"),
        dictgen::InsensitiveStr::Ascii("teed"),
        dictgen::InsensitiveStr::Ascii("teeing"),
        dictgen::InsensitiveStr::Ascii("tees"),
        dictgen::InsensitiveStr::Ascii("teing"),
        dictgen::InsensitiveStr::Ascii("tes"),
        dictgen::InsensitiveStr::Ascii("ty"),
    ],
    values: &[
        &["guarantee"],
        &["guaranteed"],
        &["guarantee"],
        &["guaranteed"],
        &["guaranteeing"],
        &["guarantees"],
        &["guaranteeing"],
        &["guarantees"],
        &["guaranty"],
        &["guarantee"],
        &["guaranteed"],
        &["guarantee"],
        &["guaranteed"],
        &["guarantee"],
        &["guaranteed"],
        &["guaranteeing"],
        &["guarantees"],
        &["guaranteeing"],
        &["guarantees"],
        &["guaranteeing"],
        &["guarantees"],
        &["guaranty"],
        &["guaranty"],
        &["guarantee"],
        &["guaranteed"],
        &["guarantee"],
        &["guaranteed"],
        &["guaranteeing"],
        &["guarantees"],
        &["guaranteeing"],
        &["guarantees"],
        &["guaranty"],
        &["guarantee"],
        &["guaranteed"],
        &["guarantee"],
        &["guaranteed"],
        &["guaranteeing"],
        &["guarantees"],
        &["guaranteeing"],
        &["guarantees"],
        &["guaranty"],
    ],
    range: 2..=8,
};

static WORD_GUARI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_GUARI_CHILDREN),
    value: None,
};

pub static WORD_GUARI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("dan"),
        dictgen::InsensitiveStr::Ascii("dans"),
    ],
    values: &[&["guardian"], &["guardians"]],
    range: 3..=4,
};

static WORD_GUARG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_GUARG_CHILDREN),
    value: None,
};

pub static WORD_GUARG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ing")],
    values: &[&["guarding"]],
    range: 3..=3,
};

static WORD_GUARE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_GUARE_CHILDREN),
    value: None,
};

pub static WORD_GUARE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("d"),
        dictgen::InsensitiveStr::Ascii("ded"),
        dictgen::InsensitiveStr::Ascii("ente"),
        dictgen::InsensitiveStr::Ascii("ented"),
        dictgen::InsensitiveStr::Ascii("entee"),
        dictgen::InsensitiveStr::Ascii("enteed"),
        dictgen::InsensitiveStr::Ascii("enteeing"),
        dictgen::InsensitiveStr::Ascii("entees"),
        dictgen::InsensitiveStr::Ascii("enteing"),
        dictgen::InsensitiveStr::Ascii("entes"),
        dictgen::InsensitiveStr::Ascii("enty"),
        dictgen::InsensitiveStr::Ascii("nte"),
        dictgen::InsensitiveStr::Ascii("nted"),
        dictgen::InsensitiveStr::Ascii("ntee"),
        dictgen::InsensitiveStr::Ascii("nteed"),
        dictgen::InsensitiveStr::Ascii("nteede"),
        dictgen::InsensitiveStr::Ascii("nteeded"),
        dictgen::InsensitiveStr::Ascii("nteedeing"),
        dictgen::InsensitiveStr::Ascii("nteedes"),
        dictgen::InsensitiveStr::Ascii("nteedy"),
        dictgen::InsensitiveStr::Ascii("nteeing"),
        dictgen::InsensitiveStr::Ascii("nteer"),
        dictgen::InsensitiveStr::Ascii("nteerd"),
        dictgen::InsensitiveStr::Ascii("nteering"),
        dictgen::InsensitiveStr::Ascii("nteers"),
        dictgen::InsensitiveStr::Ascii("ntees"),
        dictgen::InsensitiveStr::Ascii("nteing"),
        dictgen::InsensitiveStr::Ascii("ntes"),
        dictgen::InsensitiveStr::Ascii("ntie"),
        dictgen::InsensitiveStr::Ascii("ntied"),
        dictgen::InsensitiveStr::Ascii("ntieing"),
        dictgen::InsensitiveStr::Ascii("nties"),
        dictgen::InsensitiveStr::Ascii("nty"),
        dictgen::InsensitiveStr::Ascii("ntyd"),
        dictgen::InsensitiveStr::Ascii("ntying"),
        dictgen::InsensitiveStr::Ascii("ntyinging"),
        dictgen::InsensitiveStr::Ascii("ntys"),
    ],
    values: &[
        &["guard", "guarded"],
        &["guarded"],
        &["guarantee"],
        &["guaranteed"],
        &["guarantee"],
        &["guaranteed"],
        &["guaranteeing"],
        &["guarantees"],
        &["guaranteeing"],
        &["guarantees"],
        &["guaranty"],
        &["guarantee"],
        &["guaranteed"],
        &["guarantee"],
        &["guaranteed"],
        &["guarantee"],
        &["guaranteed"],
        &["guaranteeing"],
        &["guarantees"],
        &["guaranty"],
        &["guaranteeing"],
        &["guarantee"],
        &["guaranteed"],
        &["guaranteeing"],
        &["guarantees"],
        &["guarantees"],
        &["guaranteeing"],
        &["guarantees"],
        &["guarantee"],
        &["guaranteed"],
        &["guaranteeing"],
        &["guarantees"],
        &["guaranty"],
        &["guaranteed"],
        &["guarantee"],
        &["guaranteeing"],
        &["guarantees"],
    ],
    range: 1..=9,
};

static WORD_GUARD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_GUARD_CHILDREN),
    value: None,
};

pub static WORD_GUARD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ain"),
        dictgen::InsensitiveStr::Ascii("ains"),
        dictgen::InsensitiveStr::Ascii("iands"),
        dictgen::InsensitiveStr::Ascii("ianes"),
        dictgen::InsensitiveStr::Ascii("ianis"),
        dictgen::InsensitiveStr::Ascii("ias"),
        dictgen::InsensitiveStr::Ascii("in"),
    ],
    values: &[
        &["guardian"],
        &["guardians"],
        &["guardians"],
        &["guardians"],
        &["guardians"],
        &["guardians"],
        &["guardian"],
    ],
    range: 2..=5,
};

static WORD_GUARB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_GUARB_CHILDREN),
    value: None,
};

pub static WORD_GUARB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("age")],
    values: &[&["garbage"]],
    range: 3..=3,
};

static WORD_GUARA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_GUARA_CHILDREN),
    value: None,
};

pub static WORD_GUARA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("nte"),
        dictgen::InsensitiveStr::Ascii("nted"),
        dictgen::InsensitiveStr::Ascii("nteeds"),
        dictgen::InsensitiveStr::Ascii("nteey"),
        dictgen::InsensitiveStr::Ascii("nteing"),
        dictgen::InsensitiveStr::Ascii("ntes"),
        dictgen::InsensitiveStr::Ascii("ntess"),
        dictgen::InsensitiveStr::Ascii("ntie"),
    ],
    values: &[
        &["guarantee"],
        &["guaranteed"],
        &["guarantees"],
        &["guaranty"],
        &["guaranteeing"],
        &["guarantees"],
        &["guarantees"],
        &["guarantee"],
    ],
    range: 3..=6,
};

static WORD_GUAN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_GUAN_CHILDREN),
    value: None,
};

pub static WORD_GUAN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("atanmo"),
        dictgen::InsensitiveStr::Ascii("tamamo"),
        dictgen::InsensitiveStr::Ascii("tamano"),
        dictgen::InsensitiveStr::Ascii("tanameow"),
        dictgen::InsensitiveStr::Ascii("tanamero"),
        dictgen::InsensitiveStr::Ascii("tanano"),
        dictgen::InsensitiveStr::Ascii("tanemo"),
        dictgen::InsensitiveStr::Ascii("tano"),
        dictgen::InsensitiveStr::Ascii("tanoma"),
        dictgen::InsensitiveStr::Ascii("tanomo"),
        dictgen::InsensitiveStr::Ascii("tonamo"),
    ],
    values: &[
        &["guantanamo"],
        &["guantanamo"],
        &["guantanamo"],
        &["guantanamo"],
        &["guantanamo"],
        &["guantanamo"],
        &["guantanamo"],
        &["guantanamo"],
        &["guantanamo"],
        &["guantanamo"],
        &["guantanamo"],
    ],
    range: 4..=8,
};

static WORD_GUAG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_GUAG_CHILDREN),
    value: None,
};

pub static WORD_GUAG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("e")],
    values: &[&["gage"]],
    range: 1..=1,
};

static WORD_GUAD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_GUAD_CHILDREN),
    value: None,
};

pub static WORD_GUAD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("uloupe"),
        dictgen::InsensitiveStr::Ascii("ulupe"),
    ],
    values: &[&["guadalupe", "guadeloupe"], &["guadalupe", "guadeloupe"]],
    range: 5..=6,
};

static WORD_GR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_GR_CHILDREN),
    value: None,
};

static WORD_GR_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_GRA_NODE),
    Some(&WORD_GRB_NODE),
    None,
    None,
    Some(&WORD_GRE_NODE),
    None,
    None,
    None,
    Some(&WORD_GRI_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_GRO_NODE),
    Some(&WORD_GRP_NODE),
    None,
    Some(&WORD_GRR_NODE),
    None,
    None,
    Some(&WORD_GRU_NODE),
    None,
    Some(&WORD_GRW_NODE),
    None,
    None,
    None,
];

static WORD_GRW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_GRW_CHILDREN),
    value: None,
};

pub static WORD_GRW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("o")],
    values: &[&["grow"]],
    range: 1..=1,
};

static WORD_GRU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_GRU_CHILDREN),
    value: None,
};

pub static WORD_GRU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("op"),
        dictgen::InsensitiveStr::Ascii("opd"),
        dictgen::InsensitiveStr::Ascii("ops"),
        dictgen::InsensitiveStr::Ascii("p"),
        dictgen::InsensitiveStr::Ascii("ped"),
        dictgen::InsensitiveStr::Ascii("ping"),
        dictgen::InsensitiveStr::Ascii("ps"),
        dictgen::InsensitiveStr::Ascii("seome"),
    ],
    values: &[
        &["group"],
        &["grouped"],
        &["groups"],
        &["group"],
        &["grouped"],
        &["grouping"],
        &["groups"],
        &["gruesome"],
    ],
    range: 1..=5,
};

static WORD_GRR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_GRR_CHILDREN),
    value: None,
};

pub static WORD_GRR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("anted")],
    values: &[&["granted"]],
    range: 5..=5,
};

static WORD_GRP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_GRP_CHILDREN),
    value: None,
};

pub static WORD_GRP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ahic"),
        dictgen::InsensitiveStr::Ascii("ahical"),
        dictgen::InsensitiveStr::Ascii("ahically"),
        dictgen::InsensitiveStr::Ascii("ahics"),
        dictgen::InsensitiveStr::Ascii("ahite"),
    ],
    values: &[
        &["graphic"],
        &["graphical"],
        &["graphically"],
        &["graphics"],
        &["graphite"],
    ],
    range: 4..=8,
};

static WORD_GRO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_GRO_CHILDREN),
    value: None,
};

pub static WORD_GRO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("bal"),
        dictgen::InsensitiveStr::Ascii("bally"),
        dictgen::InsensitiveStr::Ascii("metry"),
        dictgen::InsensitiveStr::Ascii("osome"),
        dictgen::InsensitiveStr::Ascii("osomely"),
        dictgen::InsensitiveStr::Ascii("osum"),
        dictgen::InsensitiveStr::Ascii("osumly"),
        dictgen::InsensitiveStr::Ascii("oup"),
        dictgen::InsensitiveStr::Ascii("ouped"),
        dictgen::InsensitiveStr::Ascii("ouping"),
        dictgen::InsensitiveStr::Ascii("oups"),
        dictgen::InsensitiveStr::Ascii("p"),
        dictgen::InsensitiveStr::Ascii("pu"),
        dictgen::InsensitiveStr::Ascii("puing"),
        dictgen::InsensitiveStr::Ascii("pus"),
        dictgen::InsensitiveStr::Ascii("shuries"),
        dictgen::InsensitiveStr::Ascii("shury"),
        dictgen::InsensitiveStr::Ascii("th"),
        dictgen::InsensitiveStr::Ascii("ubdbreaking"),
        dictgen::InsensitiveStr::Ascii("ubpy"),
        dictgen::InsensitiveStr::Ascii("udnbreaking"),
        dictgen::InsensitiveStr::Ascii("uepd"),
        dictgen::InsensitiveStr::Ascii("upd"),
        dictgen::InsensitiveStr::Ascii("upe"),
        dictgen::InsensitiveStr::Ascii("upes"),
        dictgen::InsensitiveStr::Ascii("upped"),
        dictgen::InsensitiveStr::Ascii("upping"),
        dictgen::InsensitiveStr::Ascii("upt"),
        dictgen::InsensitiveStr::Ascii("wtesk"),
        dictgen::InsensitiveStr::Ascii("wteskly"),
    ],
    values: &[
        &["global"],
        &["globally"],
        &["geometry"],
        &["gruesome"],
        &["gruesomely"],
        &["gruesome"],
        &["gruesome"],
        &["group"],
        &["grouped"],
        &["grouping"],
        &["groups"],
        &["group", "drop"],
        &["group"],
        &["grouping"],
        &["groups", "gropes"],
        &["groceries"],
        &["grocery"],
        &["growth"],
        &["groundbreaking"],
        &["groupby"],
        &["groundbreaking"],
        &["grouped"],
        &["grouped"],
        &["group", "grouped"],
        &["groups", "grouped"],
        &["grouped"],
        &["grouping"],
        &["grouped"],
        &["grotesque"],
        &["grotesquely"],
    ],
    range: 1..=11,
};

static WORD_GRI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_GRI_CHILDREN),
    value: None,
};

pub static WORD_GRI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("affe"),
        dictgen::InsensitiveStr::Ascii("dles"),
        dictgen::InsensitiveStr::Ascii("eifng"),
        dictgen::InsensitiveStr::Ascii("evences"),
        dictgen::InsensitiveStr::Ascii("feing"),
        dictgen::InsensitiveStr::Ascii("gorian"),
        dictgen::InsensitiveStr::Ascii("lfriend"),
        dictgen::InsensitiveStr::Ascii("lfriends"),
        dictgen::InsensitiveStr::Ascii("llig"),
        dictgen::InsensitiveStr::Ascii("ngeworthy"),
        dictgen::InsensitiveStr::Ascii("zzlay"),
        dictgen::InsensitiveStr::Ascii("zzley"),
    ],
    values: &[
        &["giraffe"],
        &["griddles"],
        &["griefing"],
        &["grievances"],
        &["griefing"],
        &["gregorian"],
        &["girlfriend"],
        &["girlfriends"],
        &["grilling"],
        &["cringeworthy"],
        &["grizzly"],
        &["grizzly"],
    ],
    range: 4..=9,
};

static WORD_GRE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_GRE_CHILDREN),
    value: None,
};

pub static WORD_GRE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ande"),
        dictgen::InsensitiveStr::Ascii("andes"),
        dictgen::InsensitiveStr::Ascii("ate"),
        dictgen::InsensitiveStr::Ascii("ated"),
        dictgen::InsensitiveStr::Ascii("atful"),
        dictgen::InsensitiveStr::Ascii("atfull"),
        dictgen::InsensitiveStr::Ascii("atfully"),
        dictgen::InsensitiveStr::Ascii("ather"),
        dictgen::InsensitiveStr::Ascii("enalnd"),
        dictgen::InsensitiveStr::Ascii("eneer"),
        dictgen::InsensitiveStr::Ascii("enhoe"),
        dictgen::InsensitiveStr::Ascii("enhosue"),
        dictgen::InsensitiveStr::Ascii("enlad"),
        dictgen::InsensitiveStr::Ascii("enore"),
        dictgen::InsensitiveStr::Ascii("if"),
        dictgen::InsensitiveStr::Ascii("naders"),
        dictgen::InsensitiveStr::Ascii("nads"),
        dictgen::InsensitiveStr::Ascii("neer"),
        dictgen::InsensitiveStr::Ascii("phic"),
        dictgen::InsensitiveStr::Ascii("stest"),
        dictgen::InsensitiveStr::Ascii("usome"),
        dictgen::InsensitiveStr::Ascii("viances"),
        dictgen::InsensitiveStr::Ascii("ysacles"),
    ],
    values: &[
        &["grenade"],
        &["grenades"],
        &["greater", "create", "grate", "great"],
        &["greater", "grated", "graded"],
        &["grateful"],
        &["grateful", "gratefully"],
        &["gratefully"],
        &["greater"],
        &["greenland"],
        &["greener"],
        &["greenhouse"],
        &["greenhouse"],
        &["greenland"],
        &["greener"],
        &["grief"],
        &["grenades"],
        &["grenades"],
        &["greener"],
        &["graphic"],
        &["greatest"],
        &["gruesome"],
        &["grievances"],
        &["greyscales"],
    ],
    range: 2..=7,
};

static WORD_GRB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_GRB_CHILDREN),
    value: None,
};

pub static WORD_GRB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ber")],
    values: &[&["grabber"]],
    range: 3..=3,
};

static WORD_GRA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_GRA_CHILDREN),
    value: None,
};

static WORD_GRA_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    Some(&WORD_GRAB_NODE),
    Some(&WORD_GRAC_NODE),
    Some(&WORD_GRAD_NODE),
    Some(&WORD_GRAE_NODE),
    Some(&WORD_GRAF_NODE),
    None,
    Some(&WORD_GRAH_NODE),
    Some(&WORD_GRAI_NODE),
    None,
    None,
    None,
    Some(&WORD_GRAM_NODE),
    Some(&WORD_GRAN_NODE),
    Some(&WORD_GRAO_NODE),
    Some(&WORD_GRAP_NODE),
    None,
    None,
    Some(&WORD_GRAS_NODE),
    Some(&WORD_GRAT_NODE),
    Some(&WORD_GRAU_NODE),
    Some(&WORD_GRAV_NODE),
    None,
    None,
    None,
    None,
];

static WORD_GRAV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_GRAV_CHILDREN),
    value: None,
};

pub static WORD_GRAV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("itacional"),
        dictgen::InsensitiveStr::Ascii("itaitonal"),
        dictgen::InsensitiveStr::Ascii("itatie"),
        dictgen::InsensitiveStr::Ascii("itatiei"),
        dictgen::InsensitiveStr::Ascii("itationnal"),
        dictgen::InsensitiveStr::Ascii("itiation"),
    ],
    values: &[
        &["gravitational"],
        &["gravitational"],
        &["gravitate"],
        &["gravitate"],
        &["gravitational"],
        &["gravitation"],
    ],
    range: 6..=10,
};

static WORD_GRAU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_GRAU_CHILDREN),
    value: None,
};

pub static WORD_GRAU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("dally"),
        dictgen::InsensitiveStr::Ascii("dates"),
        dictgen::InsensitiveStr::Ascii("dating"),
        dictgen::InsensitiveStr::Ascii("dation"),
    ],
    values: &[
        &["gradually"],
        &["graduates"],
        &["graduating"],
        &["graduation"],
    ],
    range: 5..=6,
};

static WORD_GRAT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_GRAT_CHILDREN),
    value: Some(&["great"]),
};

pub static WORD_GRAT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("efull"),
        dictgen::InsensitiveStr::Ascii("ificacion"),
        dictgen::InsensitiveStr::Ascii("ificaiton"),
        dictgen::InsensitiveStr::Ascii("ituous"),
        dictgen::InsensitiveStr::Ascii("iutous"),
        dictgen::InsensitiveStr::Ascii("ivate"),
        dictgen::InsensitiveStr::Ascii("ivational"),
        dictgen::InsensitiveStr::Ascii("uidous"),
        dictgen::InsensitiveStr::Ascii("uitious"),
        dictgen::InsensitiveStr::Ascii("uituos"),
        dictgen::InsensitiveStr::Ascii("uituous"),
        dictgen::InsensitiveStr::Ascii("utious"),
        dictgen::InsensitiveStr::Ascii("utiously"),
    ],
    values: &[
        &["grateful"],
        &["gratification"],
        &["gratification"],
        &["gratuitous"],
        &["gratuitous"],
        &["gravitate"],
        &["gravitational"],
        &["gratuitous"],
        &["gratuitous"],
        &["gratuitous"],
        &["gratuitous"],
        &["gratuitous"],
        &["gratuitously"],
    ],
    range: 5..=9,
};

static WORD_GRAS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_GRAS_CHILDREN),
    value: None,
};

pub static WORD_GRAS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("srooots"),
        dictgen::InsensitiveStr::Ascii("srooters"),
    ],
    values: &[&["grassroots"], &["grassroots"]],
    range: 7..=8,
};

static WORD_GRAP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_GRAP_CHILDREN),
    value: None,
};

pub static WORD_GRAP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("efriut"),
        dictgen::InsensitiveStr::Ascii("efrukt"),
        dictgen::InsensitiveStr::Ascii("gics"),
        dictgen::InsensitiveStr::Ascii("hcially"),
        dictgen::InsensitiveStr::Ascii("hcis"),
        dictgen::InsensitiveStr::Ascii("hicaly"),
        dictgen::InsensitiveStr::Ascii("hiclly"),
        dictgen::InsensitiveStr::Ascii("hie"),
        dictgen::InsensitiveStr::Ascii("his"),
        dictgen::InsensitiveStr::Ascii("ic"),
        dictgen::InsensitiveStr::Ascii("ical"),
        dictgen::InsensitiveStr::Ascii("ichs"),
        dictgen::InsensitiveStr::Ascii("ics"),
        dictgen::InsensitiveStr::Ascii("pel"),
        dictgen::InsensitiveStr::Ascii("pnel"),
    ],
    values: &[
        &["grapefruit"],
        &["grapefruit"],
        &["graphics"],
        &["graphically"],
        &["graphics"],
        &["graphically"],
        &["graphically"],
        &["graphite"],
        &["graphics"],
        &["graphic"],
        &["graphical"],
        &["graphics"],
        &["graphics"],
        &["grapple"],
        &["grapple"],
    ],
    range: 2..=7,
};

static WORD_GRAO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_GRAO_CHILDREN),
    value: None,
};

pub static WORD_GRAO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("h")],
    values: &[&["graph"]],
    range: 1..=1,
};

static WORD_GRAN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_GRAN_CHILDREN),
    value: None,
};

pub static WORD_GRAN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("children"),
        dictgen::InsensitiveStr::Ascii("dchilden"),
        dictgen::InsensitiveStr::Ascii("dchilder"),
        dictgen::InsensitiveStr::Ascii("dchilderen"),
        dictgen::InsensitiveStr::Ascii("dchildern"),
        dictgen::InsensitiveStr::Ascii("dchilren"),
        dictgen::InsensitiveStr::Ascii("deeos"),
        dictgen::InsensitiveStr::Ascii("dise"),
        dictgen::InsensitiveStr::Ascii("dised"),
        dictgen::InsensitiveStr::Ascii("disement"),
        dictgen::InsensitiveStr::Ascii("diser"),
        dictgen::InsensitiveStr::Ascii("dises"),
        dictgen::InsensitiveStr::Ascii("dising"),
        dictgen::InsensitiveStr::Ascii("dize"),
        dictgen::InsensitiveStr::Ascii("dized"),
        dictgen::InsensitiveStr::Ascii("dizement"),
        dictgen::InsensitiveStr::Ascii("dizer"),
        dictgen::InsensitiveStr::Ascii("dizes"),
        dictgen::InsensitiveStr::Ascii("dizing"),
        dictgen::InsensitiveStr::Ascii("iet"),
        dictgen::InsensitiveStr::Ascii("ilarity"),
        dictgen::InsensitiveStr::Ascii("jure"),
        dictgen::InsensitiveStr::Ascii("olla"),
        dictgen::InsensitiveStr::Ascii("tie"),
        dictgen::InsensitiveStr::Ascii("uality"),
        dictgen::InsensitiveStr::Ascii("ualtiry"),
        dictgen::InsensitiveStr::Ascii("ularty"),
        dictgen::InsensitiveStr::Ascii("ulatiry"),
    ],
    values: &[
        &["grandchildren"],
        &["grandchildren"],
        &["grandchildren"],
        &["grandchildren"],
        &["grandchildren"],
        &["grandchildren"],
        &["grandiose"],
        &["aggrandise"],
        &["aggrandised"],
        &["aggrandisement"],
        &["aggrandiser"],
        &["aggrandises"],
        &["aggrandising"],
        &["aggrandize"],
        &["aggrandized"],
        &["aggrandizement"],
        &["aggrandizer"],
        &["aggrandizes"],
        &["aggrandizing"],
        &["granite"],
        &["granularity"],
        &["grandeur"],
        &["granola"],
        &["granite"],
        &["granularity"],
        &["granularity"],
        &["granularity"],
        &["granularity"],
    ],
    range: 3..=10,
};

static WORD_GRAM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_GRAM_CHILDREN),
    value: None,
};

pub static WORD_GRAM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ar"),
        dictgen::InsensitiveStr::Ascii("atically"),
        dictgen::InsensitiveStr::Ascii("marical"),
        dictgen::InsensitiveStr::Ascii("marically"),
        dictgen::InsensitiveStr::Ascii("martical"),
        dictgen::InsensitiveStr::Ascii("maticaal"),
        dictgen::InsensitiveStr::Ascii("maticallity"),
        dictgen::InsensitiveStr::Ascii("maticaly"),
        dictgen::InsensitiveStr::Ascii("maticly"),
        dictgen::InsensitiveStr::Ascii("mer"),
        dictgen::InsensitiveStr::Ascii("mers"),
        dictgen::InsensitiveStr::Ascii("mitical"),
    ],
    values: &[
        &["grammar"],
        &["grammatically"],
        &["grammatical"],
        &["grammatically"],
        &["grammatical"],
        &["grammatical"],
        &["grammatically"],
        &["grammatically"],
        &["grammatical"],
        &["grammar"],
        &["grammars"],
        &["grammatical"],
    ],
    range: 2..=11,
};

static WORD_GRAI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_GRAI_CHILDREN),
    value: None,
};

pub static WORD_GRAI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("dent"),
        dictgen::InsensitiveStr::Ascii("neries"),
        dictgen::InsensitiveStr::Ascii("nery"),
        dictgen::InsensitiveStr::Ascii("nte"),
    ],
    values: &[&["gradient"], &["granaries"], &["granary"], &["granite"]],
    range: 3..=6,
};

static WORD_GRAH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_GRAH_CHILDREN),
    value: None,
};

pub static WORD_GRAH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ic"),
        dictgen::InsensitiveStr::Ascii("ical"),
        dictgen::InsensitiveStr::Ascii("ics"),
        dictgen::InsensitiveStr::Ascii("pic"),
        dictgen::InsensitiveStr::Ascii("pical"),
        dictgen::InsensitiveStr::Ascii("pically"),
        dictgen::InsensitiveStr::Ascii("pics"),
        dictgen::InsensitiveStr::Ascii("pite"),
    ],
    values: &[
        &["graphic"],
        &["graphical"],
        &["graphics"],
        &["graphic"],
        &["graphical"],
        &["graphically"],
        &["graphics"],
        &["graphite"],
    ],
    range: 2..=7,
};

static WORD_GRAF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_GRAF_CHILDREN),
    value: None,
};

pub static WORD_GRAF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ics"),
        dictgen::InsensitiveStr::Ascii("ield"),
        dictgen::InsensitiveStr::Ascii("itti"),
    ],
    values: &[&["graphics"], &["garfield"], &["graffiti"]],
    range: 3..=4,
};

static WORD_GRAE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_GRAE_CHILDREN),
    value: None,
};

pub static WORD_GRAE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("t")],
    values: &[&["great"]],
    range: 1..=1,
};

static WORD_GRAD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_GRAD_CHILDREN),
    value: None,
};

pub static WORD_GRAD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("iant"),
        dictgen::InsensitiveStr::Ascii("iants"),
        dictgen::InsensitiveStr::Ascii("iating"),
        dictgen::InsensitiveStr::Ascii("iation"),
        dictgen::InsensitiveStr::Ascii("ification"),
        dictgen::InsensitiveStr::Ascii("uacion"),
        dictgen::InsensitiveStr::Ascii("ualy"),
        dictgen::InsensitiveStr::Ascii("uaste"),
        dictgen::InsensitiveStr::Ascii("uatin"),
    ],
    values: &[
        &["gradient", "radiant"],
        &["gradients"],
        &["graduating"],
        &["graduation"],
        &["gratification"],
        &["graduation"],
        &["gradually"],
        &["graduates"],
        &["graduation"],
    ],
    range: 4..=9,
};

static WORD_GRAC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_GRAC_CHILDREN),
    value: None,
};

pub static WORD_GRAC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("efull"),
        dictgen::InsensitiveStr::Ascii("efullly"),
        dictgen::InsensitiveStr::Ascii("efuly"),
    ],
    values: &[&["graceful"], &["gracefully"], &["gracefully"]],
    range: 5..=7,
};

static WORD_GRAB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_GRAB_CHILDREN),
    value: None,
};

pub static WORD_GRAB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("age"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("ing"),
    ],
    values: &[&["garbage"], &["grabbed"], &["grabbing"]],
    range: 2..=3,
};

static WORD_GP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_GP_CHILDREN),
    value: None,
};

pub static WORD_GP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ysies")],
    values: &[&["gypsies"]],
    range: 5..=5,
};

static WORD_GO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_GO_CHILDREN),
    value: None,
};

static WORD_GO_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_GOA_NODE),
    Some(&WORD_GOB_NODE),
    Some(&WORD_GOC_NODE),
    Some(&WORD_GOD_NODE),
    Some(&WORD_GOE_NODE),
    None,
    Some(&WORD_GOG_NODE),
    None,
    Some(&WORD_GOI_NODE),
    None,
    None,
    Some(&WORD_GOL_NODE),
    None,
    Some(&WORD_GON_NODE),
    Some(&WORD_GOO_NODE),
    None,
    None,
    Some(&WORD_GOR_NODE),
    Some(&WORD_GOS_NODE),
    Some(&WORD_GOT_NODE),
    Some(&WORD_GOU_NODE),
    Some(&WORD_GOV_NODE),
    None,
    None,
    None,
    None,
];

static WORD_GOV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_GOV_CHILDREN),
    value: None,
};

pub static WORD_GOV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ement"),
        dictgen::InsensitiveStr::Ascii("emrent"),
        dictgen::InsensitiveStr::Ascii("enment"),
        dictgen::InsensitiveStr::Ascii("enor"),
        dictgen::InsensitiveStr::Ascii("enrment"),
        dictgen::InsensitiveStr::Ascii("enrments"),
        dictgen::InsensitiveStr::Ascii("erance"),
        dictgen::InsensitiveStr::Ascii("eremnt"),
        dictgen::InsensitiveStr::Ascii("erend"),
        dictgen::InsensitiveStr::Ascii("ermenet"),
        dictgen::InsensitiveStr::Ascii("erment"),
        dictgen::InsensitiveStr::Ascii("ermental"),
        dictgen::InsensitiveStr::Ascii("ermet"),
        dictgen::InsensitiveStr::Ascii("ermetn"),
        dictgen::InsensitiveStr::Ascii("ermnent"),
        dictgen::InsensitiveStr::Ascii("ermnet"),
        dictgen::InsensitiveStr::Ascii("ermnment"),
        dictgen::InsensitiveStr::Ascii("ernemnt"),
        dictgen::InsensitiveStr::Ascii("ernemntal"),
        dictgen::InsensitiveStr::Ascii("ernemnts"),
        dictgen::InsensitiveStr::Ascii("ernened"),
        dictgen::InsensitiveStr::Ascii("erner"),
        dictgen::InsensitiveStr::Ascii("ernered"),
        dictgen::InsensitiveStr::Ascii("ernmanet"),
        dictgen::InsensitiveStr::Ascii("ernmant"),
        dictgen::InsensitiveStr::Ascii("ernmeant"),
        dictgen::InsensitiveStr::Ascii("ernmential"),
        dictgen::InsensitiveStr::Ascii("ernmently"),
        dictgen::InsensitiveStr::Ascii("ernmet"),
        dictgen::InsensitiveStr::Ascii("ernmetn"),
        dictgen::InsensitiveStr::Ascii("ernmnet"),
        dictgen::InsensitiveStr::Ascii("nerment"),
        dictgen::InsensitiveStr::Ascii("oner"),
        dictgen::InsensitiveStr::Ascii("oners"),
        dictgen::InsensitiveStr::Ascii("orment"),
        dictgen::InsensitiveStr::Ascii("ormental"),
        dictgen::InsensitiveStr::Ascii("ornment"),
        dictgen::InsensitiveStr::Ascii("rement"),
    ],
    values: &[
        &["government"],
        &["government"],
        &["government"],
        &["governor"],
        &["government"],
        &["governments"],
        &["governance"],
        &["government"],
        &["governed"],
        &["government"],
        &["government"],
        &["governmental"],
        &["government"],
        &["government"],
        &["governments"],
        &["government"],
        &["government"],
        &["government"],
        &["governmental"],
        &["governments"],
        &["governed"],
        &["governor"],
        &["governed"],
        &["governmental"],
        &["governmental"],
        &["governmental"],
        &["governmental"],
        &["governmental"],
        &["governments"],
        &["governments"],
        &["government"],
        &["government"],
        &["governor"],
        &["governors"],
        &["government"],
        &["governmental"],
        &["government"],
        &["government"],
    ],
    range: 4..=10,
};

static WORD_GOU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_GOU_CHILDREN),
    value: None,
};

pub static WORD_GOU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("p"),
        dictgen::InsensitiveStr::Ascii("ped"),
        dictgen::InsensitiveStr::Ascii("ps"),
        dictgen::InsensitiveStr::Ascii("rmelt"),
        dictgen::InsensitiveStr::Ascii("rment"),
        dictgen::InsensitiveStr::Ascii("vener"),
    ],
    values: &[
        &["group"],
        &["grouped"],
        &["groups"],
        &["gourmet"],
        &["gourmet"],
        &["governor"],
    ],
    range: 1..=5,
};

static WORD_GOT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_GOT_CHILDREN),
    value: None,
};

pub static WORD_GOT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ee"),
        dictgen::InsensitiveStr::Ascii("ees"),
        dictgen::InsensitiveStr::Ascii("henberg"),
        dictgen::InsensitiveStr::Ascii("tleib"),
    ],
    values: &[&["goatee"], &["goatees"], &["gothenburg"], &["gottlieb"]],
    range: 2..=7,
};

static WORD_GOS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_GOS_CHILDREN),
    value: None,
};

pub static WORD_GOS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("epls"),
        dictgen::InsensitiveStr::Ascii("pells"),
        dictgen::InsensitiveStr::Ascii("ples"),
        dictgen::InsensitiveStr::Ascii("t"),
    ],
    values: &[&["gospels"], &["gospels"], &["gospels"], &["ghost"]],
    range: 1..=5,
};

static WORD_GOR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_GOR_CHILDREN),
    value: None,
};

pub static WORD_GOR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("d"),
        dictgen::InsensitiveStr::Ascii("egous"),
        dictgen::InsensitiveStr::Ascii("eshadowing"),
        dictgen::InsensitiveStr::Ascii("goeus"),
        dictgen::InsensitiveStr::Ascii("illia"),
        dictgen::InsensitiveStr::Ascii("illla"),
        dictgen::InsensitiveStr::Ascii("may"),
        dictgen::InsensitiveStr::Ascii("ry"),
        dictgen::InsensitiveStr::Ascii("umet"),
        dictgen::InsensitiveStr::Ascii("up"),
        dictgen::InsensitiveStr::Ascii("uped"),
        dictgen::InsensitiveStr::Ascii("uping"),
        dictgen::InsensitiveStr::Ascii("ups"),
        dictgen::InsensitiveStr::Ascii("vement"),
        dictgen::InsensitiveStr::Ascii("w"),
        dictgen::InsensitiveStr::Ascii("wing"),
        dictgen::InsensitiveStr::Ascii("ws"),
    ],
    values: &[
        &["gourd"],
        &["gorgeous"],
        &["foreshadowing"],
        &["gorgeous"],
        &["gorilla"],
        &["gorilla"],
        &["gourmet"],
        &["gory"],
        &["gourmet"],
        &["group"],
        &["grouped"],
        &["grouping"],
        &["groups"],
        &["government"],
        &["gore", "grow"],
        &["growing"],
        &["grows"],
    ],
    range: 1..=10,
};

static WORD_GOO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_GOO_CHILDREN),
    value: None,
};

pub static WORD_GOO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("dlcuk"),
        dictgen::InsensitiveStr::Ascii("dluk"),
        dictgen::InsensitiveStr::Ascii("l"),
        dictgen::InsensitiveStr::Ascii("sebumbps"),
        dictgen::InsensitiveStr::Ascii("sebumbs"),
        dictgen::InsensitiveStr::Ascii("sebums"),
        dictgen::InsensitiveStr::Ascii("segumps"),
        dictgen::InsensitiveStr::Ascii("sepumps"),
    ],
    values: &[
        &["goodluck"],
        &["goodluck"],
        &["ghoul"],
        &["goosebumps"],
        &["goosebumps"],
        &["goosebumps"],
        &["goosebumps"],
        &["goosebumps"],
    ],
    range: 1..=8,
};

static WORD_GON_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_GON_CHILDREN),
    value: None,
};

pub static WORD_GON_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ewidl"),
        dictgen::InsensitiveStr::Ascii("gratulations"),
        dictgen::InsensitiveStr::Ascii("ig"),
    ],
    values: &[&["gonewild"], &["congratulations"], &["going"]],
    range: 2..=12,
};

static WORD_GOL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_GOL_CHILDREN),
    value: None,
};

pub static WORD_GOL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aith"),
        dictgen::InsensitiveStr::Ascii("akeeper"),
        dictgen::InsensitiveStr::Ascii("bal"),
        dictgen::InsensitiveStr::Ascii("bally"),
        dictgen::InsensitiveStr::Ascii("baly"),
        dictgen::InsensitiveStr::Ascii("bins"),
        dictgen::InsensitiveStr::Ascii("damn"),
        dictgen::InsensitiveStr::Ascii("dbeg"),
        dictgen::InsensitiveStr::Ascii("dburger"),
        dictgen::InsensitiveStr::Ascii("dfisch"),
        dictgen::InsensitiveStr::Ascii("difsh"),
        dictgen::InsensitiveStr::Ascii("dike"),
        dictgen::InsensitiveStr::Ascii("itah"),
    ],
    values: &[
        &["goliath"],
        &["goalkeeper"],
        &["global"],
        &["globally"],
        &["globally"],
        &["goblins"],
        &["goldman"],
        &["goldberg"],
        &["goldberg"],
        &["goldfish"],
        &["goldfish"],
        &["godlike"],
        &["goliath"],
    ],
    range: 3..=7,
};

static WORD_GOI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_GOI_CHILDREN),
    value: None,
};

pub static WORD_GOI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("gn"),
        dictgen::InsensitiveStr::Ascii("lath"),
        dictgen::InsensitiveStr::Ascii("n"),
        dictgen::InsensitiveStr::Ascii("nd"),
    ],
    values: &[&["going"], &["goliath"], &["going"], &["going"]],
    range: 1..=4,
};

static WORD_GOG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_GOG_CHILDREN),
    value: None,
};

pub static WORD_GOG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ether"),
        dictgen::InsensitiveStr::Ascii("in"),
    ],
    values: &[&["together"], &["going", "gauguin"]],
    range: 2..=5,
};

static WORD_GOE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_GOE_CHILDREN),
    value: None,
};

pub static WORD_GOE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("graphic"),
        dictgen::InsensitiveStr::Ascii("graphical"),
        dictgen::InsensitiveStr::Ascii("graphically"),
        dictgen::InsensitiveStr::Ascii("graphy"),
        dictgen::InsensitiveStr::Ascii("metries"),
        dictgen::InsensitiveStr::Ascii("rgia"),
        dictgen::InsensitiveStr::Ascii("ss"),
    ],
    values: &[
        &["geographic"],
        &["geographical"],
        &["geographically"],
        &["geography"],
        &["geometries"],
        &["georgia"],
        &["goes"],
    ],
    range: 2..=11,
};

static WORD_GOD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_GOD_CHILDREN),
    value: None,
};

pub static WORD_GOD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("afther"),
        dictgen::InsensitiveStr::Ascii("dammn"),
        dictgen::InsensitiveStr::Ascii("dammt"),
        dictgen::InsensitiveStr::Ascii("danm"),
        dictgen::InsensitiveStr::Ascii("dman"),
        dictgen::InsensitiveStr::Ascii("ess"),
        dictgen::InsensitiveStr::Ascii("esses"),
        dictgen::InsensitiveStr::Ascii("lberg"),
        dictgen::InsensitiveStr::Ascii("lfish"),
        dictgen::InsensitiveStr::Ascii("liek"),
        dictgen::InsensitiveStr::Ascii("lman"),
        dictgen::InsensitiveStr::Ascii("ounov"),
        dictgen::InsensitiveStr::Ascii("pseed"),
        dictgen::InsensitiveStr::Ascii("sped"),
        dictgen::InsensitiveStr::Ascii("spede"),
        dictgen::InsensitiveStr::Ascii("speeed"),
    ],
    values: &[
        &["godfather"],
        &["goddamn"],
        &["goddammit"],
        &["goddam"],
        &["goddamn"],
        &["goddess"],
        &["goddesses"],
        &["goldberg"],
        &["goldfish"],
        &["godlike"],
        &["goldman"],
        &["godunov"],
        &["godspeed"],
        &["godspeed"],
        &["godspeed"],
        &["godspeed"],
    ],
    range: 3..=6,
};

static WORD_GOC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_GOC_CHILDREN),
    value: None,
};

pub static WORD_GOC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("de")],
    values: &[&["gcode"]],
    range: 2..=2,
};

static WORD_GOB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_GOB_CHILDREN),
    value: None,
};

pub static WORD_GOB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("al"),
        dictgen::InsensitiveStr::Ascii("lings"),
    ],
    values: &[&["global"], &["goblins"]],
    range: 2..=5,
};

static WORD_GOA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_GOA_CHILDREN),
    value: None,
};

pub static WORD_GOA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("lkeaper"),
        dictgen::InsensitiveStr::Ascii("lkeepr"),
        dictgen::InsensitiveStr::Ascii("lkeeprs"),
        dictgen::InsensitiveStr::Ascii("lkepeer"),
    ],
    values: &[
        &["goalkeeper"],
        &["goalkeeper"],
        &["goalkeeper"],
        &["goalkeeper"],
    ],
    range: 6..=7,
};

static WORD_GN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_GN_CHILDREN),
    value: None,
};

pub static WORD_GN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aking"),
        dictgen::InsensitiveStr::Ascii("awwed"),
        dictgen::InsensitiveStr::Ascii("eral"),
        dictgen::InsensitiveStr::Ascii("erally"),
        dictgen::InsensitiveStr::Ascii("erals"),
        dictgen::InsensitiveStr::Ascii("erate"),
        dictgen::InsensitiveStr::Ascii("erated"),
        dictgen::InsensitiveStr::Ascii("erates"),
        dictgen::InsensitiveStr::Ascii("erating"),
        dictgen::InsensitiveStr::Ascii("eration"),
        dictgen::InsensitiveStr::Ascii("erations"),
        dictgen::InsensitiveStr::Ascii("eric"),
        dictgen::InsensitiveStr::Ascii("ored"),
        dictgen::InsensitiveStr::Ascii("orung"),
    ],
    values: &[
        &["ganking"],
        &["gnawed"],
        &["general"],
        &["generally"],
        &["generals"],
        &["generate"],
        &["generated"],
        &["generates"],
        &["generating"],
        &["generation"],
        &["generations"],
        &["generic"],
        &["ignored"],
        &["ignoring"],
    ],
    range: 4..=8,
};

static WORD_GM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_GM_CHILDREN),
    value: None,
};

pub static WORD_GM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("aertag")],
    values: &[&["gamertag"]],
    range: 6..=6,
};

static WORD_GL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_GL_CHILDREN),
    value: None,
};

pub static WORD_GL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("adiatr"),
        dictgen::InsensitiveStr::Ascii("agsow"),
        dictgen::InsensitiveStr::Ascii("aicer"),
        dictgen::InsensitiveStr::Ascii("ichted"),
        dictgen::InsensitiveStr::Ascii("ichtes"),
        dictgen::InsensitiveStr::Ascii("icthed"),
        dictgen::InsensitiveStr::Ascii("icthes"),
        dictgen::InsensitiveStr::Ascii("icthy"),
        dictgen::InsensitiveStr::Ascii("ight"),
        dictgen::InsensitiveStr::Ascii("impes"),
        dictgen::InsensitiveStr::Ascii("imspe"),
        dictgen::InsensitiveStr::Ascii("ipmse"),
        dictgen::InsensitiveStr::Ascii("itchd"),
        dictgen::InsensitiveStr::Ascii("itchey"),
        dictgen::InsensitiveStr::Ascii("itchly"),
        dictgen::InsensitiveStr::Ascii("itchs"),
        dictgen::InsensitiveStr::Ascii("itchty"),
        dictgen::InsensitiveStr::Ascii("ithced"),
        dictgen::InsensitiveStr::Ascii("ithces"),
        dictgen::InsensitiveStr::Ascii("ithcy"),
        dictgen::InsensitiveStr::Ascii("oab"),
        dictgen::InsensitiveStr::Ascii("oabal"),
        dictgen::InsensitiveStr::Ascii("oabl"),
        dictgen::InsensitiveStr::Ascii("oablly"),
        dictgen::InsensitiveStr::Ascii("oassaries"),
        dictgen::InsensitiveStr::Ascii("oassary"),
        dictgen::InsensitiveStr::Ascii("oba"),
        dictgen::InsensitiveStr::Ascii("obablly"),
        dictgen::InsensitiveStr::Ascii("obaly"),
        dictgen::InsensitiveStr::Ascii("obas"),
        dictgen::InsensitiveStr::Ascii("obbal"),
        dictgen::InsensitiveStr::Ascii("obel"),
        dictgen::InsensitiveStr::Ascii("oblal"),
        dictgen::InsensitiveStr::Ascii("oblaly"),
        dictgen::InsensitiveStr::Ascii("odberg"),
        dictgen::InsensitiveStr::Ascii("odfish"),
        dictgen::InsensitiveStr::Ascii("oiath"),
        dictgen::InsensitiveStr::Ascii("orfied"),
        dictgen::InsensitiveStr::Ascii("orifierad"),
        dictgen::InsensitiveStr::Ascii("orifindel"),
        dictgen::InsensitiveStr::Ascii("orios"),
        dictgen::InsensitiveStr::Ascii("oriuos"),
        dictgen::InsensitiveStr::Ascii("pyh"),
        dictgen::InsensitiveStr::Ascii("pyhs"),
        dictgen::InsensitiveStr::Ascii("tiched"),
        dictgen::InsensitiveStr::Ascii("tiches"),
        dictgen::InsensitiveStr::Ascii("tichy"),
        dictgen::InsensitiveStr::Ascii("yh"),
        dictgen::InsensitiveStr::Ascii("yhs"),
        dictgen::InsensitiveStr::Ascii("yped"),
        dictgen::InsensitiveStr::Ascii("yphes"),
        dictgen::InsensitiveStr::Ascii("yping"),
        dictgen::InsensitiveStr::Ascii("yserin"),
    ],
    values: &[
        &["gladiator"],
        &["glasgow"],
        &["glacier"],
        &["glitched"],
        &["glitches"],
        &["glitched"],
        &["glitches"],
        &["glitchy"],
        &["flight"],
        &["glimpse"],
        &["glimpse"],
        &["glimpse"],
        &["glitched"],
        &["glitchy"],
        &["glitchy"],
        &["glitches"],
        &["glitchy"],
        &["glitched"],
        &["glitches"],
        &["glitchy"],
        &["globe"],
        &["global"],
        &["global"],
        &["globally"],
        &["glossaries"],
        &["glossary"],
        &["global"],
        &["globally"],
        &["globally"],
        &["globals"],
        &["global"],
        &["global"],
        &["global"],
        &["globally"],
        &["goldberg"],
        &["goldfish"],
        &["goliath"],
        &["glorified"],
        &["glorified"],
        &["glorified"],
        &["glorious"],
        &["glorious"],
        &["glyph"],
        &["glyphs"],
        &["glitched"],
        &["glitches"],
        &["glitchy"],
        &["glyph"],
        &["glyphs"],
        &["glyphed"],
        &["glyphs"],
        &["glyphing"],
        &["glycerin"],
    ],
    range: 2..=9,
};

static WORD_GI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_GI_CHILDREN),
    value: None,
};

pub static WORD_GI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("agbyte"),
        dictgen::InsensitiveStr::Ascii("en"),
        dictgen::InsensitiveStr::Ascii("gabtye"),
        dictgen::InsensitiveStr::Ascii("gabye"),
        dictgen::InsensitiveStr::Ascii("gantisch"),
        dictgen::InsensitiveStr::Ascii("gaybte"),
        dictgen::InsensitiveStr::Ascii("gbayte"),
        dictgen::InsensitiveStr::Ascii("gibit"),
        dictgen::InsensitiveStr::Ascii("gnatic"),
        dictgen::InsensitiveStr::Ascii("lotine"),
        dictgen::InsensitiveStr::Ascii("ltched"),
        dictgen::InsensitiveStr::Ascii("ltches"),
        dictgen::InsensitiveStr::Ascii("ltchy"),
        dictgen::InsensitiveStr::Ascii("lty"),
        dictgen::InsensitiveStr::Ascii("mmickers"),
        dictgen::InsensitiveStr::Ascii("mmickey"),
        dictgen::InsensitiveStr::Ascii("mmickly"),
        dictgen::InsensitiveStr::Ascii("mmics"),
        dictgen::InsensitiveStr::Ascii("mmicy"),
        dictgen::InsensitiveStr::Ascii("nee"),
        dictgen::InsensitiveStr::Ascii("ngam"),
        dictgen::InsensitiveStr::Ascii("oen"),
        dictgen::InsensitiveStr::Ascii("r"),
        dictgen::InsensitiveStr::Ascii("rafes"),
        dictgen::InsensitiveStr::Ascii("rafffe"),
        dictgen::InsensitiveStr::Ascii("refing"),
        dictgen::InsensitiveStr::Ascii("rlfirend"),
        dictgen::InsensitiveStr::Ascii("rlfirends"),
        dictgen::InsensitiveStr::Ascii("rlfreind"),
        dictgen::InsensitiveStr::Ascii("rlfreinds"),
        dictgen::InsensitiveStr::Ascii("rlfried"),
        dictgen::InsensitiveStr::Ascii("rlfriens"),
        dictgen::InsensitiveStr::Ascii("rlfrients"),
        dictgen::InsensitiveStr::Ascii("rlfrinds"),
        dictgen::InsensitiveStr::Ascii("rlfrined"),
        dictgen::InsensitiveStr::Ascii("rlling"),
        dictgen::InsensitiveStr::Ascii("rzzly"),
        dictgen::InsensitiveStr::Ascii("ser"),
        dictgen::InsensitiveStr::Ascii("sers"),
        dictgen::InsensitiveStr::Ascii("tar"),
        dictgen::InsensitiveStr::Ascii("tars"),
        dictgen::InsensitiveStr::Ascii("tatributes"),
        dictgen::InsensitiveStr::Ascii("ved"),
        dictgen::InsensitiveStr::Ascii("veing"),
        dictgen::InsensitiveStr::Ascii("vem"),
        dictgen::InsensitiveStr::Ascii("vien"),
        dictgen::InsensitiveStr::Ascii("vne"),
        dictgen::InsensitiveStr::Ascii("vveing"),
        dictgen::InsensitiveStr::Ascii("vven"),
        dictgen::InsensitiveStr::Ascii("vving"),
    ],
    values: &[
        &["gigabyte"],
        &["given"],
        &["gigabyte"],
        &["gigabyte"],
        &["gigantic"],
        &["gigabyte"],
        &["gigabyte"],
        &["gigabit"],
        &["gigantic"],
        &["guillotine"],
        &["glitched"],
        &["glitches"],
        &["glitchy"],
        &["guilty"],
        &["gimmicks"],
        &["gimmicky"],
        &["gimmicky"],
        &["gimmicks"],
        &["gimmicky"],
        &["guinea"],
        &["gingham"],
        &["given"],
        &["git"],
        &["giraffes"],
        &["giraffe"],
        &["griefing"],
        &["girlfriend"],
        &["girlfriends"],
        &["girlfriend"],
        &["girlfriends"],
        &["girlfriend"],
        &["girlfriends"],
        &["girlfriends"],
        &["girlfriends"],
        &["girlfriends"],
        &["grilling"],
        &["grizzly"],
        &["geyser"],
        &["geysers"],
        &["guitar"],
        &["guitars"],
        &["gitattributes"],
        &["given", "gave"],
        &["giving"],
        &["given"],
        &["given"],
        &["given"],
        &["giving"],
        &["given"],
        &["giving"],
    ],
    range: 1..=10,
};

static WORD_GH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_GH_CHILDREN),
    value: None,
};

pub static WORD_GH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("andi"),
        dictgen::InsensitiveStr::Ascii("ostcript"),
        dictgen::InsensitiveStr::Ascii("ostscipt"),
        dictgen::InsensitiveStr::Ascii("ostscritp"),
        dictgen::InsensitiveStr::Ascii("raphic"),
    ],
    values: &[
        &["gandhi"],
        &["ghostscript"],
        &["ghostscript"],
        &["ghostscript"],
        &["graphic"],
    ],
    range: 4..=9,
};

static WORD_GG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_GG_CHILDREN),
    value: None,
};

pub static WORD_GG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ogle"),
        dictgen::InsensitiveStr::Ascii("ogled"),
        dictgen::InsensitiveStr::Ascii("ogles"),
    ],
    values: &[&["goggle", "google"], &["googled"], &["goggles", "googles"]],
    range: 4..=5,
};

static WORD_GE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_GE_CHILDREN),
    value: None,
};

static WORD_GE_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    None,
    None,
    Some(&WORD_GEE_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_GEM_NODE),
    Some(&WORD_GEN_NODE),
    Some(&WORD_GEO_NODE),
    None,
    None,
    Some(&WORD_GER_NODE),
    Some(&WORD_GES_NODE),
    Some(&WORD_GET_NODE),
    Some(&WORD_GEU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_GEU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_GEU_CHILDREN),
    value: None,
};

pub static WORD_GEU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("rrilla")],
    values: &[&["guerrilla"]],
    range: 6..=6,
};

static WORD_GET_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_GET_CHILDREN),
    value: None,
};

pub static WORD_GET_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("fastproperyvalue"),
        dictgen::InsensitiveStr::Ascii("imezone"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("lael"),
        dictgen::InsensitiveStr::Ascii("oe"),
        dictgen::InsensitiveStr::Ascii("oject"),
        dictgen::InsensitiveStr::Ascii("tetx"),
        dictgen::InsensitiveStr::Ascii("tign"),
        dictgen::InsensitiveStr::Ascii("tings"),
        dictgen::InsensitiveStr::Ascii("titem"),
        dictgen::InsensitiveStr::Ascii("titems"),
        dictgen::InsensitiveStr::Ascii("tter"),
        dictgen::InsensitiveStr::Ascii("tters"),
        dictgen::InsensitiveStr::Ascii("ttext"),
        dictgen::InsensitiveStr::Ascii("ttime"),
        dictgen::InsensitiveStr::Ascii("ttimeofday"),
        dictgen::InsensitiveStr::Ascii("tting"),
    ],
    values: &[
        &["getfastpropertyvalue"],
        &["gettimezone"],
        &["getting"],
        &["getlabel"],
        &["ghetto"],
        &["getobject"],
        &["gettext"],
        &["getting"],
        &["getting"],
        &["getitem"],
        &["getitems"],
        &["getter"],
        &["getters"],
        &["gettext"],
        &["gettime"],
        &["gettimeofday"],
        &["getting"],
    ],
    range: 2..=16,
};

static WORD_GES_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_GES_CHILDREN),
    value: None,
};

pub static WORD_GES_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("s")],
    values: &[&["guess"]],
    range: 1..=1,
};

static WORD_GER_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_GER_CHILDREN),
    value: None,
};

pub static WORD_GER_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aff"),
        dictgen::InsensitiveStr::Ascii("aphics"),
        dictgen::InsensitiveStr::Ascii("at"),
        dictgen::InsensitiveStr::Ascii("ate"),
        dictgen::InsensitiveStr::Ascii("ated"),
        dictgen::InsensitiveStr::Ascii("ates"),
        dictgen::InsensitiveStr::Ascii("ation"),
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("eating"),
        dictgen::InsensitiveStr::Ascii("enate"),
        dictgen::InsensitiveStr::Ascii("enated"),
        dictgen::InsensitiveStr::Ascii("enates"),
        dictgen::InsensitiveStr::Ascii("enating"),
        dictgen::InsensitiveStr::Ascii("enation"),
        dictgen::InsensitiveStr::Ascii("enations"),
        dictgen::InsensitiveStr::Ascii("enic"),
        dictgen::InsensitiveStr::Ascii("enics"),
        dictgen::InsensitiveStr::Ascii("erate"),
        dictgen::InsensitiveStr::Ascii("erated"),
        dictgen::InsensitiveStr::Ascii("illa"),
        dictgen::InsensitiveStr::Ascii("maniac"),
        dictgen::InsensitiveStr::Ascii("manisch"),
        dictgen::InsensitiveStr::Ascii("manos"),
        dictgen::InsensitiveStr::Ascii("manus"),
        dictgen::InsensitiveStr::Ascii("nade"),
        dictgen::InsensitiveStr::Ascii("nades"),
        dictgen::InsensitiveStr::Ascii("nal"),
        dictgen::InsensitiveStr::Ascii("neral"),
        dictgen::InsensitiveStr::Ascii("nerally"),
        dictgen::InsensitiveStr::Ascii("neraly"),
        dictgen::InsensitiveStr::Ascii("nerate"),
        dictgen::InsensitiveStr::Ascii("nerated"),
        dictgen::InsensitiveStr::Ascii("nerates"),
        dictgen::InsensitiveStr::Ascii("nerating"),
        dictgen::InsensitiveStr::Ascii("neration"),
        dictgen::InsensitiveStr::Ascii("nerator"),
        dictgen::InsensitiveStr::Ascii("nerators"),
        dictgen::InsensitiveStr::Ascii("neric"),
        dictgen::InsensitiveStr::Ascii("nerics"),
        dictgen::InsensitiveStr::Ascii("ogia"),
    ],
    values: &[
        &["giraffe"],
        &["graphics"],
        &["great"],
        &["generate", "gyrate"],
        &["generated", "gyrated"],
        &["generates", "gyrates"],
        &["generation"],
        &["gear", "here"],
        &["generating"],
        &["generate"],
        &["generated"],
        &["generates"],
        &["generating"],
        &["generation"],
        &["generations"],
        &["generic"],
        &["generics"],
        &["generate"],
        &["generated"],
        &["guerilla"],
        &["germanic"],
        &["germanic"],
        &["germans"],
        &["germans"],
        &["grenade"],
        &["grenades"],
        &["general", "journal"],
        &["general"],
        &["generally"],
        &["generally"],
        &["generate"],
        &["generated"],
        &["generates"],
        &["generating"],
        &["generation"],
        &["generator"],
        &["generators"],
        &["generic"],
        &["generics"],
        &["georgia"],
    ],
    range: 1..=8,
};

static WORD_GEO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_GEO_CHILDREN),
    value: None,
};

pub static WORD_GEO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("centic"),
        dictgen::InsensitiveStr::Ascii("emtries"),
        dictgen::InsensitiveStr::Ascii("emtry"),
        dictgen::InsensitiveStr::Ascii("gcountry"),
        dictgen::InsensitiveStr::Ascii("grahpical"),
        dictgen::InsensitiveStr::Ascii("graphacilly"),
        dictgen::InsensitiveStr::Ascii("graphia"),
        dictgen::InsensitiveStr::Ascii("graphicaly"),
        dictgen::InsensitiveStr::Ascii("graphich"),
        dictgen::InsensitiveStr::Ascii("graphicial"),
        dictgen::InsensitiveStr::Ascii("graphicly"),
        dictgen::InsensitiveStr::Ascii("graphisch"),
        dictgen::InsensitiveStr::Ascii("graphycally"),
        dictgen::InsensitiveStr::Ascii("grapy"),
        dictgen::InsensitiveStr::Ascii("gria"),
        dictgen::InsensitiveStr::Ascii("grpahic"),
        dictgen::InsensitiveStr::Ascii("grpahical"),
        dictgen::InsensitiveStr::Ascii("grpahically"),
        dictgen::InsensitiveStr::Ascii("grpahy"),
        dictgen::InsensitiveStr::Ascii("io"),
        dictgen::InsensitiveStr::Ascii("mertic"),
        dictgen::InsensitiveStr::Ascii("merties"),
        dictgen::InsensitiveStr::Ascii("merty"),
        dictgen::InsensitiveStr::Ascii("mery"),
        dictgen::InsensitiveStr::Ascii("metites"),
        dictgen::InsensitiveStr::Ascii("metrc"),
        dictgen::InsensitiveStr::Ascii("metrician"),
        dictgen::InsensitiveStr::Ascii("metricians"),
        dictgen::InsensitiveStr::Ascii("metrie"),
        dictgen::InsensitiveStr::Ascii("metrys"),
        dictgen::InsensitiveStr::Ascii("mety"),
        dictgen::InsensitiveStr::Ascii("metyr"),
        dictgen::InsensitiveStr::Ascii("mitrically"),
        dictgen::InsensitiveStr::Ascii("moetric"),
        dictgen::InsensitiveStr::Ascii("moetrically"),
        dictgen::InsensitiveStr::Ascii("moetry"),
        dictgen::InsensitiveStr::Ascii("mteric"),
        dictgen::InsensitiveStr::Ascii("mterically"),
        dictgen::InsensitiveStr::Ascii("mteries"),
        dictgen::InsensitiveStr::Ascii("mtery"),
        dictgen::InsensitiveStr::Ascii("mtries"),
        dictgen::InsensitiveStr::Ascii("mtry"),
        dictgen::InsensitiveStr::Ascii("mtrys"),
        dictgen::InsensitiveStr::Ascii("orgia"),
        dictgen::InsensitiveStr::Ascii("praphically"),
        dictgen::InsensitiveStr::Ascii("referncing"),
        dictgen::InsensitiveStr::Ascii("riga"),
    ],
    values: &[
        &["geocentric"],
        &["geometries"],
        &["geometry"],
        &["geocountry"],
        &["geographical"],
        &["geographically"],
        &["geographical"],
        &["geographically"],
        &["geographic"],
        &["geographical"],
        &["geographical"],
        &["geographic"],
        &["geographically"],
        &["geography"],
        &["georgia"],
        &["geographic"],
        &["geographical"],
        &["geographically"],
        &["geography"],
        &["geoip"],
        &["geometric"],
        &["geometries"],
        &["geometry"],
        &["geometry"],
        &["geometries"],
        &["geometric", "geometry"],
        &["geometer"],
        &["geometers"],
        &["geometry"],
        &["geometries"],
        &["geometry"],
        &["geometry"],
        &["geometrically"],
        &["geometric"],
        &["geometrically"],
        &["geometry"],
        &["geometric"],
        &["geometrically"],
        &["geometries"],
        &["geometry"],
        &["geometries"],
        &["geometry"],
        &["geometries"],
        &["georgia"],
        &["geographically"],
        &["georeferencing"],
        &["georgia"],
    ],
    range: 2..=11,
};

static WORD_GEN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_GEN_CHILDREN),
    value: None,
};

static WORD_GEN_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_GENA_NODE),
    None,
    None,
    None,
    Some(&WORD_GENE_NODE),
    None,
    None,
    None,
    Some(&WORD_GENI_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_GENR_NODE),
    None,
    Some(&WORD_GENT_NODE),
    Some(&WORD_GENU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_GENU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_GENU_CHILDREN),
    value: None,
};

pub static WORD_GENU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ienly"),
        dictgen::InsensitiveStr::Ascii("in"),
        dictgen::InsensitiveStr::Ascii("inelly"),
        dictgen::InsensitiveStr::Ascii("inley"),
        dictgen::InsensitiveStr::Ascii("ises"),
    ],
    values: &[
        &["genuinely"],
        &["genuine"],
        &["genuinely"],
        &["genuinely"],
        &["geniuses"],
    ],
    range: 2..=6,
};

static WORD_GENT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_GENT_CHILDREN),
    value: None,
};

pub static WORD_GENT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ailia"),
        dictgen::InsensitiveStr::Ascii("al"),
        dictgen::InsensitiveStr::Ascii("elmen"),
        dictgen::InsensitiveStr::Ascii("ialia"),
        dictgen::InsensitiveStr::Ascii("ials"),
        dictgen::InsensitiveStr::Ascii("lemanne"),
        dictgen::InsensitiveStr::Ascii("lemn"),
    ],
    values: &[
        &["genitalia"],
        &["gentle"],
        &["gentlemen"],
        &["genitalia"],
        &["genitals"],
        &["gentlemen"],
        &["gentlemen"],
    ],
    range: 2..=7,
};

static WORD_GENR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_GENR_CHILDREN),
    value: None,
};

pub static WORD_GENR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("al"),
        dictgen::InsensitiveStr::Ascii("alisation"),
        dictgen::InsensitiveStr::Ascii("alisations"),
        dictgen::InsensitiveStr::Ascii("alise"),
        dictgen::InsensitiveStr::Ascii("alised"),
        dictgen::InsensitiveStr::Ascii("alises"),
        dictgen::InsensitiveStr::Ascii("alization"),
        dictgen::InsensitiveStr::Ascii("alizations"),
        dictgen::InsensitiveStr::Ascii("alize"),
        dictgen::InsensitiveStr::Ascii("alized"),
        dictgen::InsensitiveStr::Ascii("alizes"),
        dictgen::InsensitiveStr::Ascii("ally"),
        dictgen::InsensitiveStr::Ascii("als"),
        dictgen::InsensitiveStr::Ascii("ate"),
        dictgen::InsensitiveStr::Ascii("ated"),
        dictgen::InsensitiveStr::Ascii("ates"),
        dictgen::InsensitiveStr::Ascii("atet"),
        dictgen::InsensitiveStr::Ascii("ating"),
        dictgen::InsensitiveStr::Ascii("ation"),
        dictgen::InsensitiveStr::Ascii("ations"),
        dictgen::InsensitiveStr::Ascii("ator"),
        dictgen::InsensitiveStr::Ascii("ators"),
        dictgen::InsensitiveStr::Ascii("eate"),
        dictgen::InsensitiveStr::Ascii("eated"),
        dictgen::InsensitiveStr::Ascii("eates"),
        dictgen::InsensitiveStr::Ascii("eating"),
        dictgen::InsensitiveStr::Ascii("eic"),
        dictgen::InsensitiveStr::Ascii("ic"),
        dictgen::InsensitiveStr::Ascii("ics"),
    ],
    values: &[
        &["general"],
        &["generalisation"],
        &["generalisations"],
        &["generalise"],
        &["generalised"],
        &["generalises"],
        &["generalization"],
        &["generalizations"],
        &["generalize"],
        &["generalized"],
        &["generalizes"],
        &["generally"],
        &["generals"],
        &["generate"],
        &["generated"],
        &["generates"],
        &["generated"],
        &["generating"],
        &["generation"],
        &["generations"],
        &["generator"],
        &["generators"],
        &["generate"],
        &["generated"],
        &["generates"],
        &["generating"],
        &["generic"],
        &["generic"],
        &["generics"],
    ],
    range: 2..=10,
};

static WORD_GENI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_GENI_CHILDREN),
    value: None,
};

pub static WORD_GENI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("alia"),
        dictgen::InsensitiveStr::Ascii("sues"),
        dictgen::InsensitiveStr::Ascii("taila"),
        dictgen::InsensitiveStr::Ascii("tala"),
        dictgen::InsensitiveStr::Ascii("tales"),
        dictgen::InsensitiveStr::Ascii("talias"),
        dictgen::InsensitiveStr::Ascii("taliban"),
        dictgen::InsensitiveStr::Ascii("talis"),
        dictgen::InsensitiveStr::Ascii("une"),
        dictgen::InsensitiveStr::Ascii("unely"),
        dictgen::InsensitiveStr::Ascii("uss"),
    ],
    values: &[
        &["genitalia"],
        &["geniuses"],
        &["genitalia"],
        &["genitalia"],
        &["genitals"],
        &["genitals"],
        &["genitalia"],
        &["genitals"],
        &["genuine"],
        &["genuinely"],
        &["geniuses"],
    ],
    range: 3..=7,
};

static WORD_GENE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_GENE_CHILDREN),
    value: None,
};

static WORD_GENE_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_GENEA_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_GENEI_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_GENEO_NODE),
    None,
    None,
    Some(&WORD_GENER_NODE),
    None,
    Some(&WORD_GENET_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_GENET_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_GENET_CHILDREN),
    value: None,
};

pub static WORD_GENET_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("icaly"),
        dictgen::InsensitiveStr::Ascii("iclly"),
    ],
    values: &[&["genetically"], &["genetically"]],
    range: 5..=5,
};

static WORD_GENER_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_GENER_CHILDREN),
    value: None,
};

static WORD_GENER_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_GENERA_NODE),
    None,
    None,
    None,
    Some(&WORD_GENERE_NODE),
    None,
    None,
    None,
    Some(&WORD_GENERI_NODE),
    None,
    None,
    Some(&WORD_GENERL_NODE),
    None,
    None,
    Some(&WORD_GENERO_NODE),
    None,
    None,
    None,
    Some(&WORD_GENERS_NODE),
    Some(&WORD_GENERT_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_GENERT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_GENERT_CHILDREN),
    value: None,
};

pub static WORD_GENERT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("ion"),
        dictgen::InsensitiveStr::Ascii("or"),
        dictgen::InsensitiveStr::Ascii("ors"),
    ],
    values: &[
        &["generated"],
        &["generating"],
        &["generation"],
        &["generator"],
        &["generators"],
    ],
    range: 2..=3,
};

static WORD_GENERS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_GENERS_CHILDREN),
    value: None,
};

pub static WORD_GENERS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("l")],
    values: &[&["generals"]],
    range: 1..=1,
};

static WORD_GENERO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_GENERO_CHILDREN),
    value: None,
};

pub static WORD_GENERO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("city"),
        dictgen::InsensitiveStr::Ascii("isty"),
        dictgen::InsensitiveStr::Ascii("stiy"),
    ],
    values: &[&["generosity"], &["generosity"], &["generosity"]],
    range: 4..=4,
};

static WORD_GENERL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_GENERL_CHILDREN),
    value: None,
};

pub static WORD_GENERL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("a"),
        dictgen::InsensitiveStr::Ascii("aizes"),
        dictgen::InsensitiveStr::Ascii("as"),
    ],
    values: &[&["general"], &["generalizes"], &["generals"]],
    range: 1..=5,
};

static WORD_GENERI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_GENERI_CHILDREN),
    value: None,
};

pub static WORD_GENERI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("lise"),
        dictgen::InsensitiveStr::Ascii("lised"),
        dictgen::InsensitiveStr::Ascii("lises"),
        dictgen::InsensitiveStr::Ascii("lize"),
        dictgen::InsensitiveStr::Ascii("lized"),
        dictgen::InsensitiveStr::Ascii("lizes"),
        dictgen::InsensitiveStr::Ascii("ously"),
    ],
    values: &[
        &["generalise"],
        &["generalised"],
        &["generalises"],
        &["generalize"],
        &["generalized"],
        &["generalizes"],
        &["generously"],
    ],
    range: 4..=5,
};

static WORD_GENERE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_GENERE_CHILDREN),
    value: None,
};

pub static WORD_GENERE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ate"),
        dictgen::InsensitiveStr::Ascii("ated"),
        dictgen::InsensitiveStr::Ascii("ates"),
        dictgen::InsensitiveStr::Ascii("ating"),
        dictgen::InsensitiveStr::Ascii("d"),
        dictgen::InsensitiveStr::Ascii("ic"),
        dictgen::InsensitiveStr::Ascii("lization"),
        dictgen::InsensitiveStr::Ascii("lize"),
        dictgen::InsensitiveStr::Ascii("lizing"),
        dictgen::InsensitiveStr::Ascii("ll"),
        dictgen::InsensitiveStr::Ascii("lly"),
        dictgen::InsensitiveStr::Ascii("rate"),
        dictgen::InsensitiveStr::Ascii("rated"),
        dictgen::InsensitiveStr::Ascii("rater"),
        dictgen::InsensitiveStr::Ascii("rating"),
        dictgen::InsensitiveStr::Ascii("ration"),
        dictgen::InsensitiveStr::Ascii("ric"),
        dictgen::InsensitiveStr::Ascii("ted"),
    ],
    values: &[
        &["generate"],
        &["generated"],
        &["generates"],
        &["generating"],
        &["generated"],
        &["generic"],
        &["generalization"],
        &["generalize"],
        &["generalizing"],
        &["general"],
        &["generally"],
        &["generate"],
        &["generated"],
        &["generator"],
        &["generating"],
        &["generation"],
        &["generic"],
        &["generated"],
    ],
    range: 1..=8,
};

static WORD_GENERA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_GENERA_CHILDREN),
    value: None,
};

pub static WORD_GENERA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ates"),
        dictgen::InsensitiveStr::Ascii("cional"),
        dictgen::InsensitiveStr::Ascii("ge"),
        dictgen::InsensitiveStr::Ascii("ged"),
        dictgen::InsensitiveStr::Ascii("ges"),
        dictgen::InsensitiveStr::Ascii("ging"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("lbs"),
        dictgen::InsensitiveStr::Ascii("lice"),
        dictgen::InsensitiveStr::Ascii("life"),
        dictgen::InsensitiveStr::Ascii("lis"),
        dictgen::InsensitiveStr::Ascii("lizacion"),
        dictgen::InsensitiveStr::Ascii("lizaing"),
        dictgen::InsensitiveStr::Ascii("lizare"),
        dictgen::InsensitiveStr::Ascii("lizate"),
        dictgen::InsensitiveStr::Ascii("lizating"),
        dictgen::InsensitiveStr::Ascii("lizaton"),
        dictgen::InsensitiveStr::Ascii("lizng"),
        dictgen::InsensitiveStr::Ascii("ll"),
        dictgen::InsensitiveStr::Ascii("lnie"),
        dictgen::InsensitiveStr::Ascii("ly"),
        dictgen::InsensitiveStr::Ascii("lyl"),
        dictgen::InsensitiveStr::Ascii("lyse"),
        dictgen::InsensitiveStr::Ascii("s"),
        dictgen::InsensitiveStr::Ascii("se"),
        dictgen::InsensitiveStr::Ascii("ste"),
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("ter"),
        dictgen::InsensitiveStr::Ascii("ters"),
        dictgen::InsensitiveStr::Ascii("tie"),
        dictgen::InsensitiveStr::Ascii("ties"),
        dictgen::InsensitiveStr::Ascii("tig"),
        dictgen::InsensitiveStr::Ascii("tign"),
        dictgen::InsensitiveStr::Ascii("tin"),
        dictgen::InsensitiveStr::Ascii("tionals"),
        dictgen::InsensitiveStr::Ascii("tionens"),
        dictgen::InsensitiveStr::Ascii("tioners"),
        dictgen::InsensitiveStr::Ascii("tionnal"),
        dictgen::InsensitiveStr::Ascii("tios"),
        dictgen::InsensitiveStr::Ascii("tng"),
        dictgen::InsensitiveStr::Ascii("ton"),
        dictgen::InsensitiveStr::Ascii("tons"),
        dictgen::InsensitiveStr::Ascii("tore"),
        dictgen::InsensitiveStr::Ascii("tos"),
        dictgen::InsensitiveStr::Ascii("ts"),
        dictgen::InsensitiveStr::Ascii("tting"),
    ],
    values: &[
        &["generates"],
        &["generational"],
        &["generate"],
        &["generated"],
        &["generates"],
        &["generating"],
        &["generating"],
        &["generals"],
        &["generalize"],
        &["generalize"],
        &["generals"],
        &["generalization"],
        &["generalizing"],
        &["generalize"],
        &["generalize"],
        &["generalization"],
        &["generalization"],
        &["generalizing"],
        &["generally", "general"],
        &["generalize"],
        &["generally"],
        &["generally"],
        &["generalise"],
        &["generals"],
        &["generates"],
        &["generates"],
        &["generate", "general"],
        &["generator"],
        &["generates", "generators"],
        &["generate"],
        &["generate"],
        &["generating"],
        &["generating"],
        &["generations"],
        &["generations"],
        &["generations"],
        &["generations"],
        &["generational"],
        &["generators"],
        &["generating"],
        &["generation", "generator"],
        &["generators"],
        &["generate"],
        &["generators"],
        &["generates"],
        &["generating"],
    ],
    range: 1..=8,
};

static WORD_GENEO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_GENEO_CHILDREN),
    value: None,
};

pub static WORD_GENEO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("logical"),
        dictgen::InsensitiveStr::Ascii("logies"),
        dictgen::InsensitiveStr::Ascii("logy"),
    ],
    values: &[&["genealogical"], &["genealogies"], &["genealogy"]],
    range: 4..=7,
};

static WORD_GENEI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_GENEI_CHILDREN),
    value: None,
};

pub static WORD_GENEI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("c")],
    values: &[&["generic", "genetic"]],
    range: 1..=1,
};

static WORD_GENEA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_GENEA_CHILDREN),
    value: None,
};

pub static WORD_GENEA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ral"),
        dictgen::InsensitiveStr::Ascii("rally"),
        dictgen::InsensitiveStr::Ascii("rted"),
        dictgen::InsensitiveStr::Ascii("te"),
        dictgen::InsensitiveStr::Ascii("ted"),
        dictgen::InsensitiveStr::Ascii("tes"),
        dictgen::InsensitiveStr::Ascii("ting"),
        dictgen::InsensitiveStr::Ascii("tion"),
        dictgen::InsensitiveStr::Ascii("tor"),
    ],
    values: &[
        &["general"],
        &["generally"],
        &["generated"],
        &["generate"],
        &["generated"],
        &["generates"],
        &["generating"],
        &["generation"],
        &["generator"],
    ],
    range: 2..=5,
};

static WORD_GENA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_GENA_CHILDREN),
    value: None,
};

pub static WORD_GENA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("rate"),
        dictgen::InsensitiveStr::Ascii("rated"),
        dictgen::InsensitiveStr::Ascii("rates"),
        dictgen::InsensitiveStr::Ascii("rating"),
        dictgen::InsensitiveStr::Ascii("ration"),
        dictgen::InsensitiveStr::Ascii("tilia"),
    ],
    values: &[
        &["generate"],
        &["generated"],
        &["generates"],
        &["generating"],
        &["generation"],
        &["genitalia"],
    ],
    range: 4..=6,
};

static WORD_GEM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_GEM_CHILDREN),
    value: None,
};

pub static WORD_GEM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("etrical"),
        dictgen::InsensitiveStr::Ascii("etry"),
        dictgen::InsensitiveStr::Ascii("oetry"),
        dictgen::InsensitiveStr::Ascii("ometric"),
    ],
    values: &[
        &["geometrical"],
        &["geometry"],
        &["geometry"],
        &["geometric"],
    ],
    range: 4..=7,
};

static WORD_GEE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_GEE_CHILDREN),
    value: None,
};

pub static WORD_GEE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("neric"),
        dictgen::InsensitiveStr::Ascii("nrate"),
        dictgen::InsensitiveStr::Ascii("nrated"),
        dictgen::InsensitiveStr::Ascii("nrates"),
        dictgen::InsensitiveStr::Ascii("nration"),
        dictgen::InsensitiveStr::Ascii("nrational"),
        dictgen::InsensitiveStr::Ascii("oteen"),
        dictgen::InsensitiveStr::Ascii("ral"),
    ],
    values: &[
        &["generic"],
        &["generate"],
        &["generated"],
        &["generates"],
        &["generation"],
        &["generational"],
        &["guillotine"],
        &["general"],
    ],
    range: 3..=9,
};

static WORD_GA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_GA_CHILDREN),
    value: None,
};

static WORD_GA_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    Some(&WORD_GAB_NODE),
    None,
    Some(&WORD_GAD_NODE),
    None,
    None,
    Some(&WORD_GAG_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_GAL_NODE),
    Some(&WORD_GAM_NODE),
    Some(&WORD_GAN_NODE),
    None,
    None,
    None,
    Some(&WORD_GAR_NODE),
    Some(&WORD_GAS_NODE),
    Some(&WORD_GAT_NODE),
    Some(&WORD_GAU_NODE),
    None,
    None,
    None,
    Some(&WORD_GAY_NODE),
    None,
];

static WORD_GAY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_GAY_CHILDREN),
    value: None,
};

pub static WORD_GAY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ity"),
        dictgen::InsensitiveStr::Ascii("sha"),
        dictgen::InsensitiveStr::Ascii("shas"),
    ],
    values: &[&["gayety"], &["geisha"], &["geishas"]],
    range: 3..=4,
};

static WORD_GAU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_GAU_CHILDREN),
    value: None,
};

pub static WORD_GAU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("age"),
        dictgen::InsensitiveStr::Ascii("arana"),
        dictgen::InsensitiveStr::Ascii("arantee"),
        dictgen::InsensitiveStr::Ascii("aranteed"),
        dictgen::InsensitiveStr::Ascii("arentee"),
        dictgen::InsensitiveStr::Ascii("arenteed"),
        dictgen::InsensitiveStr::Ascii("ntanamo"),
        dictgen::InsensitiveStr::Ascii("ntelt"),
        dictgen::InsensitiveStr::Ascii("ntelts"),
        dictgen::InsensitiveStr::Ascii("ntlent"),
        dictgen::InsensitiveStr::Ascii("ntlents"),
        dictgen::InsensitiveStr::Ascii("ntles"),
        dictgen::InsensitiveStr::Ascii("ntlettes"),
        dictgen::InsensitiveStr::Ascii("rantee"),
        dictgen::InsensitiveStr::Ascii("ranteed"),
        dictgen::InsensitiveStr::Ascii("ranteeing"),
        dictgen::InsensitiveStr::Ascii("rantees"),
        dictgen::InsensitiveStr::Ascii("rd"),
        dictgen::InsensitiveStr::Ascii("rdian"),
        dictgen::InsensitiveStr::Ascii("rding"),
        dictgen::InsensitiveStr::Ascii("rentee"),
        dictgen::InsensitiveStr::Ascii("renteed"),
        dictgen::InsensitiveStr::Ascii("rentees"),
        dictgen::InsensitiveStr::Ascii("s"),
        dictgen::InsensitiveStr::Ascii("sian"),
        dictgen::InsensitiveStr::Ascii("tnlet"),
    ],
    values: &[
        &["gauge"],
        &["guaraná"],
        &["guarantee"],
        &["guaranteed"],
        &["guarantee"],
        &["guaranteed"],
        &["guantanamo"],
        &["gauntlet"],
        &["gauntlets"],
        &["gauntlet"],
        &["gauntlet"],
        &["gauntlets"],
        &["gauntlets"],
        &["guarantee"],
        &["guaranteed"],
        &["guaranteeing"],
        &["guarantees"],
        &["guard", "gourd"],
        &["guardian"],
        &["guarding"],
        &["guarantee"],
        &["guaranteed"],
        &["guarantees"],
        &["gauss", "gauze"],
        &["gaussian"],
        &["gauntlet"],
    ],
    range: 1..=9,
};

static WORD_GAT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_GAT_CHILDREN),
    value: None,
};

pub static WORD_GAT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("able"),
        dictgen::InsensitiveStr::Ascii("eing"),
        dictgen::InsensitiveStr::Ascii("herig"),
        dictgen::InsensitiveStr::Ascii("herins"),
        dictgen::InsensitiveStr::Ascii("way"),
    ],
    values: &[
        &["gateable"],
        &["gating"],
        &["gatherings", "gathering"],
        &["gatherings"],
        &["gateway"],
    ],
    range: 3..=6,
};

static WORD_GAS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_GAS_CHILDREN),
    value: None,
};

pub static WORD_GAS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("tly")],
    values: &[&["ghastly", "vastly"]],
    range: 3..=3,
};

static WORD_GAR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_GAR_CHILDREN),
    value: None,
};

pub static WORD_GAR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("abge"),
        dictgen::InsensitiveStr::Ascii("antee"),
        dictgen::InsensitiveStr::Ascii("anteed"),
        dictgen::InsensitiveStr::Ascii("anteeed"),
        dictgen::InsensitiveStr::Ascii("antees"),
        dictgen::InsensitiveStr::Ascii("antie"),
        dictgen::InsensitiveStr::Ascii("antied"),
        dictgen::InsensitiveStr::Ascii("anties"),
        dictgen::InsensitiveStr::Ascii("anty"),
        dictgen::InsensitiveStr::Ascii("badge"),
        dictgen::InsensitiveStr::Ascii("bagge"),
        dictgen::InsensitiveStr::Ascii("barge"),
        dictgen::InsensitiveStr::Ascii("d"),
        dictgen::InsensitiveStr::Ascii("dai"),
        dictgen::InsensitiveStr::Ascii("dient"),
        dictgen::InsensitiveStr::Ascii("entee"),
        dictgen::InsensitiveStr::Ascii("feild"),
        dictgen::InsensitiveStr::Ascii("fied"),
        dictgen::InsensitiveStr::Ascii("filed"),
        dictgen::InsensitiveStr::Ascii("flied"),
        dictgen::InsensitiveStr::Ascii("gage"),
        dictgen::InsensitiveStr::Ascii("goil"),
        dictgen::InsensitiveStr::Ascii("goils"),
        dictgen::InsensitiveStr::Ascii("illa"),
        dictgen::InsensitiveStr::Ascii("illas"),
        dictgen::InsensitiveStr::Ascii("nison"),
        dictgen::InsensitiveStr::Ascii("nola"),
        dictgen::InsensitiveStr::Ascii("rions"),
        dictgen::InsensitiveStr::Ascii("riosn"),
        dictgen::InsensitiveStr::Ascii("rsion"),
        dictgen::InsensitiveStr::Ascii("uantee"),
        dictgen::InsensitiveStr::Ascii("uanteed"),
        dictgen::InsensitiveStr::Ascii("uantees"),
        dictgen::InsensitiveStr::Ascii("uantied"),
    ],
    values: &[
        &["garbage"],
        &["guarantee"],
        &["guaranteed"],
        &["guaranteed"],
        &["guarantees"],
        &["guarantee"],
        &["guaranteed"],
        &["guarantees"],
        &["guarantee"],
        &["garbage"],
        &["garbage"],
        &["garbage"],
        &["guard"],
        &["gardaí"],
        &["gradient"],
        &["guarantee"],
        &["garfield"],
        &["garfield"],
        &["garfield"],
        &["garfield"],
        &["garbage", "garage"],
        &["gargoyle"],
        &["gargoyles"],
        &["guerilla"],
        &["guerillas"],
        &["garrison"],
        &["granola"],
        &["garrison"],
        &["garrison"],
        &["garrison"],
        &["guarantee"],
        &["guaranteed"],
        &["guarantees"],
        &["guaranteed"],
    ],
    range: 1..=7,
};

static WORD_GAN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_GAN_CHILDREN),
    value: None,
};

pub static WORD_GAN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("bia"),
        dictgen::InsensitiveStr::Ascii("erate"),
        dictgen::InsensitiveStr::Ascii("erated"),
        dictgen::InsensitiveStr::Ascii("erates"),
        dictgen::InsensitiveStr::Ascii("erating"),
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("gsterest"),
        dictgen::InsensitiveStr::Ascii("gsterous"),
        dictgen::InsensitiveStr::Ascii("kign"),
        dictgen::InsensitiveStr::Ascii("ster"),
    ],
    values: &[
        &["gambia"],
        &["generate"],
        &["generated"],
        &["generates"],
        &["generating"],
        &["games"],
        &["gangsters"],
        &["gangsters"],
        &["ganking"],
        &["gangster"],
    ],
    range: 2..=8,
};

static WORD_GAM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_GAM_CHILDREN),
    value: None,
};

pub static WORD_GAM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("emdoe"),
        dictgen::InsensitiveStr::Ascii("epaly"),
        dictgen::InsensitiveStr::Ascii("eply"),
        dictgen::InsensitiveStr::Ascii("erga"),
        dictgen::InsensitiveStr::Ascii("ergat"),
        dictgen::InsensitiveStr::Ascii("ifications"),
        dictgen::InsensitiveStr::Ascii("meode"),
    ],
    values: &[
        &["gamemode"],
        &["gameplay"],
        &["gameplay"],
        &["gamertag"],
        &["gamertag"],
        &["ramifications"],
        &["gamemode"],
    ],
    range: 4..=10,
};

static WORD_GAL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_GAL_CHILDREN),
    value: None,
};

pub static WORD_GAL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("atic"),
        dictgen::InsensitiveStr::Ascii("ations"),
        dictgen::InsensitiveStr::Ascii("cier"),
        dictgen::InsensitiveStr::Ascii("diator"),
        dictgen::InsensitiveStr::Ascii("laries"),
        dictgen::InsensitiveStr::Ascii("lary"),
        dictgen::InsensitiveStr::Ascii("laxies"),
        dictgen::InsensitiveStr::Ascii("lleries"),
        dictgen::InsensitiveStr::Ascii("llery"),
        dictgen::InsensitiveStr::Ascii("llerys"),
        dictgen::InsensitiveStr::Ascii("sgow"),
        dictgen::InsensitiveStr::Ascii("vinized"),
    ],
    values: &[
        &["galactic"],
        &["galatians"],
        &["glacier"],
        &["gladiator"],
        &["galleries"],
        &["gallery"],
        &["galaxies"],
        &["galleries"],
        &["gallery"],
        &["galleries"],
        &["glasgow"],
        &["galvanized"],
    ],
    range: 4..=7,
};

static WORD_GAG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_GAG_CHILDREN),
    value: None,
};

pub static WORD_GAG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("dets"),
        dictgen::InsensitiveStr::Ascii("et"),
        dictgen::InsensitiveStr::Ascii("it"),
        dictgen::InsensitiveStr::Ascii("its"),
        dictgen::InsensitiveStr::Ascii("nsters"),
    ],
    values: &[
        &["gadgets"],
        &["gadget"],
        &["gadget"],
        &["gadgets"],
        &["gangsters"],
    ],
    range: 2..=6,
};

static WORD_GAD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_GAD_CHILDREN),
    value: None,
};

pub static WORD_GAD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ged"),
        dictgen::InsensitiveStr::Ascii("gest"),
    ],
    values: &[&["gadget", "gauged"], &["gadgets"]],
    range: 3..=4,
};

static WORD_GAB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_GAB_CHILDREN),
    value: None,
};

pub static WORD_GAB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("age")],
    values: &[&["garbage"]],
    range: 3..=3,
};

static WORD_F_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_F_CHILDREN),
    value: None,
};

static WORD_F_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_FA_NODE),
    None,
    Some(&WORD_FC_NODE),
    None,
    Some(&WORD_FE_NODE),
    None,
    None,
    Some(&WORD_FH_NODE),
    Some(&WORD_FI_NODE),
    None,
    None,
    Some(&WORD_FL_NODE),
    None,
    Some(&WORD_FN_NODE),
    Some(&WORD_FO_NODE),
    Some(&WORD_FP_NODE),
    None,
    Some(&WORD_FR_NODE),
    Some(&WORD_FS_NODE),
    Some(&WORD_FT_NODE),
    Some(&WORD_FU_NODE),
    None,
    Some(&WORD_FW_NODE),
    Some(&WORD_FX_NODE),
    Some(&WORD_FY_NODE),
    None,
];

static WORD_FY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FY_CHILDREN),
    value: None,
};

pub static WORD_FY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("sical"),
        dictgen::InsensitiveStr::Ascii("sisist"),
        dictgen::InsensitiveStr::Ascii("sisit"),
    ],
    values: &[&["physical"], &["physicist"], &["physicist"]],
    range: 5..=6,
};

static WORD_FX_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FX_CHILDREN),
    value: None,
};

pub static WORD_FX_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ed")],
    values: &[&["fixed"]],
    range: 2..=2,
};

static WORD_FW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FW_CHILDREN),
    value: None,
};

pub static WORD_FW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ankenstein"),
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("irte"),
    ],
    values: &[&["frankenstein"], &["few"], &["fwrite"]],
    range: 1..=10,
};

static WORD_FU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_FU_CHILDREN),
    value: None,
};

static WORD_FU_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_FUA_NODE),
    None,
    Some(&WORD_FUC_NODE),
    None,
    Some(&WORD_FUE_NODE),
    Some(&WORD_FUF_NODE),
    Some(&WORD_FUG_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_FUL_NODE),
    Some(&WORD_FUM_NODE),
    Some(&WORD_FUN_NODE),
    None,
    None,
    None,
    Some(&WORD_FUR_NODE),
    Some(&WORD_FUS_NODE),
    Some(&WORD_FUT_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_FUT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FUT_CHILDREN),
    value: None,
};

pub static WORD_FUT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("al"),
        dictgen::InsensitiveStr::Ascii("er"),
        dictgen::InsensitiveStr::Ascii("her"),
        dictgen::InsensitiveStr::Ascii("herize"),
        dictgen::InsensitiveStr::Ascii("hermore"),
        dictgen::InsensitiveStr::Ascii("hroc"),
        dictgen::InsensitiveStr::Ascii("rue"),
        dictgen::InsensitiveStr::Ascii("rure"),
        dictgen::InsensitiveStr::Ascii("ture"),
        dictgen::InsensitiveStr::Ascii("urers"),
        dictgen::InsensitiveStr::Ascii("urestic"),
        dictgen::InsensitiveStr::Ascii("ureus"),
        dictgen::InsensitiveStr::Ascii("urisitc"),
        dictgen::InsensitiveStr::Ascii("urisitic"),
        dictgen::InsensitiveStr::Ascii("uristc"),
        dictgen::InsensitiveStr::Ascii("uristisch"),
        dictgen::InsensitiveStr::Ascii("urustic"),
    ],
    values: &[
        &["futile"],
        &["further", "future"],
        &["further"],
        &["further"],
        &["furthermore"],
        &["futhark", "futhorc"],
        &["future"],
        &["future"],
        &["future"],
        &["futures"],
        &["futuristic"],
        &["futures"],
        &["futuristic"],
        &["futuristic"],
        &["futuristic"],
        &["futuristic"],
        &["futuristic"],
    ],
    range: 2..=9,
};

static WORD_FUS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FUS_CHILDREN),
    value: None,
};

pub static WORD_FUS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("chia"),
        dictgen::InsensitiveStr::Ascii("ha"),
        dictgen::InsensitiveStr::Ascii("has"),
        dictgen::InsensitiveStr::Ascii("hed"),
        dictgen::InsensitiveStr::Ascii("hing"),
        dictgen::InsensitiveStr::Ascii("ipn"),
    ],
    values: &[
        &["fuchsia"],
        &["fuchsia"],
        &["fuchsias"],
        &["flushed"],
        &["flushing"],
        &["fusion"],
    ],
    range: 2..=4,
};

static WORD_FUR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FUR_CHILDREN),
    value: None,
};

pub static WORD_FUR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ance"),
        dictgen::InsensitiveStr::Ascii("ctose"),
        dictgen::InsensitiveStr::Ascii("ether"),
        dictgen::InsensitiveStr::Ascii("ethermore"),
        dictgen::InsensitiveStr::Ascii("ethest"),
        dictgen::InsensitiveStr::Ascii("fill"),
        dictgen::InsensitiveStr::Ascii("her"),
        dictgen::InsensitiveStr::Ascii("hermore"),
        dictgen::InsensitiveStr::Ascii("hest"),
        dictgen::InsensitiveStr::Ascii("hter"),
        dictgen::InsensitiveStr::Ascii("htermore"),
        dictgen::InsensitiveStr::Ascii("htest"),
        dictgen::InsensitiveStr::Ascii("iosuly"),
        dictgen::InsensitiveStr::Ascii("ition"),
        dictgen::InsensitiveStr::Ascii("iuosly"),
        dictgen::InsensitiveStr::Ascii("malae"),
        dictgen::InsensitiveStr::Ascii("mula"),
        dictgen::InsensitiveStr::Ascii("mulae"),
        dictgen::InsensitiveStr::Ascii("ncae"),
        dictgen::InsensitiveStr::Ascii("nction"),
        dictgen::InsensitiveStr::Ascii("nctional"),
        dictgen::InsensitiveStr::Ascii("nctions"),
        dictgen::InsensitiveStr::Ascii("neture"),
        dictgen::InsensitiveStr::Ascii("ser"),
        dictgen::InsensitiveStr::Ascii("sermore"),
        dictgen::InsensitiveStr::Ascii("sest"),
        dictgen::InsensitiveStr::Ascii("st"),
        dictgen::InsensitiveStr::Ascii("sther"),
        dictgen::InsensitiveStr::Ascii("sthermore"),
        dictgen::InsensitiveStr::Ascii("sthest"),
        dictgen::InsensitiveStr::Ascii("strated"),
        dictgen::InsensitiveStr::Ascii("strates"),
        dictgen::InsensitiveStr::Ascii("stration"),
        dictgen::InsensitiveStr::Ascii("strations"),
        dictgen::InsensitiveStr::Ascii("tehr"),
        dictgen::InsensitiveStr::Ascii("ter"),
        dictgen::InsensitiveStr::Ascii("themore"),
        dictgen::InsensitiveStr::Ascii("thermor"),
        dictgen::InsensitiveStr::Ascii("therst"),
        dictgen::InsensitiveStr::Ascii("thher"),
        dictgen::InsensitiveStr::Ascii("thremore"),
        dictgen::InsensitiveStr::Ascii("threst"),
        dictgen::InsensitiveStr::Ascii("thur"),
        dictgen::InsensitiveStr::Ascii("thurmore"),
        dictgen::InsensitiveStr::Ascii("ture"),
        dictgen::InsensitiveStr::Ascii("ure"),
        dictgen::InsensitiveStr::Ascii("ute"),
        dictgen::InsensitiveStr::Ascii("uther"),
        dictgen::InsensitiveStr::Ascii("utistic"),
        dictgen::InsensitiveStr::Ascii("utre"),
        dictgen::InsensitiveStr::Ascii("zzer"),
    ],
    values: &[
        &["furnace"],
        &["fructose"],
        &["further"],
        &["furthermore"],
        &["furthest"],
        &["fulfill"],
        &["further"],
        &["furthermore"],
        &["furthest"],
        &["further"],
        &["furthermore"],
        &["furthest"],
        &["furiously"],
        &["fruition"],
        &["furiously"],
        &["formulae"],
        &["formula"],
        &["formulae"],
        &["furnace"],
        &["function"],
        &["functional"],
        &["functions"],
        &["furniture"],
        &["further"],
        &["furthermore"],
        &["first", "furthest"],
        &["first"],
        &["further"],
        &["furthermore"],
        &["furthest"],
        &["frustrated"],
        &["frustrates"],
        &["frustration"],
        &["frustrations"],
        &["further"],
        &["further"],
        &["furthermore"],
        &["furthermore"],
        &["furthest"],
        &["further"],
        &["furthermore"],
        &["furthest"],
        &["further"],
        &["furthermore"],
        &["future"],
        &["future"],
        &["fruit", "future"],
        &["further"],
        &["futuristic"],
        &["future"],
        &["fuzzer"],
    ],
    range: 2..=9,
};

static WORD_FUN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_FUN_CHILDREN),
    value: None,
};

static WORD_FUN_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    Some(&WORD_FUNC_NODE),
    Some(&WORD_FUND_NODE),
    None,
    None,
    Some(&WORD_FUNG_NODE),
    None,
    Some(&WORD_FUNI_NODE),
    None,
    Some(&WORD_FUNK_NODE),
    None,
    None,
    Some(&WORD_FUNN_NODE),
    None,
    None,
    None,
    Some(&WORD_FUNR_NODE),
    None,
    Some(&WORD_FUNT_NODE),
    None,
    Some(&WORD_FUNV_NODE),
    None,
    Some(&WORD_FUNX_NODE),
    None,
    None,
];

static WORD_FUNX_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FUNX_CHILDREN),
    value: None,
};

pub static WORD_FUNX_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("tion"),
        dictgen::InsensitiveStr::Ascii("tional"),
        dictgen::InsensitiveStr::Ascii("tionalities"),
        dictgen::InsensitiveStr::Ascii("tionality"),
        dictgen::InsensitiveStr::Ascii("tioned"),
        dictgen::InsensitiveStr::Ascii("tioning"),
        dictgen::InsensitiveStr::Ascii("tions"),
    ],
    values: &[
        &["function"],
        &["functional"],
        &["functionalities"],
        &["functionality"],
        &["functioned"],
        &["functioning"],
        &["functions"],
    ],
    range: 4..=11,
};

static WORD_FUNV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FUNV_CHILDREN),
    value: None,
};

pub static WORD_FUNV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("tion"),
        dictgen::InsensitiveStr::Ascii("tional"),
        dictgen::InsensitiveStr::Ascii("tionalities"),
        dictgen::InsensitiveStr::Ascii("tionality"),
        dictgen::InsensitiveStr::Ascii("tioned"),
        dictgen::InsensitiveStr::Ascii("tioning"),
        dictgen::InsensitiveStr::Ascii("tions"),
    ],
    values: &[
        &["function"],
        &["functional"],
        &["functionalities"],
        &["functionality"],
        &["functioned"],
        &["functioning"],
        &["functions"],
    ],
    range: 4..=11,
};

static WORD_FUNT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FUNT_CHILDREN),
    value: None,
};

pub static WORD_FUNT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ion"),
        dictgen::InsensitiveStr::Ascii("ional"),
        dictgen::InsensitiveStr::Ascii("ionalities"),
        dictgen::InsensitiveStr::Ascii("ionality"),
        dictgen::InsensitiveStr::Ascii("ionallity"),
        dictgen::InsensitiveStr::Ascii("ionally"),
        dictgen::InsensitiveStr::Ascii("ionalty"),
        dictgen::InsensitiveStr::Ascii("ioning"),
        dictgen::InsensitiveStr::Ascii("ions"),
        dictgen::InsensitiveStr::Ascii("ure"),
    ],
    values: &[
        &["function"],
        &["functional"],
        &["functionalities"],
        &["functionality"],
        &["functionality"],
        &["functionally"],
        &["functionality"],
        &["functioning"],
        &["functions"],
        &["future"],
    ],
    range: 3..=10,
};

static WORD_FUNR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FUNR_CHILDREN),
    value: None,
};

pub static WORD_FUNR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("el"),
        dictgen::InsensitiveStr::Ascii("els"),
    ],
    values: &[&["funeral"], &["funerals"]],
    range: 2..=3,
};

static WORD_FUNN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FUNN_CHILDREN),
    value: None,
};

pub static WORD_FUNN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("iliy"),
        dictgen::InsensitiveStr::Ascii("illy"),
        dictgen::InsensitiveStr::Ascii("nily"),
    ],
    values: &[&["funnily"], &["funnily"], &["funnily"]],
    range: 4..=4,
};

static WORD_FUNK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FUNK_CHILDREN),
    value: None,
};

pub static WORD_FUNK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("tion")],
    values: &[&["function"]],
    range: 4..=4,
};

static WORD_FUNI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FUNI_CHILDREN),
    value: None,
};

pub static WORD_FUNI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("des")],
    values: &[&["fundies"]],
    range: 3..=3,
};

static WORD_FUNG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FUNG_CHILDREN),
    value: None,
};

pub static WORD_FUNG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("uses")],
    values: &[&["fungi"]],
    range: 4..=4,
};

static WORD_FUND_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FUND_CHILDREN),
    value: None,
};

pub static WORD_FUND_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("amendalist"),
        dictgen::InsensitiveStr::Ascii("amendalists"),
        dictgen::InsensitiveStr::Ascii("amentais"),
        dictgen::InsensitiveStr::Ascii("amentalis"),
        dictgen::InsensitiveStr::Ascii("amentalisme"),
        dictgen::InsensitiveStr::Ascii("amentalismo"),
        dictgen::InsensitiveStr::Ascii("amentalismos"),
        dictgen::InsensitiveStr::Ascii("amentalismus"),
        dictgen::InsensitiveStr::Ascii("amentalista"),
        dictgen::InsensitiveStr::Ascii("amentalistas"),
        dictgen::InsensitiveStr::Ascii("amentalisten"),
        dictgen::InsensitiveStr::Ascii("amentalister"),
        dictgen::InsensitiveStr::Ascii("amentalisti"),
        dictgen::InsensitiveStr::Ascii("amentalistisch"),
        dictgen::InsensitiveStr::Ascii("amentalistisk"),
        dictgen::InsensitiveStr::Ascii("amentalistiska"),
        dictgen::InsensitiveStr::Ascii("amentalistiske"),
        dictgen::InsensitiveStr::Ascii("amentalistiskt"),
        dictgen::InsensitiveStr::Ascii("amentalits"),
        dictgen::InsensitiveStr::Ascii("amentalt"),
        dictgen::InsensitiveStr::Ascii("amentaly"),
        dictgen::InsensitiveStr::Ascii("amentas"),
        dictgen::InsensitiveStr::Ascii("amently"),
        dictgen::InsensitiveStr::Ascii("ametal"),
        dictgen::InsensitiveStr::Ascii("ametals"),
        dictgen::InsensitiveStr::Ascii("amnetal"),
        dictgen::InsensitiveStr::Ascii("amnetalist"),
        dictgen::InsensitiveStr::Ascii("amnetalists"),
        dictgen::InsensitiveStr::Ascii("amnetally"),
        dictgen::InsensitiveStr::Ascii("ation"),
        dictgen::InsensitiveStr::Ascii("ations"),
        dictgen::InsensitiveStr::Ascii("emantal"),
        dictgen::InsensitiveStr::Ascii("emantalist"),
        dictgen::InsensitiveStr::Ascii("emantalists"),
        dictgen::InsensitiveStr::Ascii("emantals"),
        dictgen::InsensitiveStr::Ascii("emental"),
        dictgen::InsensitiveStr::Ascii("ementally"),
        dictgen::InsensitiveStr::Ascii("ementals"),
        dictgen::InsensitiveStr::Ascii("imental"),
        dictgen::InsensitiveStr::Ascii("imentalist"),
        dictgen::InsensitiveStr::Ascii("imentalists"),
        dictgen::InsensitiveStr::Ascii("imentally"),
        dictgen::InsensitiveStr::Ascii("imentals"),
        dictgen::InsensitiveStr::Ascii("irse"),
        dictgen::InsensitiveStr::Ascii("umentalist"),
        dictgen::InsensitiveStr::Ascii("umentalists"),
    ],
    values: &[
        &["fundamentalist"],
        &["fundamentalists"],
        &["fundamentals"],
        &["fundamentals"],
        &["fundamentals"],
        &["fundamentals"],
        &["fundamentalists"],
        &["fundamentalists"],
        &["fundamentals"],
        &["fundamentalists"],
        &["fundamentalists"],
        &["fundamentalists"],
        &["fundamentals"],
        &["fundamentalists"],
        &["fundamentalists"],
        &["fundamentalists"],
        &["fundamentalists"],
        &["fundamentalists"],
        &["fundamentalists"],
        &["fundamentalist"],
        &["fundamentally"],
        &["fundamentals"],
        &["fundamental"],
        &["fundamental"],
        &["fundamentals"],
        &["fundamentals"],
        &["fundamentalist"],
        &["fundamentalists"],
        &["fundamentally"],
        &["foundation"],
        &["foundations"],
        &["fundamental"],
        &["fundamentalist"],
        &["fundamentalists"],
        &["fundamentals"],
        &["fundamental"],
        &["fundamentally"],
        &["fundamentals"],
        &["fundamental"],
        &["fundamentalist"],
        &["fundamentalists"],
        &["fundamentally"],
        &["fundamentals"],
        &["fundies"],
        &["fundamentalist"],
        &["fundamentalists"],
    ],
    range: 4..=14,
};

static WORD_FUNC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_FUNC_CHILDREN),
    value: None,
};

static WORD_FUNC_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_FUNCA_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_FUNCH_NODE),
    Some(&WORD_FUNCI_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_FUNCS_NODE),
    Some(&WORD_FUNCT_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_FUNCZ_NODE),
];

static WORD_FUNCZ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FUNCZ_CHILDREN),
    value: None,
};

pub static WORD_FUNCZ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ion")],
    values: &[&["function"]],
    range: 3..=3,
};

static WORD_FUNCT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FUNCT_CHILDREN),
    value: None,
};

pub static WORD_FUNCT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("iion"),
        dictgen::InsensitiveStr::Ascii("iional"),
        dictgen::InsensitiveStr::Ascii("iionality"),
        dictgen::InsensitiveStr::Ascii("iionally"),
        dictgen::InsensitiveStr::Ascii("iioning"),
        dictgen::InsensitiveStr::Ascii("iions"),
        dictgen::InsensitiveStr::Ascii("in"),
        dictgen::InsensitiveStr::Ascii("inality"),
        dictgen::InsensitiveStr::Ascii("ino"),
        dictgen::InsensitiveStr::Ascii("ins"),
        dictgen::InsensitiveStr::Ascii("io"),
        dictgen::InsensitiveStr::Ascii("iom"),
        dictgen::InsensitiveStr::Ascii("ioms"),
        dictgen::InsensitiveStr::Ascii("ionability"),
        dictgen::InsensitiveStr::Ascii("ionable"),
        dictgen::InsensitiveStr::Ascii("ionaility"),
        dictgen::InsensitiveStr::Ascii("ionailty"),
        dictgen::InsensitiveStr::Ascii("ionaily"),
        dictgen::InsensitiveStr::Ascii("ionaliy"),
        dictgen::InsensitiveStr::Ascii("ionallities"),
        dictgen::InsensitiveStr::Ascii("ionallity"),
        dictgen::InsensitiveStr::Ascii("ionaltiy"),
        dictgen::InsensitiveStr::Ascii("ionalty"),
        dictgen::InsensitiveStr::Ascii("ionaly"),
        dictgen::InsensitiveStr::Ascii("iong"),
        dictgen::InsensitiveStr::Ascii("ionionalities"),
        dictgen::InsensitiveStr::Ascii("ionionality"),
        dictgen::InsensitiveStr::Ascii("ionlity"),
        dictgen::InsensitiveStr::Ascii("ionnal"),
        dictgen::InsensitiveStr::Ascii("ionnalities"),
        dictgen::InsensitiveStr::Ascii("ionnality"),
        dictgen::InsensitiveStr::Ascii("ionnaly"),
        dictgen::InsensitiveStr::Ascii("ionning"),
        dictgen::InsensitiveStr::Ascii("ionon"),
        dictgen::InsensitiveStr::Ascii("ionss"),
        dictgen::InsensitiveStr::Ascii("ios"),
        dictgen::InsensitiveStr::Ascii("iosn"),
        dictgen::InsensitiveStr::Ascii("iton"),
        dictgen::InsensitiveStr::Ascii("itonal"),
        dictgen::InsensitiveStr::Ascii("itonally"),
        dictgen::InsensitiveStr::Ascii("itoned"),
        dictgen::InsensitiveStr::Ascii("itons"),
        dictgen::InsensitiveStr::Ascii("on"),
        dictgen::InsensitiveStr::Ascii("onal"),
        dictgen::InsensitiveStr::Ascii("onality"),
        dictgen::InsensitiveStr::Ascii("oning"),
        dictgen::InsensitiveStr::Ascii("ons"),
        dictgen::InsensitiveStr::Ascii("tion"),
        dictgen::InsensitiveStr::Ascii("tional"),
        dictgen::InsensitiveStr::Ascii("tionalities"),
        dictgen::InsensitiveStr::Ascii("tioned"),
        dictgen::InsensitiveStr::Ascii("tioning"),
        dictgen::InsensitiveStr::Ascii("tions"),
    ],
    values: &[
        &["function"],
        &["functional"],
        &["functionality"],
        &["functionally"],
        &["functioning"],
        &["functions"],
        &["function"],
        &["functionality"],
        &["function"],
        &["functions"],
        &["function"],
        &["function"],
        &["functions"],
        &["functionality"],
        &["functional", "functioning"],
        &["functionality"],
        &["functionality"],
        &["functionality"],
        &["functionally"],
        &["functionalities"],
        &["functionality"],
        &["functionality"],
        &["functionality"],
        &["functionally", "functionality"],
        &["functioning"],
        &["functionalities"],
        &["functionality"],
        &["functionality"],
        &["functional"],
        &["functionalities"],
        &["functionality"],
        &["functionally"],
        &["functioning"],
        &["function"],
        &["functions"],
        &["functions"],
        &["functions"],
        &["function"],
        &["functional"],
        &["functionally"],
        &["functioned"],
        &["functions"],
        &["function"],
        &["functional"],
        &["functionality"],
        &["functioning"],
        &["functions"],
        &["function"],
        &["functional"],
        &["functionalities"],
        &["functioned"],
        &["functioning"],
        &["functions"],
    ],
    range: 2..=13,
};

static WORD_FUNCS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FUNCS_CHILDREN),
    value: None,
};

pub static WORD_FUNCS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("tion"),
        dictgen::InsensitiveStr::Ascii("tions"),
    ],
    values: &[&["function", "functions"], &["functions"]],
    range: 4..=5,
};

static WORD_FUNCI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FUNCI_CHILDREN),
    value: None,
};

pub static WORD_FUNCI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("on"),
        dictgen::InsensitiveStr::Ascii("onal"),
        dictgen::InsensitiveStr::Ascii("onality"),
        dictgen::InsensitiveStr::Ascii("ons"),
        dictgen::InsensitiveStr::Ascii("otn"),
        dictgen::InsensitiveStr::Ascii("otns"),
        dictgen::InsensitiveStr::Ascii("ton"),
        dictgen::InsensitiveStr::Ascii("tonal"),
        dictgen::InsensitiveStr::Ascii("tonality"),
        dictgen::InsensitiveStr::Ascii("tonally"),
        dictgen::InsensitiveStr::Ascii("toned"),
        dictgen::InsensitiveStr::Ascii("toning"),
        dictgen::InsensitiveStr::Ascii("tons"),
    ],
    values: &[
        &["function"],
        &["functional"],
        &["functionality"],
        &["functions"],
        &["function"],
        &["functions"],
        &["function"],
        &["functional"],
        &["functionality"],
        &["functionally"],
        &["functioned"],
        &["functioning"],
        &["functions"],
    ],
    range: 2..=8,
};

static WORD_FUNCH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FUNCH_CHILDREN),
    value: None,
};

pub static WORD_FUNCH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("tion"),
        dictgen::InsensitiveStr::Ascii("tional"),
        dictgen::InsensitiveStr::Ascii("tioned"),
        dictgen::InsensitiveStr::Ascii("tioning"),
        dictgen::InsensitiveStr::Ascii("tionn"),
        dictgen::InsensitiveStr::Ascii("tionnal"),
        dictgen::InsensitiveStr::Ascii("tionned"),
        dictgen::InsensitiveStr::Ascii("tionning"),
        dictgen::InsensitiveStr::Ascii("tionns"),
        dictgen::InsensitiveStr::Ascii("tions"),
    ],
    values: &[
        &["function"],
        &["functional"],
        &["functioned"],
        &["functioning"],
        &["function"],
        &["functional"],
        &["functioned"],
        &["functioning"],
        &["functions"],
        &["functions"],
    ],
    range: 4..=8,
};

static WORD_FUNCA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FUNCA_CHILDREN),
    value: None,
};

pub static WORD_FUNCA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("tion")],
    values: &[&["function"]],
    range: 4..=4,
};

static WORD_FUM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FUM_CHILDREN),
    value: None,
};

pub static WORD_FUM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ction"),
        dictgen::InsensitiveStr::Ascii("ctional"),
        dictgen::InsensitiveStr::Ascii("ctionally"),
        dictgen::InsensitiveStr::Ascii("ctioned"),
        dictgen::InsensitiveStr::Ascii("ctions"),
    ],
    values: &[
        &["function"],
        &["functional"],
        &["functionally"],
        &["functioned"],
        &["functions"],
    ],
    range: 5..=9,
};

static WORD_FUL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FUL_CHILDREN),
    value: None,
};

pub static WORD_FUL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("filed"),
        dictgen::InsensitiveStr::Ascii("fillling"),
        dictgen::InsensitiveStr::Ascii("fulling"),
        dictgen::InsensitiveStr::Ascii("fullment"),
        dictgen::InsensitiveStr::Ascii("lanme"),
        dictgen::InsensitiveStr::Ascii("lets"),
        dictgen::InsensitiveStr::Ascii("lfil"),
        dictgen::InsensitiveStr::Ascii("lfiled"),
        dictgen::InsensitiveStr::Ascii("lfiling"),
        dictgen::InsensitiveStr::Ascii("lfill"),
        dictgen::InsensitiveStr::Ascii("lfilled"),
        dictgen::InsensitiveStr::Ascii("lfilling"),
        dictgen::InsensitiveStr::Ascii("lfills"),
        dictgen::InsensitiveStr::Ascii("lfilment"),
        dictgen::InsensitiveStr::Ascii("lfils"),
        dictgen::InsensitiveStr::Ascii("lill"),
        dictgen::InsensitiveStr::Ascii("lly"),
        dictgen::InsensitiveStr::Ascii("lscrean"),
        dictgen::InsensitiveStr::Ascii("lscreeen"),
        dictgen::InsensitiveStr::Ascii("lscren"),
        dictgen::InsensitiveStr::Ascii("lset"),
        dictgen::InsensitiveStr::Ascii("sh"),
        dictgen::InsensitiveStr::Ascii("ttershy"),
        dictgen::InsensitiveStr::Ascii("y"),
    ],
    values: &[
        &["file"],
        &["fulfilled"],
        &["fulfilling"],
        &["fulfilling"],
        &["fulfillment"],
        &["fullname"],
        &["fullest"],
        &["fulfil"],
        &["fulfilled"],
        &["fulfilling"],
        &["fulfill"],
        &["fulfilled"],
        &["fulfilling"],
        &["fulfills"],
        &["fulfilment"],
        &["fulfils"],
        &["fulfill"],
        &["fully"],
        &["fullscreen"],
        &["fullscreen"],
        &["fullscreen"],
        &["fullest"],
        &["flush"],
        &["fluttershy"],
        &["fully"],
    ],
    range: 1..=8,
};

static WORD_FUG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FUG_CHILDREN),
    value: None,
};

pub static WORD_FUG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ure"),
        dictgen::InsensitiveStr::Ascii("ured"),
        dictgen::InsensitiveStr::Ascii("ures"),
    ],
    values: &[&["figure"], &["figured"], &["figures"]],
    range: 3..=4,
};

static WORD_FUF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FUF_CHILDREN),
    value: None,
};

pub static WORD_FUF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ill"),
        dictgen::InsensitiveStr::Ascii("illed"),
    ],
    values: &[&["fulfill"], &["fulfilled"]],
    range: 3..=5,
};

static WORD_FUE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FUE_CHILDREN),
    value: None,
};

pub static WORD_FUE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("therst"),
        dictgen::InsensitiveStr::Ascii("thest"),
    ],
    values: &[&["furthest"], &["furthest"]],
    range: 5..=6,
};

static WORD_FUC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FUC_CHILDREN),
    value: None,
};

pub static WORD_FUC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ntion"),
        dictgen::InsensitiveStr::Ascii("ntional"),
        dictgen::InsensitiveStr::Ascii("ntionality"),
        dictgen::InsensitiveStr::Ascii("ntionally"),
        dictgen::InsensitiveStr::Ascii("ntioned"),
        dictgen::InsensitiveStr::Ascii("ntioning"),
        dictgen::InsensitiveStr::Ascii("ntions"),
        dictgen::InsensitiveStr::Ascii("tion"),
        dictgen::InsensitiveStr::Ascii("tionality"),
        dictgen::InsensitiveStr::Ascii("tiones"),
        dictgen::InsensitiveStr::Ascii("tioning"),
        dictgen::InsensitiveStr::Ascii("tionoid"),
        dictgen::InsensitiveStr::Ascii("tions"),
    ],
    values: &[
        &["function"],
        &["functional"],
        &["functionality"],
        &["functionally"],
        &["functioned"],
        &["functioning"],
        &["functions"],
        &["function"],
        &["functionality"],
        &["functioned"],
        &["functioning"],
        &["functionoid"],
        &["functions"],
    ],
    range: 4..=10,
};

static WORD_FUA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FUA_CHILDREN),
    value: None,
};

pub static WORD_FUA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("lt"),
        dictgen::InsensitiveStr::Ascii("lts"),
    ],
    values: &[&["fault"], &["faults"]],
    range: 2..=3,
};

static WORD_FT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FT_CHILDREN),
    value: None,
};

pub static WORD_FT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("bs"),
        dictgen::InsensitiveStr::Ascii("er"),
        dictgen::InsensitiveStr::Ascii("runacate"),
    ],
    values: &[&["ftbfs"], &["after"], &["ftruncate"]],
    range: 2..=8,
};

static WORD_FS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FS_CHILDREN),
    value: None,
};

pub static WORD_FS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("chk")],
    values: &[&["fsck"]],
    range: 3..=3,
};

static WORD_FR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_FR_CHILDREN),
    value: None,
};

static WORD_FR_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_FRA_NODE),
    None,
    None,
    None,
    Some(&WORD_FRE_NODE),
    None,
    Some(&WORD_FRG_NODE),
    None,
    Some(&WORD_FRI_NODE),
    None,
    None,
    None,
    Some(&WORD_FRM_NODE),
    None,
    Some(&WORD_FRO_NODE),
    None,
    None,
    None,
    Some(&WORD_FRS_NODE),
    None,
    Some(&WORD_FRU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_FRU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FRU_CHILDREN),
    value: None,
};

pub static WORD_FRU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("adulent"),
        dictgen::InsensitiveStr::Ascii("itin"),
        dictgen::InsensitiveStr::Ascii("itsations"),
        dictgen::InsensitiveStr::Ascii("startion"),
        dictgen::InsensitiveStr::Ascii("stracion"),
        dictgen::InsensitiveStr::Ascii("straded"),
        dictgen::InsensitiveStr::Ascii("stradet"),
        dictgen::InsensitiveStr::Ascii("straited"),
        dictgen::InsensitiveStr::Ascii("straits"),
        dictgen::InsensitiveStr::Ascii("strantes"),
        dictgen::InsensitiveStr::Ascii("strants"),
        dictgen::InsensitiveStr::Ascii("strasion"),
        dictgen::InsensitiveStr::Ascii("strasted"),
        dictgen::InsensitiveStr::Ascii("strastion"),
        dictgen::InsensitiveStr::Ascii("straties"),
        dictgen::InsensitiveStr::Ascii("stratin"),
        dictgen::InsensitiveStr::Ascii("strato"),
        dictgen::InsensitiveStr::Ascii("strats"),
        dictgen::InsensitiveStr::Ascii("strsted"),
        dictgen::InsensitiveStr::Ascii("tcose"),
    ],
    values: &[
        &["fraudulent"],
        &["fruition"],
        &["frustrations"],
        &["frustrations"],
        &["frustration"],
        &["frustrated"],
        &["frustrates"],
        &["frustrated"],
        &["frustrates"],
        &["frustrates"],
        &["frustrates"],
        &["frustrations"],
        &["frustrates"],
        &["frustrations"],
        &["frustrates"],
        &["frustration"],
        &["frustration"],
        &["frustrates"],
        &["frustrates"],
        &["fructose"],
    ],
    range: 4..=9,
};

static WORD_FRS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FRS_CHILDREN),
    value: None,
};

pub static WORD_FRS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ibee")],
    values: &[&["frisbee"]],
    range: 4..=4,
};

static WORD_FRO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FRO_CHILDREN),
    value: None,
};

pub static WORD_FRO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ce"),
        dictgen::InsensitiveStr::Ascii("given"),
        dictgen::InsensitiveStr::Ascii("inter"),
        dictgen::InsensitiveStr::Ascii("k"),
        dictgen::InsensitiveStr::Ascii("mal"),
        dictgen::InsensitiveStr::Ascii("mat"),
        dictgen::InsensitiveStr::Ascii("mated"),
        dictgen::InsensitiveStr::Ascii("mates"),
        dictgen::InsensitiveStr::Ascii("mating"),
        dictgen::InsensitiveStr::Ascii("mation"),
        dictgen::InsensitiveStr::Ascii("mats"),
        dictgen::InsensitiveStr::Ascii("matted"),
        dictgen::InsensitiveStr::Ascii("matting"),
        dictgen::InsensitiveStr::Ascii("me"),
        dictgen::InsensitiveStr::Ascii("med"),
        dictgen::InsensitiveStr::Ascii("merly"),
        dictgen::InsensitiveStr::Ascii("midable"),
        dictgen::InsensitiveStr::Ascii("mm"),
        dictgen::InsensitiveStr::Ascii("ms"),
        dictgen::InsensitiveStr::Ascii("mt"),
        dictgen::InsensitiveStr::Ascii("mtier"),
        dictgen::InsensitiveStr::Ascii("n"),
        dictgen::InsensitiveStr::Ascii("nat"),
        dictgen::InsensitiveStr::Ascii("nend"),
        dictgen::InsensitiveStr::Ascii("nends"),
        dictgen::InsensitiveStr::Ascii("niter"),
        dictgen::InsensitiveStr::Ascii("nkenstein"),
        dictgen::InsensitiveStr::Ascii("ntapge"),
        dictgen::InsensitiveStr::Ascii("nteir"),
        dictgen::InsensitiveStr::Ascii("ntent"),
        dictgen::InsensitiveStr::Ascii("ntents"),
        dictgen::InsensitiveStr::Ascii("ntilne"),
        dictgen::InsensitiveStr::Ascii("ntlinie"),
        dictgen::InsensitiveStr::Ascii("ntlinies"),
        dictgen::InsensitiveStr::Ascii("ntlinjen"),
        dictgen::InsensitiveStr::Ascii("p"),
        dictgen::InsensitiveStr::Ascii("pm"),
        dictgen::InsensitiveStr::Ascii("ps"),
        dictgen::InsensitiveStr::Ascii("saken"),
        dictgen::InsensitiveStr::Ascii("stig"),
        dictgen::InsensitiveStr::Ascii("warded"),
        dictgen::InsensitiveStr::Ascii("wrad"),
        dictgen::InsensitiveStr::Ascii("wrading"),
        dictgen::InsensitiveStr::Ascii("wrads"),
        dictgen::InsensitiveStr::Ascii("zee"),
    ],
    values: &[
        &["force"],
        &["forgiven"],
        &["frontier"],
        &["from"],
        &["formal"],
        &["format"],
        &["formatted"],
        &["formats"],
        &["formatting"],
        &["formation"],
        &["formats"],
        &["formatted"],
        &["formatting"],
        &["from"],
        &["formed"],
        &["formerly"],
        &["formidable"],
        &["from"],
        &["forms"],
        &["from", "front"],
        &["frontier"],
        &["from", "front"],
        &["format", "front"],
        &["frontend"],
        &["frontends"],
        &["frontier"],
        &["frankenstein"],
        &["frontpage"],
        &["frontier"],
        &["frontend"],
        &["frontends"],
        &["frontline"],
        &["frontline"],
        &["frontline"],
        &["frontline"],
        &["drop"],
        &["from"],
        &["drops"],
        &["forsaken"],
        &["frosting"],
        &["forwarded"],
        &["forward"],
        &["forwarding"],
        &["forwards"],
        &["frozen"],
    ],
    range: 1..=9,
};

static WORD_FRM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FRM_CHILDREN),
    value: None,
};

pub static WORD_FRM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("at"),
        dictgen::InsensitiveStr::Ascii("o"),
    ],
    values: &[&["format"], &["from"]],
    range: 1..=2,
};

static WORD_FRI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FRI_CHILDREN),
    value: None,
};

pub static WORD_FRI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cton"),
        dictgen::InsensitiveStr::Ascii("dey"),
        dictgen::InsensitiveStr::Ascii("ednship"),
        dictgen::InsensitiveStr::Ascii("ednzone"),
        dictgen::InsensitiveStr::Ascii("endboned"),
        dictgen::InsensitiveStr::Ascii("endhsip"),
        dictgen::InsensitiveStr::Ascii("endle"),
        dictgen::InsensitiveStr::Ascii("endlines"),
        dictgen::InsensitiveStr::Ascii("endlis"),
        dictgen::InsensitiveStr::Ascii("endsi"),
        dictgen::InsensitiveStr::Ascii("endsies"),
        dictgen::InsensitiveStr::Ascii("endzies"),
        dictgen::InsensitiveStr::Ascii("endzond"),
        dictgen::InsensitiveStr::Ascii("endzonded"),
        dictgen::InsensitiveStr::Ascii("endzoneado"),
        dictgen::InsensitiveStr::Ascii("endzonie"),
        dictgen::InsensitiveStr::Ascii("endzonned"),
        dictgen::InsensitiveStr::Ascii("endzowned"),
        dictgen::InsensitiveStr::Ascii("entship"),
        dictgen::InsensitiveStr::Ascii("entships"),
        dictgen::InsensitiveStr::Ascii("entzoned"),
        dictgen::InsensitiveStr::Ascii("ghtend"),
        dictgen::InsensitiveStr::Ascii("ghtenend"),
        dictgen::InsensitiveStr::Ascii("ghtining"),
        dictgen::InsensitiveStr::Ascii("gign"),
        dictgen::InsensitiveStr::Ascii("gthened"),
        dictgen::InsensitiveStr::Ascii("gthening"),
        dictgen::InsensitiveStr::Ascii("mware"),
        dictgen::InsensitiveStr::Ascii("nedzoned"),
        dictgen::InsensitiveStr::Ascii("ngeworthy"),
        dictgen::InsensitiveStr::Ascii("sday"),
        dictgen::InsensitiveStr::Ascii("st"),
        dictgen::InsensitiveStr::Ascii("stly"),
        dictgen::InsensitiveStr::Ascii("tion"),
        dictgen::InsensitiveStr::Ascii("tional"),
        dictgen::InsensitiveStr::Ascii("tions"),
        dictgen::InsensitiveStr::Ascii("vilous"),
        dictgen::InsensitiveStr::Ascii("vilously"),
    ],
    values: &[
        &["friction"],
        &["friday"],
        &["friendships"],
        &["friendzoned"],
        &["friendzoned"],
        &["friendship"],
        &["friendlies"],
        &["friendlies"],
        &["friendlies"],
        &["friendlies"],
        &["friendlies"],
        &["friendlies"],
        &["friendzoned"],
        &["friendzoned"],
        &["friendzoned"],
        &["friendzoned"],
        &["friendzoned"],
        &["friendzoned"],
        &["friendship"],
        &["friendships"],
        &["friendzoned"],
        &["frightened"],
        &["frightened"],
        &["frightening"],
        &["friggin"],
        &["frightened"],
        &["frightening"],
        &["firmware"],
        &["friendzoned"],
        &["cringeworthy"],
        &["friday"],
        &["first"],
        &["firstly"],
        &["friction"],
        &["frictional"],
        &["frictions"],
        &["frivolous"],
        &["frivolously"],
    ],
    range: 2..=10,
};

static WORD_FRG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FRG_CHILDREN),
    value: None,
};

pub static WORD_FRG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ament")],
    values: &[&["fragment"]],
    range: 5..=5,
};

static WORD_FRE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FRE_CHILDREN),
    value: None,
};

pub static WORD_FRE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ckels"),
        dictgen::InsensitiveStr::Ascii("cklers"),
        dictgen::InsensitiveStr::Ascii("cuencies"),
        dictgen::InsensitiveStr::Ascii("cuency"),
        dictgen::InsensitiveStr::Ascii("cuent"),
        dictgen::InsensitiveStr::Ascii("cuented"),
        dictgen::InsensitiveStr::Ascii("cuently"),
        dictgen::InsensitiveStr::Ascii("cuents"),
        dictgen::InsensitiveStr::Ascii("ecallrelpy"),
        dictgen::InsensitiveStr::Ascii("edeom"),
        dictgen::InsensitiveStr::Ascii("edomers"),
        dictgen::InsensitiveStr::Ascii("edomes"),
        dictgen::InsensitiveStr::Ascii("edomest"),
        dictgen::InsensitiveStr::Ascii("edon"),
        dictgen::InsensitiveStr::Ascii("edons"),
        dictgen::InsensitiveStr::Ascii("edos"),
        dictgen::InsensitiveStr::Ascii("edum"),
        dictgen::InsensitiveStr::Ascii("edums"),
        dictgen::InsensitiveStr::Ascii("ee"),
        dictgen::InsensitiveStr::Ascii("eed"),
        dictgen::InsensitiveStr::Ascii("estlye"),
        dictgen::InsensitiveStr::Ascii("esytle"),
        dictgen::InsensitiveStr::Ascii("ez"),
        dictgen::InsensitiveStr::Ascii("ezs"),
        dictgen::InsensitiveStr::Ascii("ind"),
        dictgen::InsensitiveStr::Ascii("indlies"),
        dictgen::InsensitiveStr::Ascii("indly"),
        dictgen::InsensitiveStr::Ascii("inds"),
        dictgen::InsensitiveStr::Ascii("indship"),
        dictgen::InsensitiveStr::Ascii("indships"),
        dictgen::InsensitiveStr::Ascii("indzoned"),
        dictgen::InsensitiveStr::Ascii("mentation"),
        dictgen::InsensitiveStr::Ascii("mented"),
        dictgen::InsensitiveStr::Ascii("qencies"),
        dictgen::InsensitiveStr::Ascii("qency"),
        dictgen::InsensitiveStr::Ascii("qeuncies"),
        dictgen::InsensitiveStr::Ascii("qeuncy"),
        dictgen::InsensitiveStr::Ascii("qiencies"),
        dictgen::InsensitiveStr::Ascii("qiency"),
        dictgen::InsensitiveStr::Ascii("qquencies"),
        dictgen::InsensitiveStr::Ascii("qquency"),
        dictgen::InsensitiveStr::Ascii("quancies"),
        dictgen::InsensitiveStr::Ascii("quancy"),
        dictgen::InsensitiveStr::Ascii("quant"),
        dictgen::InsensitiveStr::Ascii("quantly"),
        dictgen::InsensitiveStr::Ascii("quence"),
        dictgen::InsensitiveStr::Ascii("quences"),
        dictgen::InsensitiveStr::Ascii("quencey"),
        dictgen::InsensitiveStr::Ascii("quenct"),
        dictgen::InsensitiveStr::Ascii("quenices"),
        dictgen::InsensitiveStr::Ascii("quenies"),
        dictgen::InsensitiveStr::Ascii("quensies"),
        dictgen::InsensitiveStr::Ascii("quenties"),
        dictgen::InsensitiveStr::Ascii("quentily"),
        dictgen::InsensitiveStr::Ascii("queny"),
        dictgen::InsensitiveStr::Ascii("quenzies"),
        dictgen::InsensitiveStr::Ascii("quncies"),
        dictgen::InsensitiveStr::Ascii("quncy"),
        dictgen::InsensitiveStr::Ascii("ze"),
        dictgen::InsensitiveStr::Ascii("zes"),
    ],
    values: &[
        &["freckles"],
        &["freckles"],
        &["frequencies"],
        &["frequency"],
        &["frequent"],
        &["frequented"],
        &["frequently"],
        &["frequents"],
        &["freecallreply"],
        &["freedom", "freedoms"],
        &["freedoms"],
        &["freedoms"],
        &["freedoms"],
        &["freedom"],
        &["freedoms"],
        &["freedoms"],
        &["freedom"],
        &["freedoms"],
        &["free"],
        &["freed"],
        &["freestyle"],
        &["freestyle"],
        &["frees", "freeze"],
        &["freezes"],
        &["friend"],
        &["friendlies"],
        &["friendly"],
        &["friends"],
        &["friendship"],
        &["friendships"],
        &["friendzoned"],
        &["fermentation"],
        &["fermented"],
        &["frequencies"],
        &["frequency"],
        &["frequencies"],
        &["frequency"],
        &["frequencies"],
        &["frequency"],
        &["frequencies"],
        &["frequency"],
        &["frequencies"],
        &["frequency"],
        &["frequent"],
        &["frequently"],
        &["frequencies"],
        &["frequencies"],
        &["frequency"],
        &["frequency", "frequent"],
        &["frequencies"],
        &["frequencies"],
        &["frequencies"],
        &["frequencies"],
        &["frequently"],
        &["frequency", "frequently", "frequent"],
        &["frequencies"],
        &["frequencies"],
        &["frequency"],
        &["freeze"],
        &["freezes"],
    ],
    range: 2..=10,
};

static WORD_FRA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_FRA_CHILDREN),
    value: None,
};

static WORD_FRA_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    Some(&WORD_FRAC_NODE),
    None,
    None,
    None,
    Some(&WORD_FRAG_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_FRAM_NODE),
    Some(&WORD_FRAN_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_FRAT_NODE),
    Some(&WORD_FRAU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_FRAU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FRAU_CHILDREN),
    value: None,
};

pub static WORD_FRAU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("dalent"),
        dictgen::InsensitiveStr::Ascii("delant"),
        dictgen::InsensitiveStr::Ascii("delent"),
        dictgen::InsensitiveStr::Ascii("dolent"),
        dictgen::InsensitiveStr::Ascii("dulant"),
    ],
    values: &[
        &["fraudulent"],
        &["fraudulent"],
        &["fraudulent"],
        &["fraudulent"],
        &["fraudulent"],
    ],
    range: 6..=6,
};

static WORD_FRAT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FRAT_CHILDREN),
    value: None,
};

pub static WORD_FRAT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ernaty"),
        dictgen::InsensitiveStr::Ascii("ernety"),
        dictgen::InsensitiveStr::Ascii("erntiy"),
        dictgen::InsensitiveStr::Ascii("urnity"),
    ],
    values: &[
        &["fraternity"],
        &["fraternity"],
        &["fraternity"],
        &["fraternity"],
    ],
    range: 6..=6,
};

static WORD_FRAN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FRAN_CHILDREN),
    value: None,
};

pub static WORD_FRAN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("caises"),
        dictgen::InsensitiveStr::Ascii("ches"),
        dictgen::InsensitiveStr::Ascii("chices"),
        dictgen::InsensitiveStr::Ascii("chie"),
        dictgen::InsensitiveStr::Ascii("chies"),
        dictgen::InsensitiveStr::Ascii("chieses"),
        dictgen::InsensitiveStr::Ascii("chines"),
        dictgen::InsensitiveStr::Ascii("chizes"),
        dictgen::InsensitiveStr::Ascii("chsies"),
        dictgen::InsensitiveStr::Ascii("ciso"),
        dictgen::InsensitiveStr::Ascii("csico"),
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("kensite"),
        dictgen::InsensitiveStr::Ascii("kenstain"),
        dictgen::InsensitiveStr::Ascii("kensteen"),
        dictgen::InsensitiveStr::Ascii("kensten"),
        dictgen::InsensitiveStr::Ascii("kenstiens"),
        dictgen::InsensitiveStr::Ascii("kenstine"),
        dictgen::InsensitiveStr::Ascii("kenstined"),
        dictgen::InsensitiveStr::Ascii("kenstiner"),
        dictgen::InsensitiveStr::Ascii("kenstines"),
        dictgen::InsensitiveStr::Ascii("kiln"),
        dictgen::InsensitiveStr::Ascii("kin"),
        dictgen::InsensitiveStr::Ascii("kinstein"),
        dictgen::InsensitiveStr::Ascii("lkin"),
        dictgen::InsensitiveStr::Ascii("scico"),
        dictgen::InsensitiveStr::Ascii("siscan"),
        dictgen::InsensitiveStr::Ascii("siscans"),
        dictgen::InsensitiveStr::Ascii("ticaly"),
        dictgen::InsensitiveStr::Ascii("ticlly"),
        dictgen::InsensitiveStr::Ascii("zise"),
    ],
    values: &[
        &["franchises"],
        &["franchise"],
        &["franchises"],
        &["franchises"],
        &["franchise"],
        &["franchises"],
        &["franchises"],
        &["franchises"],
        &["franchises"],
        &["francisco"],
        &["francisco"],
        &["frame"],
        &["frankenstein"],
        &["frankenstein"],
        &["frankenstein"],
        &["frankenstein"],
        &["frankenstein"],
        &["frankenstein"],
        &["frankenstein"],
        &["frankenstein"],
        &["frankenstein"],
        &["franklin"],
        &["franklin"],
        &["frankenstein"],
        &["franklin"],
        &["francisco"],
        &["franciscan"],
        &["franciscans"],
        &["frantically"],
        &["frantically"],
        &["franchise"],
    ],
    range: 1..=9,
};

static WORD_FRAM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FRAM_CHILDREN),
    value: None,
};

pub static WORD_FRAM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("buffer"),
        dictgen::InsensitiveStr::Ascii("ebufer"),
        dictgen::InsensitiveStr::Ascii("ei"),
        dictgen::InsensitiveStr::Ascii("ent"),
        dictgen::InsensitiveStr::Ascii("ented"),
        dictgen::InsensitiveStr::Ascii("ents"),
        dictgen::InsensitiveStr::Ascii("eowrk"),
        dictgen::InsensitiveStr::Ascii("ethrower"),
        dictgen::InsensitiveStr::Ascii("etyp"),
        dictgen::InsensitiveStr::Ascii("ewoek"),
        dictgen::InsensitiveStr::Ascii("ewoeks"),
        dictgen::InsensitiveStr::Ascii("eword"),
        dictgen::InsensitiveStr::Ascii("eworkk"),
        dictgen::InsensitiveStr::Ascii("gent"),
        dictgen::InsensitiveStr::Ascii("layout"),
        dictgen::InsensitiveStr::Ascii("ming"),
        dictgen::InsensitiveStr::Ascii("w"),
        dictgen::InsensitiveStr::Ascii("wd"),
        dictgen::InsensitiveStr::Ascii("wework"),
        dictgen::InsensitiveStr::Ascii("work"),
        dictgen::InsensitiveStr::Ascii("works"),
        dictgen::InsensitiveStr::Ascii("ws"),
    ],
    values: &[
        &["framebuffer"],
        &["framebuffer"],
        &["frame"],
        &["fragment"],
        &["fragmented"],
        &["fragments"],
        &["framework"],
        &["flamethrower"],
        &["frametype"],
        &["framework"],
        &["frameworks"],
        &["framework"],
        &["framework"],
        &["fragment"],
        &["framelayout"],
        &["framing"],
        &["frame"],
        &["framed"],
        &["framework"],
        &["framework"],
        &["frameworks"],
        &["frames"],
    ],
    range: 1..=8,
};

static WORD_FRAG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FRAG_CHILDREN),
    value: None,
};

pub static WORD_FRAG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ement"),
        dictgen::InsensitiveStr::Ascii("ementation"),
        dictgen::InsensitiveStr::Ascii("ements"),
        dictgen::InsensitiveStr::Ascii("mant"),
        dictgen::InsensitiveStr::Ascii("mantation"),
        dictgen::InsensitiveStr::Ascii("manted"),
        dictgen::InsensitiveStr::Ascii("mants"),
        dictgen::InsensitiveStr::Ascii("menet"),
        dictgen::InsensitiveStr::Ascii("menetd"),
        dictgen::InsensitiveStr::Ascii("meneted"),
        dictgen::InsensitiveStr::Ascii("meneting"),
        dictgen::InsensitiveStr::Ascii("menets"),
        dictgen::InsensitiveStr::Ascii("menot"),
        dictgen::InsensitiveStr::Ascii("met"),
        dictgen::InsensitiveStr::Ascii("mnet"),
    ],
    values: &[
        &["fragment"],
        &["fragmentation"],
        &["fragments"],
        &["fragment"],
        &["fragmentation"],
        &["fragment"],
        &["fragments"],
        &["fragment"],
        &["fragmented"],
        &["fragmented"],
        &["fragmenting"],
        &["fragments"],
        &["fragment"],
        &["fragment"],
        &["fragment"],
    ],
    range: 3..=10,
};

static WORD_FRAC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FRAC_CHILDREN),
    value: None,
};

pub static WORD_FRAC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ional"),
        dictgen::InsensitiveStr::Ascii("kign"),
        dictgen::InsensitiveStr::Ascii("talers"),
        dictgen::InsensitiveStr::Ascii("tales"),
        dictgen::InsensitiveStr::Ascii("talis"),
        dictgen::InsensitiveStr::Ascii("talius"),
        dictgen::InsensitiveStr::Ascii("talpus"),
        dictgen::InsensitiveStr::Ascii("talus"),
        dictgen::InsensitiveStr::Ascii("ter"),
        dictgen::InsensitiveStr::Ascii("turare"),
    ],
    values: &[
        &["fractional"],
        &["fracking"],
        &["fractals"],
        &["fractals"],
        &["fractals"],
        &["fractals"],
        &["fractals"],
        &["fractals"],
        &["fracture"],
        &["fracture"],
    ],
    range: 3..=6,
};

static WORD_FP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FP_CHILDREN),
    value: None,
};

pub static WORD_FP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("r"),
        dictgen::InsensitiveStr::Ascii("rmat"),
        dictgen::InsensitiveStr::Ascii("t"),
    ],
    values: &[&["for", "far", "fps"], &["format"], &["ftp"]],
    range: 1..=4,
};

static WORD_FO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_FO_CHILDREN),
    value: Some(&["of", "for", "do", "go", "to"]),
};

static WORD_FO_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    Some(&WORD_FOC_NODE),
    Some(&WORD_FOD_NODE),
    None,
    Some(&WORD_FOF_NODE),
    Some(&WORD_FOG_NODE),
    None,
    Some(&WORD_FOI_NODE),
    None,
    None,
    Some(&WORD_FOL_NODE),
    Some(&WORD_FOM_NODE),
    Some(&WORD_FON_NODE),
    Some(&WORD_FOO_NODE),
    Some(&WORD_FOP_NODE),
    None,
    Some(&WORD_FOR_NODE),
    Some(&WORD_FOS_NODE),
    Some(&WORD_FOT_NODE),
    Some(&WORD_FOU_NODE),
    None,
    Some(&WORD_FOW_NODE),
    None,
    None,
    None,
];

static WORD_FOW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FOW_CHILDREN),
    value: None,
};

pub static WORD_FOW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ard"),
        dictgen::InsensitiveStr::Ascii("arded"),
        dictgen::InsensitiveStr::Ascii("arding"),
        dictgen::InsensitiveStr::Ascii("ards"),
        dictgen::InsensitiveStr::Ascii("ll"),
        dictgen::InsensitiveStr::Ascii("lling"),
        dictgen::InsensitiveStr::Ascii("rards"),
    ],
    values: &[
        &["forward"],
        &["forwarded"],
        &["forwarding"],
        &["forwards"],
        &["follow", "foul"],
        &["following"],
        &["forwards"],
    ],
    range: 2..=6,
};

static WORD_FOU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FOU_CHILDREN),
    value: None,
};

pub static WORD_FOU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cs"),
        dictgen::InsensitiveStr::Ascii("dn"),
        dictgen::InsensitiveStr::Ascii("dning"),
        dictgen::InsensitiveStr::Ascii("gth"),
        dictgen::InsensitiveStr::Ascii("lt"),
        dictgen::InsensitiveStr::Ascii("lts"),
        dictgen::InsensitiveStr::Ascii("ndaiton"),
        dictgen::InsensitiveStr::Ascii("ndaries"),
        dictgen::InsensitiveStr::Ascii("ndary"),
        dictgen::InsensitiveStr::Ascii("ndatin"),
        dictgen::InsensitiveStr::Ascii("ndatoin"),
        dictgen::InsensitiveStr::Ascii("ndland"),
        dictgen::InsensitiveStr::Ascii("ntan"),
        dictgen::InsensitiveStr::Ascii("ntian"),
        dictgen::InsensitiveStr::Ascii("rh"),
        dictgen::InsensitiveStr::Ascii("rteeen"),
        dictgen::InsensitiveStr::Ascii("rten"),
        dictgen::InsensitiveStr::Ascii("rties"),
        dictgen::InsensitiveStr::Ascii("rty"),
        dictgen::InsensitiveStr::Ascii("th"),
        dictgen::InsensitiveStr::Ascii("und"),
    ],
    values: &[
        &["focus"],
        &["found"],
        &["founding"],
        &["fought"],
        &["fault"],
        &["faults"],
        &["foundations"],
        &["foundries"],
        &["foundry"],
        &["foundations"],
        &["foundations"],
        &["newfoundland"],
        &["fountain"],
        &["fountain"],
        &["fourth"],
        &["fourteen"],
        &["fourteen"],
        &["forties"],
        &["forty"],
        &["fourth"],
        &["found"],
    ],
    range: 2..=7,
};

static WORD_FOT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FOT_CHILDREN),
    value: Some(&["for", "fit", "dot", "rot", "cot", "got", "tot", "fog"]),
};

pub static WORD_FOT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("o"),
        dictgen::InsensitiveStr::Ascii("ograf"),
        dictgen::InsensitiveStr::Ascii("ografic"),
        dictgen::InsensitiveStr::Ascii("ografical"),
        dictgen::InsensitiveStr::Ascii("ografy"),
        dictgen::InsensitiveStr::Ascii("ograph"),
        dictgen::InsensitiveStr::Ascii("ography"),
    ],
    values: &[
        &["photo"],
        &["photograph"],
        &["photographic"],
        &["photographical"],
        &["photography"],
        &["photograph"],
        &["photography"],
    ],
    range: 1..=9,
};

static WORD_FOS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FOS_CHILDREN),
    value: None,
};

pub static WORD_FOS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("siles"),
        dictgen::InsensitiveStr::Ascii("silis"),
    ],
    values: &[&["fossils"], &["fossils"]],
    range: 5..=5,
};

static WORD_FOR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_FOR_CHILDREN),
    value: None,
};

static WORD_FOR_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_FORA_NODE),
    Some(&WORD_FORB_NODE),
    Some(&WORD_FORC_NODE),
    None,
    Some(&WORD_FORE_NODE),
    Some(&WORD_FORF_NODE),
    Some(&WORD_FORG_NODE),
    Some(&WORD_FORH_NODE),
    Some(&WORD_FORI_NODE),
    None,
    None,
    Some(&WORD_FORL_NODE),
    Some(&WORD_FORM_NODE),
    Some(&WORD_FORN_NODE),
    Some(&WORD_FORO_NODE),
    None,
    None,
    Some(&WORD_FORR_NODE),
    Some(&WORD_FORS_NODE),
    Some(&WORD_FORT_NODE),
    Some(&WORD_FORU_NODE),
    Some(&WORD_FORV_NODE),
    Some(&WORD_FORW_NODE),
    None,
    None,
    None,
];

static WORD_FORW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FORW_CHILDREN),
    value: None,
};

pub static WORD_FORW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ad"),
        dictgen::InsensitiveStr::Ascii("aded"),
        dictgen::InsensitiveStr::Ascii("ading"),
        dictgen::InsensitiveStr::Ascii("ads"),
        dictgen::InsensitiveStr::Ascii("ardig"),
        dictgen::InsensitiveStr::Ascii("ared"),
        dictgen::InsensitiveStr::Ascii("aring"),
        dictgen::InsensitiveStr::Ascii("warded"),
    ],
    values: &[
        &["forward"],
        &["forwarded"],
        &["forwarding"],
        &["forwards"],
        &["forwarding"],
        &["forwarded", "forward"],
        &["forwarding"],
        &["forwarded"],
    ],
    range: 2..=6,
};

static WORD_FORV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FORV_CHILDREN),
    value: None,
};

pub static WORD_FORV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("er")],
    values: &[&["forever"]],
    range: 2..=2,
};

static WORD_FORU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FORU_CHILDREN),
    value: None,
};

pub static WORD_FORU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("la"),
        dictgen::InsensitiveStr::Ascii("las"),
        dictgen::InsensitiveStr::Ascii("mla"),
        dictgen::InsensitiveStr::Ascii("mlas"),
        dictgen::InsensitiveStr::Ascii("mlate"),
        dictgen::InsensitiveStr::Ascii("mula"),
        dictgen::InsensitiveStr::Ascii("mulas"),
        dictgen::InsensitiveStr::Ascii("nate"),
        dictgen::InsensitiveStr::Ascii("nately"),
        dictgen::InsensitiveStr::Ascii("nner"),
        dictgen::InsensitiveStr::Ascii("tunate"),
        dictgen::InsensitiveStr::Ascii("tunately"),
    ],
    values: &[
        &["formula"],
        &["formulas"],
        &["formula"],
        &["formulas"],
        &["formulate"],
        &["formula"],
        &["formulas"],
        &["fortunate"],
        &["fortunately"],
        &["forerunner"],
        &["fortunate"],
        &["fortunately"],
    ],
    range: 2..=8,
};

static WORD_FORT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FORT_CHILDREN),
    value: None,
};

pub static WORD_FORT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("an"),
        dictgen::InsensitiveStr::Ascii("at"),
        dictgen::InsensitiveStr::Ascii("een"),
        dictgen::InsensitiveStr::Ascii("elling"),
        dictgen::InsensitiveStr::Ascii("hcominng"),
        dictgen::InsensitiveStr::Ascii("hcomming"),
        dictgen::InsensitiveStr::Ascii("itudine"),
        dictgen::InsensitiveStr::Ascii("itue"),
        dictgen::InsensitiveStr::Ascii("uante"),
        dictgen::InsensitiveStr::Ascii("uantely"),
        dictgen::InsensitiveStr::Ascii("unae"),
        dictgen::InsensitiveStr::Ascii("unaly"),
        dictgen::InsensitiveStr::Ascii("unantly"),
        dictgen::InsensitiveStr::Ascii("unat"),
        dictgen::InsensitiveStr::Ascii("unatelly"),
        dictgen::InsensitiveStr::Ascii("unatley"),
        dictgen::InsensitiveStr::Ascii("unatly"),
        dictgen::InsensitiveStr::Ascii("unetely"),
        dictgen::InsensitiveStr::Ascii("unetly"),
        dictgen::InsensitiveStr::Ascii("unte"),
    ],
    values: &[
        &["fortran"],
        &["format"],
        &["fourteen"],
        &["foretelling"],
        &["forthcoming"],
        &["forthcoming"],
        &["fortitude"],
        &["fortitude"],
        &["fortunate"],
        &["fortunately"],
        &["fortune"],
        &["fortunately"],
        &["fortunately"],
        &["fortunate"],
        &["fortunately"],
        &["fortunately"],
        &["fortunately"],
        &["fortunately"],
        &["fortunately"],
        &["fortune"],
    ],
    range: 2..=8,
};

static WORD_FORS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FORS_CHILDREN),
    value: None,
};

pub static WORD_FORS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("akn"),
        dictgen::InsensitiveStr::Ascii("ane"),
        dictgen::InsensitiveStr::Ascii("aw"),
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("eeable"),
        dictgen::InsensitiveStr::Ascii("ekan"),
        dictgen::InsensitiveStr::Ascii("ekin"),
        dictgen::InsensitiveStr::Ascii("enic"),
        dictgen::InsensitiveStr::Ascii("kaen"),
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("ting"),
    ],
    values: &[
        &["forsaken"],
        &["forsaken"],
        &["foresaw"],
        &["force"],
        &["foreseeable"],
        &["forsaken"],
        &["foreskin"],
        &["forensic"],
        &["forsaken"],
        &["first", "forced"],
        &["frosting"],
    ],
    range: 1..=6,
};

static WORD_FORR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FORR_CHILDREN),
    value: Some(&["for"]),
};

pub static WORD_FORR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("esst"),
        dictgen::InsensitiveStr::Ascii("set"),
    ],
    values: &[&["forrest"], &["forrest"]],
    range: 3..=4,
};

static WORD_FORO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FORO_CHILDREN),
    value: None,
};

pub static WORD_FORO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("tten"),
    ],
    values: &[&["forgot"], &["forgotten"]],
    range: 1..=4,
};

static WORD_FORN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FORN_CHILDREN),
    value: None,
};

pub static WORD_FORN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("at"),
        dictgen::InsensitiveStr::Ascii("ated"),
        dictgen::InsensitiveStr::Ascii("ater"),
        dictgen::InsensitiveStr::Ascii("ats"),
        dictgen::InsensitiveStr::Ascii("atted"),
        dictgen::InsensitiveStr::Ascii("atter"),
        dictgen::InsensitiveStr::Ascii("esic"),
        dictgen::InsensitiveStr::Ascii("tline"),
        dictgen::InsensitiveStr::Ascii("tpage"),
    ],
    values: &[
        &["format"],
        &["formatted"],
        &["formatter"],
        &["formats"],
        &["formatted"],
        &["formatter"],
        &["forensic"],
        &["frontline"],
        &["frontpage"],
    ],
    range: 2..=5,
};

static WORD_FORM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FORM_CHILDREN),
    value: None,
};

pub static WORD_FORM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("adible"),
        dictgen::InsensitiveStr::Ascii("alhaut"),
        dictgen::InsensitiveStr::Ascii("allity"),
        dictgen::InsensitiveStr::Ascii("allize"),
        dictgen::InsensitiveStr::Ascii("allized"),
        dictgen::InsensitiveStr::Ascii("aly"),
        dictgen::InsensitiveStr::Ascii("ate"),
        dictgen::InsensitiveStr::Ascii("ated"),
        dictgen::InsensitiveStr::Ascii("ater"),
        dictgen::InsensitiveStr::Ascii("aters"),
        dictgen::InsensitiveStr::Ascii("ates"),
        dictgen::InsensitiveStr::Ascii("ath"),
        dictgen::InsensitiveStr::Ascii("aths"),
        dictgen::InsensitiveStr::Ascii("atiing"),
        dictgen::InsensitiveStr::Ascii("atin"),
        dictgen::InsensitiveStr::Ascii("ating"),
        dictgen::InsensitiveStr::Ascii("atings"),
        dictgen::InsensitiveStr::Ascii("ativos"),
        dictgen::InsensitiveStr::Ascii("atteded"),
        dictgen::InsensitiveStr::Ascii("attgin"),
        dictgen::InsensitiveStr::Ascii("attied"),
        dictgen::InsensitiveStr::Ascii("attind"),
        dictgen::InsensitiveStr::Ascii("attings"),
        dictgen::InsensitiveStr::Ascii("attring"),
        dictgen::InsensitiveStr::Ascii("attted"),
        dictgen::InsensitiveStr::Ascii("attting"),
        dictgen::InsensitiveStr::Ascii("elly"),
        dictgen::InsensitiveStr::Ascii("ely"),
        dictgen::InsensitiveStr::Ascii("en"),
        dictgen::InsensitiveStr::Ascii("end"),
        dictgen::InsensitiveStr::Ascii("erlly"),
        dictgen::InsensitiveStr::Ascii("ery"),
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("idabble"),
        dictgen::InsensitiveStr::Ascii("idabel"),
        dictgen::InsensitiveStr::Ascii("idabelt"),
        dictgen::InsensitiveStr::Ascii("idabil"),
        dictgen::InsensitiveStr::Ascii("idabile"),
        dictgen::InsensitiveStr::Ascii("idible"),
        dictgen::InsensitiveStr::Ascii("inable"),
        dictgen::InsensitiveStr::Ascii("itable"),
        dictgen::InsensitiveStr::Ascii("matted"),
        dictgen::InsensitiveStr::Ascii("ost"),
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("ua"),
        dictgen::InsensitiveStr::Ascii("ual"),
        dictgen::InsensitiveStr::Ascii("uala"),
        dictgen::InsensitiveStr::Ascii("uale"),
        dictgen::InsensitiveStr::Ascii("uals"),
        dictgen::InsensitiveStr::Ascii("ualte"),
        dictgen::InsensitiveStr::Ascii("uladas"),
        dictgen::InsensitiveStr::Ascii("ulados"),
        dictgen::InsensitiveStr::Ascii("ulaes"),
        dictgen::InsensitiveStr::Ascii("ulaical"),
        dictgen::InsensitiveStr::Ascii("ulars"),
        dictgen::InsensitiveStr::Ascii("ulayic"),
        dictgen::InsensitiveStr::Ascii("uls"),
    ],
    values: &[
        &["formidable"],
        &["fomalhaut"],
        &["formally"],
        &["formalize"],
        &["formalized"],
        &["formally", "formerly"],
        &["format"],
        &["formatted"],
        &["formatter"],
        &["formatters"],
        &["formats"],
        &["format"],
        &["formats"],
        &["formatting"],
        &["formation"],
        &["formatting"],
        &["formations"],
        &["formations"],
        &["formatted"],
        &["formatting"],
        &["formatted"],
        &["formatting"],
        &["formatting"],
        &["formatting"],
        &["formatted"],
        &["formatting"],
        &["formerly"],
        &["formerly"],
        &["foremen"],
        &["formed"],
        &["formerly"],
        &["formerly"],
        &["forms", "formed"],
        &["formidable"],
        &["formidable"],
        &["formidable"],
        &["formidable"],
        &["formidable"],
        &["formidable"],
        &["formidable"],
        &["formidable"],
        &["formatted"],
        &["foremost"],
        &["format"],
        &["formula"],
        &["formula"],
        &["formula"],
        &["formulae"],
        &["formulas"],
        &["formulate"],
        &["formulas"],
        &["formulas"],
        &["formulas"],
        &["formulaic"],
        &["formulas"],
        &["formulaic"],
        &["formulas"],
    ],
    range: 1..=7,
};

static WORD_FORL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FORL_CHILDREN),
    value: None,
};

pub static WORD_FORL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("d"),
        dictgen::InsensitiveStr::Ascii("der"),
        dictgen::InsensitiveStr::Ascii("ders"),
    ],
    values: &[&["fold"], &["folder"], &["folders"]],
    range: 1..=4,
};

static WORD_FORI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FORI_CHILDREN),
    value: None,
};

pub static WORD_FORI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cbly"),
        dictgen::InsensitiveStr::Ascii("egn"),
        dictgen::InsensitiveStr::Ascii("egner"),
        dictgen::InsensitiveStr::Ascii("egners"),
        dictgen::InsensitiveStr::Ascii("gener"),
        dictgen::InsensitiveStr::Ascii("gven"),
        dictgen::InsensitiveStr::Ascii("n"),
        dictgen::InsensitiveStr::Ascii("ner"),
        dictgen::InsensitiveStr::Ascii("ners"),
    ],
    values: &[
        &["forcibly"],
        &["foreign"],
        &["foreigner"],
        &["foreigners"],
        &["foreigner"],
        &["forgiven"],
        &["foreign"],
        &["foreigner"],
        &["foreigners"],
    ],
    range: 1..=6,
};

static WORD_FORH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FORH_CHILDREN),
    value: None,
};

pub static WORD_FORH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ead")],
    values: &[&["forehead"]],
    range: 3..=3,
};

static WORD_FORG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FORG_CHILDREN),
    value: None,
};

pub static WORD_FORG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("einer"),
        dictgen::InsensitiveStr::Ascii("einers"),
        dictgen::InsensitiveStr::Ascii("eround"),
        dictgen::InsensitiveStr::Ascii("ettting"),
        dictgen::InsensitiveStr::Ascii("iener"),
        dictgen::InsensitiveStr::Ascii("ieners"),
        dictgen::InsensitiveStr::Ascii("ivance"),
        dictgen::InsensitiveStr::Ascii("ivenness"),
        dictgen::InsensitiveStr::Ascii("ivens"),
        dictgen::InsensitiveStr::Ascii("ivenss"),
        dictgen::InsensitiveStr::Ascii("iviness"),
        dictgen::InsensitiveStr::Ascii("oten"),
        dictgen::InsensitiveStr::Ascii("otting"),
        dictgen::InsensitiveStr::Ascii("otton"),
        dictgen::InsensitiveStr::Ascii("round"),
    ],
    values: &[
        &["foreigner"],
        &["foreigners"],
        &["foreground"],
        &["forgetting"],
        &["foreigner"],
        &["foreigners"],
        &["forgiven"],
        &["forgiveness"],
        &["forgiveness"],
        &["forgiveness"],
        &["forgiveness"],
        &["forgotten"],
        &["forgetting"],
        &["forgotten"],
        &["foreground"],
    ],
    range: 4..=8,
};

static WORD_FORF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FORF_CHILDREN),
    value: None,
};

pub static WORD_FORF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("iet"),
        dictgen::InsensitiveStr::Ascii("it"),
        dictgen::InsensitiveStr::Ascii("ited"),
        dictgen::InsensitiveStr::Ascii("iting"),
        dictgen::InsensitiveStr::Ascii("its"),
    ],
    values: &[
        &["forfeit"],
        &["forfeit"],
        &["forfeited"],
        &["forfeiting"],
        &["forfeits"],
    ],
    range: 2..=5,
};

static WORD_FORE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FORE_CHILDREN),
    value: None,
};

pub static WORD_FORE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("amrs"),
        dictgen::InsensitiveStr::Ascii("armes"),
        dictgen::InsensitiveStr::Ascii("ce"),
        dictgen::InsensitiveStr::Ascii("ced"),
        dictgen::InsensitiveStr::Ascii("ces"),
        dictgen::InsensitiveStr::Ascii("cfully"),
        dictgen::InsensitiveStr::Ascii("fit"),
        dictgen::InsensitiveStr::Ascii("gin"),
        dictgen::InsensitiveStr::Ascii("giner"),
        dictgen::InsensitiveStr::Ascii("giners"),
        dictgen::InsensitiveStr::Ascii("gorund"),
        dictgen::InsensitiveStr::Ascii("grond"),
        dictgen::InsensitiveStr::Ascii("gronds"),
        dictgen::InsensitiveStr::Ascii("groud"),
        dictgen::InsensitiveStr::Ascii("ignese"),
        dictgen::InsensitiveStr::Ascii("igness"),
        dictgen::InsensitiveStr::Ascii("ignors"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("inger"),
        dictgen::InsensitiveStr::Ascii("ingers"),
        dictgen::InsensitiveStr::Ascii("ksin"),
        dictgen::InsensitiveStr::Ascii("mentionned"),
        dictgen::InsensitiveStr::Ascii("nics"),
        dictgen::InsensitiveStr::Ascii("nisc"),
        dictgen::InsensitiveStr::Ascii("nsisch"),
        dictgen::InsensitiveStr::Ascii("rmly"),
        dictgen::InsensitiveStr::Ascii("seaable"),
        dictgen::InsensitiveStr::Ascii("seeble"),
        dictgen::InsensitiveStr::Ascii("shadowning"),
        dictgen::InsensitiveStr::Ascii("snic"),
        dictgen::InsensitiveStr::Ascii("sseable"),
        dictgen::InsensitiveStr::Ascii("ward"),
    ],
    values: &[
        &["forearms"],
        &["forearms"],
        &["force"],
        &["forced"],
        &["forces"],
        &["forcefully"],
        &["forfeit"],
        &["foreign"],
        &["foreigner"],
        &["foreigners"],
        &["foreground"],
        &["foreground"],
        &["foregrounds"],
        &["foreground"],
        &["foreigners"],
        &["foreigners"],
        &["foreigners"],
        &["foreign"],
        &["foreigner"],
        &["foreigners"],
        &["foreskin"],
        &["aforementioned"],
        &["forensic"],
        &["forensic"],
        &["forensic"],
        &["formerly"],
        &["foreseeable"],
        &["foreseeable"],
        &["foreshadowing"],
        &["forensic"],
        &["foreseeable"],
        &["foreword", "forward"],
    ],
    range: 2..=10,
};

static WORD_FORC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FORC_CHILDREN),
    value: None,
};

pub static WORD_FORC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ably"),
        dictgen::InsensitiveStr::Ascii("ast"),
        dictgen::InsensitiveStr::Ascii("asted"),
        dictgen::InsensitiveStr::Ascii("aster"),
        dictgen::InsensitiveStr::Ascii("asters"),
        dictgen::InsensitiveStr::Ascii("asting"),
        dictgen::InsensitiveStr::Ascii("asts"),
        dictgen::InsensitiveStr::Ascii("eably"),
        dictgen::InsensitiveStr::Ascii("efullly"),
        dictgen::InsensitiveStr::Ascii("efuly"),
        dictgen::InsensitiveStr::Ascii("ibley"),
        dictgen::InsensitiveStr::Ascii("iblly"),
        dictgen::InsensitiveStr::Ascii("ifully"),
        dictgen::InsensitiveStr::Ascii("ot"),
    ],
    values: &[
        &["forcibly"],
        &["forecast"],
        &["forecasted"],
        &["forecaster"],
        &["forecasters"],
        &["forecasting"],
        &["forecasts"],
        &["forcibly"],
        &["forcefully"],
        &["forcefully"],
        &["forcibly"],
        &["forcibly"],
        &["forcefully"],
        &["forgot"],
    ],
    range: 2..=7,
};

static WORD_FORB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FORB_CHILDREN),
    value: None,
};

pub static WORD_FORB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ad"),
        dictgen::InsensitiveStr::Ascii("atum"),
        dictgen::InsensitiveStr::Ascii("biden"),
        dictgen::InsensitiveStr::Ascii("iden"),
        dictgen::InsensitiveStr::Ascii("it"),
        dictgen::InsensitiveStr::Ascii("iten"),
        dictgen::InsensitiveStr::Ascii("itten"),
    ],
    values: &[
        &["forbade"],
        &["verbatim"],
        &["forbidden"],
        &["forbidden"],
        &["forbid"],
        &["forbidden"],
        &["forbidden"],
    ],
    range: 2..=5,
};

static WORD_FORA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FORA_CHILDREN),
    value: None,
};

pub static WORD_FORA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("matting"),
        dictgen::InsensitiveStr::Ascii("mt"),
        dictgen::InsensitiveStr::Ascii("sken"),
        dictgen::InsensitiveStr::Ascii("t"),
    ],
    values: &[&["formatting"], &["format"], &["forsaken"], &["format"]],
    range: 1..=7,
};

static WORD_FOP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FOP_CHILDREN),
    value: None,
};

pub static WORD_FOP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("py"),
        dictgen::InsensitiveStr::Ascii("pys"),
    ],
    values: &[&["floppy"], &["floppies"]],
    range: 2..=3,
};

static WORD_FOO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FOO_CHILDREN),
    value: None,
};

pub static WORD_FOO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ntnotes"),
        dictgen::InsensitiveStr::Ascii("otball"),
        dictgen::InsensitiveStr::Ascii("r"),
        dictgen::InsensitiveStr::Ascii("rter"),
        dictgen::InsensitiveStr::Ascii("tnoes"),
        dictgen::InsensitiveStr::Ascii("tprinst"),
        dictgen::InsensitiveStr::Ascii("und"),
    ],
    values: &[
        &["footnotes"],
        &["football"],
        &["foot", "for"],
        &["footer"],
        &["footnotes"],
        &["footprints"],
        &["found"],
    ],
    range: 1..=7,
};

static WORD_FON_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FON_CHILDREN),
    value: None,
};

pub static WORD_FON_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ction"),
        dictgen::InsensitiveStr::Ascii("ctional"),
        dictgen::InsensitiveStr::Ascii("ctionalities"),
        dictgen::InsensitiveStr::Ascii("ctionality"),
        dictgen::InsensitiveStr::Ascii("ctioning"),
        dictgen::InsensitiveStr::Ascii("ctionnalies"),
        dictgen::InsensitiveStr::Ascii("ctionnalities"),
        dictgen::InsensitiveStr::Ascii("ctionnality"),
        dictgen::InsensitiveStr::Ascii("ctionnaly"),
        dictgen::InsensitiveStr::Ascii("ctions"),
        dictgen::InsensitiveStr::Ascii("damentalist"),
        dictgen::InsensitiveStr::Ascii("damentalists"),
        dictgen::InsensitiveStr::Ascii("etic"),
        dictgen::InsensitiveStr::Ascii("tain"),
        dictgen::InsensitiveStr::Ascii("tains"),
        dictgen::InsensitiveStr::Ascii("tier"),
        dictgen::InsensitiveStr::Ascii("tisizing"),
        dictgen::InsensitiveStr::Ascii("tonfig"),
        dictgen::InsensitiveStr::Ascii("trier"),
        dictgen::InsensitiveStr::Ascii("ud"),
    ],
    values: &[
        &["function"],
        &["functional"],
        &["functionalities"],
        &["functionality"],
        &["functioning"],
        &["functionalities"],
        &["functionalities"],
        &["functionality"],
        &["functionally", "functionality"],
        &["functions"],
        &["fundamentalist"],
        &["fundamentalists"],
        &["phonetic"],
        &["fountain", "contain"],
        &["fountains", "contains"],
        &["frontier"],
        &["fontifying"],
        &["fontconfig"],
        &["frontier"],
        &["found"],
    ],
    range: 2..=13,
};

static WORD_FOM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FOM_CHILDREN),
    value: Some(&["form", "from"]),
};

pub static WORD_FOM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aing"),
        dictgen::InsensitiveStr::Ascii("at"),
        dictgen::InsensitiveStr::Ascii("ated"),
        dictgen::InsensitiveStr::Ascii("ater"),
        dictgen::InsensitiveStr::Ascii("ates"),
        dictgen::InsensitiveStr::Ascii("ating"),
        dictgen::InsensitiveStr::Ascii("ats"),
        dictgen::InsensitiveStr::Ascii("atted"),
        dictgen::InsensitiveStr::Ascii("atter"),
        dictgen::InsensitiveStr::Ascii("atting"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("r"),
        dictgen::InsensitiveStr::Ascii("rat"),
        dictgen::InsensitiveStr::Ascii("rated"),
        dictgen::InsensitiveStr::Ascii("rater"),
        dictgen::InsensitiveStr::Ascii("rating"),
        dictgen::InsensitiveStr::Ascii("rats"),
        dictgen::InsensitiveStr::Ascii("ratted"),
        dictgen::InsensitiveStr::Ascii("ratter"),
        dictgen::InsensitiveStr::Ascii("ratting"),
        dictgen::InsensitiveStr::Ascii("ula"),
        dictgen::InsensitiveStr::Ascii("ulas"),
    ],
    values: &[
        &["foaming"],
        &["format"],
        &["formatted"],
        &["formatter"],
        &["formats"],
        &["formatting"],
        &["formats"],
        &["formatted"],
        &["formatter"],
        &["formatting"],
        &["formed"],
        &["from", "form"],
        &["format"],
        &["formatted"],
        &["formatter"],
        &["formatting"],
        &["formats"],
        &["formatted"],
        &["formatter"],
        &["formatting"],
        &["formula"],
        &["formula"],
    ],
    range: 1..=7,
};

static WORD_FOL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_FOL_CHILDREN),
    value: None,
};

static WORD_FOL_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    None,
    Some(&WORD_FOLD_NODE),
    Some(&WORD_FOLE_NODE),
    Some(&WORD_FOLF_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_FOLL_NODE),
    None,
    None,
    Some(&WORD_FOLO_NODE),
    None,
    None,
    None,
    Some(&WORD_FOLS_NODE),
    None,
    None,
    None,
    Some(&WORD_FOLW_NODE),
    Some(&WORD_FOLX_NODE),
    None,
    None,
];

static WORD_FOLX_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FOLX_CHILDREN),
    value: Some(&["folks"]),
};

pub static WORD_FOLX_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[],
    values: &[],
    range: 0..=0,
};

static WORD_FOLW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FOLW_CHILDREN),
    value: None,
};

pub static WORD_FOLW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("o"),
        dictgen::InsensitiveStr::Ascii("oed"),
        dictgen::InsensitiveStr::Ascii("oer"),
        dictgen::InsensitiveStr::Ascii("oers"),
        dictgen::InsensitiveStr::Ascii("oin"),
        dictgen::InsensitiveStr::Ascii("oind"),
        dictgen::InsensitiveStr::Ascii("oing"),
        dictgen::InsensitiveStr::Ascii("oinwg"),
        dictgen::InsensitiveStr::Ascii("oiong"),
        dictgen::InsensitiveStr::Ascii("oiwng"),
        dictgen::InsensitiveStr::Ascii("oong"),
        dictgen::InsensitiveStr::Ascii("os"),
    ],
    values: &[
        &["follow"],
        &["followed"],
        &["follower"],
        &["followers"],
        &["following"],
        &["following"],
        &["following"],
        &["following"],
        &["following"],
        &["following"],
        &["following"],
        &["follows"],
    ],
    range: 1..=5,
};

static WORD_FOLS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FOLS_CHILDREN),
    value: None,
};

pub static WORD_FOLS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("e")],
    values: &[&["false"]],
    range: 1..=1,
};

static WORD_FOLO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FOLO_CHILDREN),
    value: None,
};

pub static WORD_FOLO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ow"),
        dictgen::InsensitiveStr::Ascii("owed"),
        dictgen::InsensitiveStr::Ascii("ower"),
        dictgen::InsensitiveStr::Ascii("owers"),
        dictgen::InsensitiveStr::Ascii("owin"),
        dictgen::InsensitiveStr::Ascii("owind"),
        dictgen::InsensitiveStr::Ascii("owing"),
        dictgen::InsensitiveStr::Ascii("owinwg"),
        dictgen::InsensitiveStr::Ascii("owiong"),
        dictgen::InsensitiveStr::Ascii("owiwng"),
        dictgen::InsensitiveStr::Ascii("owong"),
        dictgen::InsensitiveStr::Ascii("ows"),
        dictgen::InsensitiveStr::Ascii("w"),
        dictgen::InsensitiveStr::Ascii("wed"),
        dictgen::InsensitiveStr::Ascii("wer"),
        dictgen::InsensitiveStr::Ascii("wers"),
        dictgen::InsensitiveStr::Ascii("win"),
        dictgen::InsensitiveStr::Ascii("wind"),
        dictgen::InsensitiveStr::Ascii("wing"),
        dictgen::InsensitiveStr::Ascii("winwg"),
        dictgen::InsensitiveStr::Ascii("wiong"),
        dictgen::InsensitiveStr::Ascii("wiwng"),
        dictgen::InsensitiveStr::Ascii("wong"),
        dictgen::InsensitiveStr::Ascii("ws"),
        dictgen::InsensitiveStr::Ascii("ww"),
        dictgen::InsensitiveStr::Ascii("wwed"),
        dictgen::InsensitiveStr::Ascii("wwer"),
        dictgen::InsensitiveStr::Ascii("wwers"),
        dictgen::InsensitiveStr::Ascii("wwin"),
        dictgen::InsensitiveStr::Ascii("wwind"),
        dictgen::InsensitiveStr::Ascii("wwing"),
        dictgen::InsensitiveStr::Ascii("wwinwg"),
        dictgen::InsensitiveStr::Ascii("wwiong"),
        dictgen::InsensitiveStr::Ascii("wwiwng"),
        dictgen::InsensitiveStr::Ascii("wwong"),
        dictgen::InsensitiveStr::Ascii("wws"),
    ],
    values: &[
        &["follow"],
        &["followed"],
        &["follower"],
        &["followers"],
        &["following"],
        &["following"],
        &["following"],
        &["following"],
        &["following"],
        &["following"],
        &["following"],
        &["follows"],
        &["follow"],
        &["followed"],
        &["follower"],
        &["followers"],
        &["following"],
        &["following"],
        &["following"],
        &["following"],
        &["following"],
        &["following"],
        &["following"],
        &["follows"],
        &["follow"],
        &["followed"],
        &["follower"],
        &["followers"],
        &["following"],
        &["following"],
        &["following"],
        &["following"],
        &["following"],
        &["following"],
        &["following"],
        &["follows"],
    ],
    range: 1..=6,
};

static WORD_FOLL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_FOLL_CHILDREN),
    value: None,
};

static WORD_FOLL_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    None,
    Some(&WORD_FOLLD_NODE),
    Some(&WORD_FOLLE_NODE),
    Some(&WORD_FOLLF_NODE),
    None,
    None,
    Some(&WORD_FOLLI_NODE),
    None,
    None,
    Some(&WORD_FOLLL_NODE),
    None,
    None,
    Some(&WORD_FOLLO_NODE),
    None,
    None,
    None,
    Some(&WORD_FOLLS_NODE),
    None,
    None,
    None,
    Some(&WORD_FOLLW_NODE),
    None,
    None,
    None,
];

static WORD_FOLLW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FOLLW_CHILDREN),
    value: Some(&["follow"]),
};

pub static WORD_FOLLW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("er"),
        dictgen::InsensitiveStr::Ascii("ers"),
        dictgen::InsensitiveStr::Ascii("in"),
        dictgen::InsensitiveStr::Ascii("ind"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("inwg"),
        dictgen::InsensitiveStr::Ascii("iong"),
        dictgen::InsensitiveStr::Ascii("iwng"),
        dictgen::InsensitiveStr::Ascii("o"),
        dictgen::InsensitiveStr::Ascii("oe"),
        dictgen::InsensitiveStr::Ascii("oed"),
        dictgen::InsensitiveStr::Ascii("oeed"),
        dictgen::InsensitiveStr::Ascii("oeer"),
        dictgen::InsensitiveStr::Ascii("oeers"),
        dictgen::InsensitiveStr::Ascii("oein"),
        dictgen::InsensitiveStr::Ascii("oeind"),
        dictgen::InsensitiveStr::Ascii("oeing"),
        dictgen::InsensitiveStr::Ascii("oeinwg"),
        dictgen::InsensitiveStr::Ascii("oeiong"),
        dictgen::InsensitiveStr::Ascii("oeiwng"),
        dictgen::InsensitiveStr::Ascii("oeong"),
        dictgen::InsensitiveStr::Ascii("oer"),
        dictgen::InsensitiveStr::Ascii("oers"),
        dictgen::InsensitiveStr::Ascii("oes"),
        dictgen::InsensitiveStr::Ascii("oin"),
        dictgen::InsensitiveStr::Ascii("oind"),
        dictgen::InsensitiveStr::Ascii("oing"),
        dictgen::InsensitiveStr::Ascii("oinwg"),
        dictgen::InsensitiveStr::Ascii("oiong"),
        dictgen::InsensitiveStr::Ascii("oiwng"),
        dictgen::InsensitiveStr::Ascii("ong"),
        dictgen::InsensitiveStr::Ascii("oong"),
        dictgen::InsensitiveStr::Ascii("os"),
        dictgen::InsensitiveStr::Ascii("ow"),
        dictgen::InsensitiveStr::Ascii("owed"),
        dictgen::InsensitiveStr::Ascii("ower"),
        dictgen::InsensitiveStr::Ascii("owers"),
        dictgen::InsensitiveStr::Ascii("owin"),
        dictgen::InsensitiveStr::Ascii("owind"),
        dictgen::InsensitiveStr::Ascii("owing"),
        dictgen::InsensitiveStr::Ascii("owinwg"),
        dictgen::InsensitiveStr::Ascii("owiong"),
        dictgen::InsensitiveStr::Ascii("owiwng"),
        dictgen::InsensitiveStr::Ascii("owong"),
        dictgen::InsensitiveStr::Ascii("ows"),
        dictgen::InsensitiveStr::Ascii("s"),
        dictgen::InsensitiveStr::Ascii("w"),
        dictgen::InsensitiveStr::Ascii("wed"),
        dictgen::InsensitiveStr::Ascii("wer"),
        dictgen::InsensitiveStr::Ascii("wers"),
        dictgen::InsensitiveStr::Ascii("win"),
        dictgen::InsensitiveStr::Ascii("wind"),
        dictgen::InsensitiveStr::Ascii("wing"),
        dictgen::InsensitiveStr::Ascii("winwg"),
        dictgen::InsensitiveStr::Ascii("wiong"),
        dictgen::InsensitiveStr::Ascii("wiwng"),
        dictgen::InsensitiveStr::Ascii("wong"),
        dictgen::InsensitiveStr::Ascii("ws"),
    ],
    values: &[
        &["followed"],
        &["follower"],
        &["followers"],
        &["following"],
        &["following"],
        &["following"],
        &["following"],
        &["following"],
        &["following"],
        &["follow"],
        &["follow"],
        &["followed"],
        &["followed"],
        &["follower"],
        &["followers"],
        &["following"],
        &["following"],
        &["following"],
        &["following"],
        &["following"],
        &["following"],
        &["following"],
        &["follower"],
        &["followers"],
        &["follows"],
        &["following"],
        &["following"],
        &["following"],
        &["following"],
        &["following"],
        &["following"],
        &["following"],
        &["following"],
        &["follows"],
        &["follow"],
        &["followed"],
        &["follower"],
        &["followers"],
        &["following"],
        &["following"],
        &["following"],
        &["following"],
        &["following"],
        &["following"],
        &["following"],
        &["follows"],
        &["follows"],
        &["follow"],
        &["followed"],
        &["follower"],
        &["followers"],
        &["following"],
        &["following"],
        &["following"],
        &["following"],
        &["following"],
        &["following"],
        &["following"],
        &["follows"],
    ],
    range: 1..=6,
};

static WORD_FOLLS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FOLLS_CHILDREN),
    value: Some(&["follows"]),
};

pub static WORD_FOLLS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[],
    values: &[],
    range: 0..=0,
};

static WORD_FOLLO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FOLLO_CHILDREN),
    value: None,
};

pub static WORD_FOLLO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("d"),
        dictgen::InsensitiveStr::Ascii("eing"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("iwng"),
        dictgen::InsensitiveStr::Ascii("lwing"),
        dictgen::InsensitiveStr::Ascii("ng"),
        dictgen::InsensitiveStr::Ascii("s"),
        dictgen::InsensitiveStr::Ascii("wd"),
        dictgen::InsensitiveStr::Ascii("wes"),
        dictgen::InsensitiveStr::Ascii("wig"),
        dictgen::InsensitiveStr::Ascii("wign"),
        dictgen::InsensitiveStr::Ascii("win"),
        dictgen::InsensitiveStr::Ascii("wind"),
        dictgen::InsensitiveStr::Ascii("wint"),
        dictgen::InsensitiveStr::Ascii("wng"),
        dictgen::InsensitiveStr::Ascii("wwing"),
        dictgen::InsensitiveStr::Ascii("wwings"),
    ],
    values: &[
        &["followed"],
        &["following"],
        &["following"],
        &["following"],
        &["following"],
        &["following"],
        &["follows"],
        &["followed", "follows", "follow"],
        &["follows"],
        &["following"],
        &["following"],
        &["following"],
        &["following"],
        &["following"],
        &["following"],
        &["following"],
        &["followings"],
    ],
    range: 1..=6,
};

static WORD_FOLLL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FOLLL_CHILDREN),
    value: None,
};

pub static WORD_FOLLL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ow"),
        dictgen::InsensitiveStr::Ascii("owed"),
        dictgen::InsensitiveStr::Ascii("ower"),
        dictgen::InsensitiveStr::Ascii("owers"),
        dictgen::InsensitiveStr::Ascii("owin"),
        dictgen::InsensitiveStr::Ascii("owind"),
        dictgen::InsensitiveStr::Ascii("owing"),
        dictgen::InsensitiveStr::Ascii("owinwg"),
        dictgen::InsensitiveStr::Ascii("owiong"),
        dictgen::InsensitiveStr::Ascii("owiwng"),
        dictgen::InsensitiveStr::Ascii("owong"),
        dictgen::InsensitiveStr::Ascii("ows"),
    ],
    values: &[
        &["follow"],
        &["followed"],
        &["follower"],
        &["followers"],
        &["following"],
        &["following"],
        &["following"],
        &["following"],
        &["following"],
        &["following"],
        &["following"],
        &["follows", "followings"],
    ],
    range: 2..=6,
};

static WORD_FOLLI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FOLLI_CHILDREN),
    value: None,
};

pub static WORD_FOLLI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("n"),
        dictgen::InsensitiveStr::Ascii("nd"),
        dictgen::InsensitiveStr::Ascii("ng"),
        dictgen::InsensitiveStr::Ascii("nwg"),
        dictgen::InsensitiveStr::Ascii("ong"),
        dictgen::InsensitiveStr::Ascii("w"),
        dictgen::InsensitiveStr::Ascii("wed"),
        dictgen::InsensitiveStr::Ascii("wer"),
        dictgen::InsensitiveStr::Ascii("wers"),
        dictgen::InsensitiveStr::Ascii("win"),
        dictgen::InsensitiveStr::Ascii("wind"),
        dictgen::InsensitiveStr::Ascii("wing"),
        dictgen::InsensitiveStr::Ascii("winwg"),
        dictgen::InsensitiveStr::Ascii("wiong"),
        dictgen::InsensitiveStr::Ascii("wiwng"),
        dictgen::InsensitiveStr::Ascii("wng"),
        dictgen::InsensitiveStr::Ascii("wong"),
        dictgen::InsensitiveStr::Ascii("ws"),
    ],
    values: &[
        &["following"],
        &["following"],
        &["following", "falling", "rolling"],
        &["following"],
        &["following"],
        &["follow"],
        &["followed"],
        &["follower"],
        &["followers"],
        &["following"],
        &["following"],
        &["following"],
        &["following"],
        &["following"],
        &["following"],
        &["following"],
        &["following"],
        &["follows"],
    ],
    range: 1..=5,
};

static WORD_FOLLF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FOLLF_CHILDREN),
    value: None,
};

pub static WORD_FOLLF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ow"),
        dictgen::InsensitiveStr::Ascii("owed"),
        dictgen::InsensitiveStr::Ascii("ower"),
        dictgen::InsensitiveStr::Ascii("owers"),
        dictgen::InsensitiveStr::Ascii("owin"),
        dictgen::InsensitiveStr::Ascii("owind"),
        dictgen::InsensitiveStr::Ascii("owing"),
        dictgen::InsensitiveStr::Ascii("owinwg"),
        dictgen::InsensitiveStr::Ascii("owiong"),
        dictgen::InsensitiveStr::Ascii("owiwng"),
        dictgen::InsensitiveStr::Ascii("owong"),
        dictgen::InsensitiveStr::Ascii("ows"),
    ],
    values: &[
        &["follow"],
        &["followed"],
        &["follower"],
        &["followers"],
        &["following"],
        &["following"],
        &["following"],
        &["following"],
        &["following"],
        &["following"],
        &["following"],
        &["follows"],
    ],
    range: 2..=6,
};

static WORD_FOLLE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FOLLE_CHILDREN),
    value: None,
};

pub static WORD_FOLLE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("d"),
        dictgen::InsensitiveStr::Ascii("r"),
        dictgen::InsensitiveStr::Ascii("rs"),
        dictgen::InsensitiveStr::Ascii("w"),
        dictgen::InsensitiveStr::Ascii("wed"),
        dictgen::InsensitiveStr::Ascii("wer"),
        dictgen::InsensitiveStr::Ascii("wers"),
        dictgen::InsensitiveStr::Ascii("win"),
        dictgen::InsensitiveStr::Ascii("wind"),
        dictgen::InsensitiveStr::Ascii("wing"),
        dictgen::InsensitiveStr::Ascii("winwg"),
        dictgen::InsensitiveStr::Ascii("wiong"),
        dictgen::InsensitiveStr::Ascii("wiwng"),
        dictgen::InsensitiveStr::Ascii("wong"),
        dictgen::InsensitiveStr::Ascii("ws"),
    ],
    values: &[
        &["followed"],
        &["follower"],
        &["followers"],
        &["follow"],
        &["followed"],
        &["follower"],
        &["followers"],
        &["following"],
        &["following"],
        &["following"],
        &["following"],
        &["following"],
        &["following"],
        &["following"],
        &["follows"],
    ],
    range: 1..=5,
};

static WORD_FOLLD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FOLLD_CHILDREN),
    value: None,
};

pub static WORD_FOLLD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("er")],
    values: &[&["folder"]],
    range: 2..=2,
};

static WORD_FOLF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FOLF_CHILDREN),
    value: None,
};

pub static WORD_FOLF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("er"),
        dictgen::InsensitiveStr::Ascii("ers"),
    ],
    values: &[&["folder"], &["folders"]],
    range: 2..=3,
};

static WORD_FOLE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FOLE_CHILDREN),
    value: None,
};

pub static WORD_FOLE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("r"),
        dictgen::InsensitiveStr::Ascii("rs"),
    ],
    values: &[&["folder"], &["folders"]],
    range: 1..=2,
};

static WORD_FOLD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FOLD_CHILDREN),
    value: None,
};

pub static WORD_FOLD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("e")],
    values: &[&["folder", "fold"]],
    range: 1..=1,
};

static WORD_FOI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FOI_CHILDREN),
    value: None,
};

pub static WORD_FOI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("nters")],
    values: &[&["pointers"]],
    range: 5..=5,
};

static WORD_FOG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FOG_CHILDREN),
    value: None,
};

pub static WORD_FOG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("et"),
        dictgen::InsensitiveStr::Ascii("ets"),
        dictgen::InsensitiveStr::Ascii("ot"),
        dictgen::InsensitiveStr::Ascii("otten"),
    ],
    values: &[&["forget"], &["forgets"], &["forgot"], &["forgotten"]],
    range: 2..=5,
};

static WORD_FOF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FOF_CHILDREN),
    value: Some(&["for"]),
};

pub static WORD_FOF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[],
    values: &[],
    range: 0..=0,
};

static WORD_FOD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FOD_CHILDREN),
    value: None,
};

pub static WORD_FOD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("er"),
        dictgen::InsensitiveStr::Ascii("ers"),
        dictgen::InsensitiveStr::Ascii("ing"),
    ],
    values: &[
        &["boded", "coded", "faded", "folded", "forded"],
        &["coder", "folder"],
        &["coders", "folders"],
        &["boding", "coding", "fading", "folding", "fording"],
    ],
    range: 2..=3,
};

static WORD_FOC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FOC_CHILDREN),
    value: None,
};

pub static WORD_FOC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("u"),
        dictgen::InsensitiveStr::Ascii("ued"),
        dictgen::InsensitiveStr::Ascii("ument"),
        dictgen::InsensitiveStr::Ascii("use"),
        dictgen::InsensitiveStr::Ascii("usf"),
        dictgen::InsensitiveStr::Ascii("uss"),
        dictgen::InsensitiveStr::Ascii("usses"),
    ],
    values: &[
        &["focus"],
        &["focused"],
        &["document"],
        &["focus"],
        &["focus"],
        &["focus"],
        &["focuses"],
    ],
    range: 1..=5,
};

static WORD_FN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FN_CHILDREN),
    value: None,
};

pub static WORD_FN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aatic"),
        dictgen::InsensitiveStr::Ascii("ction"),
        dictgen::InsensitiveStr::Ascii("ctions"),
        dictgen::InsensitiveStr::Ascii("uction"),
    ],
    values: &[&["fanatic"], &["function"], &["functions"], &["function"]],
    range: 5..=6,
};

static WORD_FL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_FL_CHILDREN),
    value: None,
};

static WORD_FL_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_FLA_NODE),
    None,
    Some(&WORD_FLC_NODE),
    None,
    Some(&WORD_FLE_NODE),
    None,
    None,
    None,
    Some(&WORD_FLI_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_FLO_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_FLT_NODE),
    Some(&WORD_FLU_NODE),
    None,
    None,
    None,
    Some(&WORD_FLY_NODE),
    None,
];

static WORD_FLY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FLY_CHILDREN),
    value: None,
};

pub static WORD_FLY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("es")],
    values: &[&["flies", "flyers"]],
    range: 2..=2,
};

static WORD_FLU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FLU_CHILDREN),
    value: None,
};

pub static WORD_FLU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ctaute"),
        dictgen::InsensitiveStr::Ascii("ctiations"),
        dictgen::InsensitiveStr::Ascii("ctuand"),
        dictgen::InsensitiveStr::Ascii("ctuatie"),
        dictgen::InsensitiveStr::Ascii("ctuaties"),
        dictgen::InsensitiveStr::Ascii("ctuatin"),
        dictgen::InsensitiveStr::Ascii("ctuative"),
        dictgen::InsensitiveStr::Ascii("cutate"),
        dictgen::InsensitiveStr::Ascii("cutations"),
        dictgen::InsensitiveStr::Ascii("d"),
        dictgen::InsensitiveStr::Ascii("orish"),
        dictgen::InsensitiveStr::Ascii("oroscent"),
        dictgen::InsensitiveStr::Ascii("roescent"),
        dictgen::InsensitiveStr::Ascii("roide"),
        dictgen::InsensitiveStr::Ascii("shs"),
        dictgen::InsensitiveStr::Ascii("sing"),
        dictgen::InsensitiveStr::Ascii("tterhsy"),
        dictgen::InsensitiveStr::Ascii("ttersky"),
        dictgen::InsensitiveStr::Ascii("tterspy"),
        dictgen::InsensitiveStr::Ascii("ttersy"),
        dictgen::InsensitiveStr::Ascii("tteryshy"),
        dictgen::InsensitiveStr::Ascii("xtuations"),
    ],
    values: &[
        &["fluctuate"],
        &["fluctuations"],
        &["fluctuant"],
        &["fluctuate"],
        &["fluctuate"],
        &["fluctuations"],
        &["fluctuate"],
        &["fluctuate"],
        &["fluctuations"],
        &["flood"],
        &["flourish"],
        &["fluorescent"],
        &["fluorescent"],
        &["fluoride"],
        &["flushes"],
        &["flushing"],
        &["fluttershy"],
        &["fluttershy"],
        &["fluttershy"],
        &["fluttershy"],
        &["fluttershy"],
        &["fluctuations"],
    ],
    range: 1..=9,
};

static WORD_FLT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FLT_CHILDREN),
    value: None,
};

pub static WORD_FLT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("er")],
    values: &[&["filter"]],
    range: 2..=2,
};

static WORD_FLO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FLO_CHILDREN),
    value: None,
};

pub static WORD_FLO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ading"),
        dictgen::InsensitiveStr::Ascii("r"),
        dictgen::InsensitiveStr::Ascii("rdia"),
        dictgen::InsensitiveStr::Ascii("recen"),
        dictgen::InsensitiveStr::Ascii("rene"),
        dictgen::InsensitiveStr::Ascii("resent"),
        dictgen::InsensitiveStr::Ascii("ride"),
        dictgen::InsensitiveStr::Ascii("ridia"),
        dictgen::InsensitiveStr::Ascii("ruide"),
        dictgen::InsensitiveStr::Ascii("ruish"),
        dictgen::InsensitiveStr::Ascii("ting"),
        dictgen::InsensitiveStr::Ascii("urescent"),
        dictgen::InsensitiveStr::Ascii("uride"),
        dictgen::InsensitiveStr::Ascii("urine"),
        dictgen::InsensitiveStr::Ascii("urishment"),
        dictgen::InsensitiveStr::Ascii("ursih"),
    ],
    values: &[
        &["floating", "flooding"],
        &["floor", "flow"],
        &["florida"],
        &["florence"],
        &["florence"],
        &["fluorescent", "florescent"],
        &["fluoride"],
        &["florida"],
        &["fluoride"],
        &["flourish"],
        &["floating"],
        &["fluorescent", "florescent"],
        &["fluoride"],
        &["fluorine"],
        &["flourishing"],
        &["flourish"],
    ],
    range: 1..=9,
};

static WORD_FLI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FLI_CHILDREN),
    value: None,
};

pub static WORD_FLI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("mmakers"),
        dictgen::InsensitiveStr::Ascii("ppade"),
        dictgen::InsensitiveStr::Ascii("ter"),
        dictgen::InsensitiveStr::Ascii("tered"),
        dictgen::InsensitiveStr::Ascii("tering"),
        dictgen::InsensitiveStr::Ascii("ters"),
    ],
    values: &[
        &["file"],
        &["filmmakers"],
        &["flipped"],
        &["filter"],
        &["filtered"],
        &["filtering"],
        &["filters"],
    ],
    range: 1..=7,
};

static WORD_FLE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FLE_CHILDREN),
    value: Some(&["file"]),
};

pub static WORD_FLE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("chter"),
        dictgen::InsensitiveStr::Ascii("cther"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("m"),
        dictgen::InsensitiveStr::Ascii("mmish"),
        dictgen::InsensitiveStr::Ascii("thcer"),
        dictgen::InsensitiveStr::Ascii("want"),
        dictgen::InsensitiveStr::Ascii("xability"),
        dictgen::InsensitiveStr::Ascii("xable"),
        dictgen::InsensitiveStr::Ascii("xbile"),
        dictgen::InsensitiveStr::Ascii("xibel"),
        dictgen::InsensitiveStr::Ascii("xibele"),
        dictgen::InsensitiveStr::Ascii("xibiliy"),
        dictgen::InsensitiveStr::Ascii("xibillity"),
        dictgen::InsensitiveStr::Ascii("xibiltiy"),
        dictgen::InsensitiveStr::Ascii("xibilty"),
        dictgen::InsensitiveStr::Ascii("xibily"),
        dictgen::InsensitiveStr::Ascii("xiblity"),
        dictgen::InsensitiveStr::Ascii("xt"),
    ],
    values: &[
        &["fletcher"],
        &["fletcher"],
        &["fled", "freed"],
        &["phlegm"],
        &["flemish"],
        &["fletcher"],
        &["fluent"],
        &["flexibility"],
        &["flexible"],
        &["flexible"],
        &["flexible"],
        &["flexible"],
        &["flexibility"],
        &["flexibility"],
        &["flexibility"],
        &["flexibility"],
        &["flexibility", "flexibly"],
        &["flexibility"],
        &["flex"],
    ],
    range: 1..=9,
};

static WORD_FLC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FLC_CHILDREN),
    value: None,
};

pub static WORD_FLC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("iker")],
    values: &[&["flicker"]],
    range: 4..=4,
};

static WORD_FLA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FLA_CHILDREN),
    value: None,
};

pub static WORD_FLA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cons"),
        dictgen::InsensitiveStr::Ascii("cor"),
        dictgen::InsensitiveStr::Ascii("cored"),
        dictgen::InsensitiveStr::Ascii("coring"),
        dictgen::InsensitiveStr::Ascii("corings"),
        dictgen::InsensitiveStr::Ascii("cors"),
        dictgen::InsensitiveStr::Ascii("cour"),
        dictgen::InsensitiveStr::Ascii("coured"),
        dictgen::InsensitiveStr::Ascii("couring"),
        dictgen::InsensitiveStr::Ascii("courings"),
        dictgen::InsensitiveStr::Ascii("cours"),
        dictgen::InsensitiveStr::Ascii("ge"),
        dictgen::InsensitiveStr::Ascii("ged"),
        dictgen::InsensitiveStr::Ascii("ges"),
        dictgen::InsensitiveStr::Ascii("gg"),
        dictgen::InsensitiveStr::Ascii("ghsip"),
        dictgen::InsensitiveStr::Ascii("hs"),
        dictgen::InsensitiveStr::Ascii("hsed"),
        dictgen::InsensitiveStr::Ascii("hses"),
        dictgen::InsensitiveStr::Ascii("hsing"),
        dictgen::InsensitiveStr::Ascii("kyness"),
        dictgen::InsensitiveStr::Ascii("mable"),
        dictgen::InsensitiveStr::Ascii("methorwer"),
        dictgen::InsensitiveStr::Ascii("metrhower"),
        dictgen::InsensitiveStr::Ascii("nethrower"),
        dictgen::InsensitiveStr::Ascii("ot"),
        dictgen::InsensitiveStr::Ascii("oting"),
        dictgen::InsensitiveStr::Ascii("ried"),
        dictgen::InsensitiveStr::Ascii("se"),
        dictgen::InsensitiveStr::Ascii("sely"),
        dictgen::InsensitiveStr::Ascii("sghip"),
        dictgen::InsensitiveStr::Ascii("shflame"),
        dictgen::InsensitiveStr::Ascii("shig"),
        dictgen::InsensitiveStr::Ascii("shligt"),
        dictgen::InsensitiveStr::Ascii("shligth"),
        dictgen::InsensitiveStr::Ascii("sing"),
        dictgen::InsensitiveStr::Ascii("skbacks"),
        dictgen::InsensitiveStr::Ascii("ss"),
        dictgen::InsensitiveStr::Ascii("te"),
        dictgen::InsensitiveStr::Ascii("tened"),
        dictgen::InsensitiveStr::Ascii("ttend"),
        dictgen::InsensitiveStr::Ascii("ttenning"),
        dictgen::InsensitiveStr::Ascii("tterd"),
        dictgen::InsensitiveStr::Ascii("tterende"),
        dictgen::InsensitiveStr::Ascii("tteur"),
        dictgen::InsensitiveStr::Ascii("ttire"),
        dictgen::InsensitiveStr::Ascii("vorade"),
        dictgen::InsensitiveStr::Ascii("vord"),
        dictgen::InsensitiveStr::Ascii("vores"),
        dictgen::InsensitiveStr::Ascii("voures"),
        dictgen::InsensitiveStr::Ascii("vourus"),
        dictgen::InsensitiveStr::Ascii("vous"),
        dictgen::InsensitiveStr::Ascii("wess"),
        dictgen::InsensitiveStr::Ascii("wleslly"),
        dictgen::InsensitiveStr::Ascii("wlessely"),
        dictgen::InsensitiveStr::Ascii("wlessley"),
        dictgen::InsensitiveStr::Ascii("wlessy"),
    ],
    values: &[
        &["falcons"],
        &["flavor"],
        &["flavored"],
        &["flavoring"],
        &["flavorings"],
        &["flavors"],
        &["flavour"],
        &["flavoured"],
        &["flavouring"],
        &["flavourings"],
        &["flavours"],
        &["flags", "flag"],
        &["flagged"],
        &["flags"],
        &["flag"],
        &["flagship"],
        &["flash", "flags"],
        &["flashed"],
        &["flashes"],
        &["flashing"],
        &["flakiness"],
        &["flammable"],
        &["flamethrower"],
        &["flamethrower"],
        &["flamethrower"],
        &["float"],
        &["floating"],
        &["flaired"],
        &["false", "flake", "flame", "flare", "flash", "flask"],
        &["falsely"],
        &["flagship"],
        &["flashframe"],
        &["flashing"],
        &["flashlight"],
        &["flashlight"],
        &["flashing"],
        &["flashbacks"],
        &["class", "glass", "flask", "flash"],
        &["flat"],
        &["flattened"],
        &["flattened"],
        &["flattening"],
        &["flattered"],
        &["flattered"],
        &["flatter"],
        &["flatter"],
        &["flavored"],
        &["flavored"],
        &["flavors"],
        &["flavours"],
        &["flavours"],
        &["flavours"],
        &["flawless"],
        &["flawlessly"],
        &["flawlessly"],
        &["flawlessly"],
        &["flawlessly"],
    ],
    range: 2..=9,
};

static WORD_FI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_FI_CHILDREN),
    value: None,
};

static WORD_FI_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_FIA_NODE),
    Some(&WORD_FIB_NODE),
    Some(&WORD_FIC_NODE),
    Some(&WORD_FID_NODE),
    Some(&WORD_FIE_NODE),
    Some(&WORD_FIF_NODE),
    Some(&WORD_FIG_NODE),
    None,
    None,
    None,
    Some(&WORD_FIK_NODE),
    Some(&WORD_FIL_NODE),
    Some(&WORD_FIM_NODE),
    Some(&WORD_FIN_NODE),
    Some(&WORD_FIO_NODE),
    None,
    None,
    Some(&WORD_FIR_NODE),
    Some(&WORD_FIS_NODE),
    Some(&WORD_FIT_NODE),
    None,
    Some(&WORD_FIV_NODE),
    None,
    Some(&WORD_FIX_NODE),
    None,
    Some(&WORD_FIZ_NODE),
];

static WORD_FIZ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FIZ_CHILDREN),
    value: None,
};

pub static WORD_FIZ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("eek")],
    values: &[&["physique"]],
    range: 3..=3,
};

static WORD_FIX_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FIX_CHILDREN),
    value: None,
};

pub static WORD_FIX_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("el"),
        dictgen::InsensitiveStr::Ascii("els"),
        dictgen::InsensitiveStr::Ascii("eme"),
        dictgen::InsensitiveStr::Ascii("utre"),
        dictgen::InsensitiveStr::Ascii("wd"),
    ],
    values: &[
        &["fixed", "fixes", "fix", "fixme", "fixer"],
        &["pixel"],
        &["pixels"],
        &["fixme"],
        &["fixture"],
        &["fixed"],
    ],
    range: 1..=4,
};

static WORD_FIV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FIV_CHILDREN),
    value: None,
};

pub static WORD_FIV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ety")],
    values: &[&["fifty"]],
    range: 3..=3,
};

static WORD_FIT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FIT_CHILDREN),
    value: None,
};

pub static WORD_FIT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("er"),
        dictgen::InsensitiveStr::Ascii("ering"),
        dictgen::InsensitiveStr::Ascii("ers"),
        dictgen::InsensitiveStr::Ascii("h"),
        dictgen::InsensitiveStr::Ascii("ler"),
        dictgen::InsensitiveStr::Ascii("lered"),
        dictgen::InsensitiveStr::Ascii("lering"),
        dictgen::InsensitiveStr::Ascii("lers"),
    ],
    values: &[
        &["filter", "fighter", "fitter", "fiver"],
        &["filtering"],
        &["filters", "fighters", "fitters", "fivers"],
        &["fifth", "filth"],
        &["filter"],
        &["filtered"],
        &["filtering"],
        &["filters"],
    ],
    range: 1..=6,
};

static WORD_FIS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FIS_CHILDREN),
    value: None,
};

pub static WORD_FIS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ical"),
        dictgen::InsensitiveStr::Ascii("ionable"),
        dictgen::InsensitiveStr::Ascii("isist"),
        dictgen::InsensitiveStr::Ascii("ist"),
        dictgen::InsensitiveStr::Ascii("rt"),
    ],
    values: &[
        &["physical", "fiscal"],
        &["fissionable"],
        &["physicist"],
        &["physicist"],
        &["first"],
    ],
    range: 2..=7,
};

static WORD_FIR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FIR_CHILDREN),
    value: None,
};

pub static WORD_FIR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("day"),
        dictgen::InsensitiveStr::Ascii("dt"),
        dictgen::InsensitiveStr::Ascii("eballls"),
        dictgen::InsensitiveStr::Ascii("ebals"),
        dictgen::InsensitiveStr::Ascii("efigher"),
        dictgen::InsensitiveStr::Ascii("efighers"),
        dictgen::InsensitiveStr::Ascii("efigter"),
        dictgen::InsensitiveStr::Ascii("efigther"),
        dictgen::InsensitiveStr::Ascii("efigthers"),
        dictgen::InsensitiveStr::Ascii("endlies"),
        dictgen::InsensitiveStr::Ascii("endly"),
        dictgen::InsensitiveStr::Ascii("ends"),
        dictgen::InsensitiveStr::Ascii("endzoned"),
        dictgen::InsensitiveStr::Ascii("est"),
        dictgen::InsensitiveStr::Ascii("ey"),
        dictgen::InsensitiveStr::Ascii("ggin"),
        dictgen::InsensitiveStr::Ascii("ghtened"),
        dictgen::InsensitiveStr::Ascii("ghtening"),
        dictgen::InsensitiveStr::Ascii("mare"),
        dictgen::InsensitiveStr::Ascii("maware"),
        dictgen::InsensitiveStr::Ascii("mawre"),
        dictgen::InsensitiveStr::Ascii("meare"),
        dictgen::InsensitiveStr::Ascii("meware"),
        dictgen::InsensitiveStr::Ascii("mnware"),
        dictgen::InsensitiveStr::Ascii("mwart"),
        dictgen::InsensitiveStr::Ascii("mwear"),
        dictgen::InsensitiveStr::Ascii("mwqre"),
        dictgen::InsensitiveStr::Ascii("mwre"),
        dictgen::InsensitiveStr::Ascii("mwware"),
        dictgen::InsensitiveStr::Ascii("rst"),
        dictgen::InsensitiveStr::Ascii("sbee"),
        dictgen::InsensitiveStr::Ascii("slty"),
        dictgen::InsensitiveStr::Ascii("sr"),
        dictgen::InsensitiveStr::Ascii("srt"),
        dictgen::InsensitiveStr::Ascii("sth"),
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("ts"),
        dictgen::InsensitiveStr::Ascii("tsly"),
        dictgen::InsensitiveStr::Ascii("ware"),
        dictgen::InsensitiveStr::Ascii("wmare"),
    ],
    values: &[
        &["friday"],
        &["first", "third"],
        &["fireballs"],
        &["fireballs"],
        &["firefighter"],
        &["firefighters"],
        &["firefighter"],
        &["firefighters"],
        &["firefighters"],
        &["friendlies"],
        &["friendly"],
        &["friends"],
        &["friendzoned"],
        &["fires", "first"],
        &["fiery"],
        &["friggin"],
        &["frightened"],
        &["frightening"],
        &["firmware"],
        &["firmware"],
        &["firmware"],
        &["firmware"],
        &["firmware"],
        &["firmware"],
        &["firmware"],
        &["firmware"],
        &["firmware"],
        &["firmware"],
        &["firmware"],
        &["first"],
        &["frisbee"],
        &["firstly"],
        &["first"],
        &["first"],
        &["first"],
        &["first", "flirt"],
        &["flirts", "first"],
        &["firstly"],
        &["firmware"],
        &["firmware"],
    ],
    range: 1..=9,
};

static WORD_FIO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FIO_CHILDREN),
    value: None,
};

pub static WORD_FIO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("rget")],
    values: &[&["forget"]],
    range: 4..=4,
};

static WORD_FIN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_FIN_CHILDREN),
    value: None,
};

static WORD_FIN_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_FINA_NODE),
    None,
    Some(&WORD_FINC_NODE),
    Some(&WORD_FIND_NODE),
    Some(&WORD_FINE_NODE),
    None,
    Some(&WORD_FING_NODE),
    None,
    Some(&WORD_FINI_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_FINN_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_FINS_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_FINX_NODE),
    None,
    None,
];

static WORD_FINX_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FINX_CHILDREN),
    value: None,
};

pub static WORD_FINX_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("ing"),
    ],
    values: &[&["fixed"], &["fixing"]],
    range: 2..=3,
};

static WORD_FINS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FINS_CHILDREN),
    value: None,
};

pub static WORD_FINS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("h"),
        dictgen::InsensitiveStr::Ascii("hed"),
        dictgen::InsensitiveStr::Ascii("hes"),
        dictgen::InsensitiveStr::Ascii("hing"),
        dictgen::InsensitiveStr::Ascii("ih"),
        dictgen::InsensitiveStr::Ascii("ihed"),
        dictgen::InsensitiveStr::Ascii("ihes"),
        dictgen::InsensitiveStr::Ascii("ihing"),
        dictgen::InsensitiveStr::Ascii("ished"),
    ],
    values: &[
        &["finish", "finch"],
        &["finished"],
        &["finishes", "finches"],
        &["finishing"],
        &["finish"],
        &["finished"],
        &["finishes"],
        &["finishing"],
        &["finished"],
    ],
    range: 1..=5,
};

static WORD_FINN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FINN_CHILDREN),
    value: None,
};

pub static WORD_FINN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ess"),
        dictgen::InsensitiveStr::Ascii("isch"),
        dictgen::InsensitiveStr::Ascii("ished"),
        dictgen::InsensitiveStr::Ascii("sih"),
    ],
    values: &[&["finesse"], &["finnish"], &["finished"], &["finnish"]],
    range: 3..=5,
};

static WORD_FINI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FINI_CHILDREN),
    value: None,
};

pub static WORD_FINI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("alization"),
        dictgen::InsensitiveStr::Ascii("alize"),
        dictgen::InsensitiveStr::Ascii("alizing"),
        dictgen::InsensitiveStr::Ascii("lizes"),
        dictgen::InsensitiveStr::Ascii("nsh"),
        dictgen::InsensitiveStr::Ascii("nshed"),
        dictgen::InsensitiveStr::Ascii("sch"),
        dictgen::InsensitiveStr::Ascii("sched"),
        dictgen::InsensitiveStr::Ascii("sed"),
        dictgen::InsensitiveStr::Ascii("she"),
        dictgen::InsensitiveStr::Ascii("shied"),
        dictgen::InsensitiveStr::Ascii("shs"),
        dictgen::InsensitiveStr::Ascii("sse"),
        dictgen::InsensitiveStr::Ascii("tel"),
    ],
    values: &[
        &["finalization"],
        &["finalize"],
        &["finalizing"],
        &["finalizes"],
        &["finnish"],
        &["finished"],
        &["finish", "finnish"],
        &["finished"],
        &["finished"],
        &["finished", "finish"],
        &["finished"],
        &["finishes"],
        &["finishes"],
        &["finite"],
    ],
    range: 3..=9,
};

static WORD_FING_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FING_CHILDREN),
    value: None,
};

pub static WORD_FING_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("eprint"),
        dictgen::InsensitiveStr::Ascii("ernal"),
        dictgen::InsensitiveStr::Ascii("ernals"),
        dictgen::InsensitiveStr::Ascii("erpies"),
        dictgen::InsensitiveStr::Ascii("erpint"),
        dictgen::InsensitiveStr::Ascii("erpints"),
        dictgen::InsensitiveStr::Ascii("erpoint"),
        dictgen::InsensitiveStr::Ascii("erpoints"),
        dictgen::InsensitiveStr::Ascii("ersi"),
        dictgen::InsensitiveStr::Ascii("ertaps"),
        dictgen::InsensitiveStr::Ascii("ertits"),
        dictgen::InsensitiveStr::Ascii("ertops"),
        dictgen::InsensitiveStr::Ascii("ertrips"),
    ],
    values: &[
        &["finger", "fringe"],
        &["fingerprint"],
        &["fingernails"],
        &["fingernails"],
        &["fingertips"],
        &["fingerprint"],
        &["fingertips"],
        &["fingerprint"],
        &["fingerprints"],
        &["fingertips"],
        &["fingertips"],
        &["fingertips"],
        &["fingertips"],
        &["fingertips"],
    ],
    range: 1..=8,
};

static WORD_FINE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FINE_CHILDREN),
    value: None,
};

pub static WORD_FINE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("lly"),
        dictgen::InsensitiveStr::Ascii("ses"),
        dictgen::InsensitiveStr::Ascii("shes"),
        dictgen::InsensitiveStr::Ascii("ss"),
    ],
    values: &[&["finally"], &["finesse"], &["finesse"], &["finesse"]],
    range: 2..=4,
};

static WORD_FIND_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FIND_CHILDREN),
    value: None,
};

pub static WORD_FIND_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("n"),
    ],
    values: &[&["find"], &["fined", "found", "funded"], &["find"]],
    range: 1..=2,
};

static WORD_FINC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FINC_CHILDREN),
    value: None,
};

pub static WORD_FINC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ally"),
        dictgen::InsensitiveStr::Ascii("tional"),
        dictgen::InsensitiveStr::Ascii("tionalities"),
        dictgen::InsensitiveStr::Ascii("tionality"),
    ],
    values: &[
        &["finally"],
        &["functional", "fictional"],
        &["functionalities"],
        &["functionality"],
    ],
    range: 4..=11,
};

static WORD_FINA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FINA_CHILDREN),
    value: None,
};

pub static WORD_FINA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cee"),
        dictgen::InsensitiveStr::Ascii("cial"),
        dictgen::InsensitiveStr::Ascii("ilse"),
        dictgen::InsensitiveStr::Ascii("ilze"),
        dictgen::InsensitiveStr::Ascii("ll"),
        dictgen::InsensitiveStr::Ascii("lle"),
        dictgen::InsensitiveStr::Ascii("llizes"),
        dictgen::InsensitiveStr::Ascii("llly"),
        dictgen::InsensitiveStr::Ascii("ly"),
        dictgen::InsensitiveStr::Ascii("nace"),
        dictgen::InsensitiveStr::Ascii("naced"),
        dictgen::InsensitiveStr::Ascii("naces"),
        dictgen::InsensitiveStr::Ascii("nacially"),
        dictgen::InsensitiveStr::Ascii("nacier"),
        dictgen::InsensitiveStr::Ascii("ncialy"),
        dictgen::InsensitiveStr::Ascii("nically"),
        dictgen::InsensitiveStr::Ascii("nize"),
        dictgen::InsensitiveStr::Ascii("nlize"),
        dictgen::InsensitiveStr::Ascii("ntially"),
    ],
    values: &[
        &["fiancee"],
        &["financial"],
        &["finalise"],
        &["finalize"],
        &["final", "finally"],
        &["finale", "finally"],
        &["finalizes"],
        &["finally"],
        &["finally", "finale"],
        &["finance"],
        &["financed"],
        &["finances"],
        &["financially"],
        &["financier"],
        &["financially"],
        &["financially"],
        &["finalize"],
        &["finalize"],
        &["financially"],
    ],
    range: 2..=8,
};

static WORD_FIM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FIM_CHILDREN),
    value: None,
};

pub static WORD_FIM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("ilies"),
        dictgen::InsensitiveStr::Ascii("rware"),
        dictgen::InsensitiveStr::Ascii("ware"),
    ],
    values: &[
        &["fixme", "time"],
        &["families"],
        &["firmware"],
        &["firmware"],
    ],
    range: 1..=5,
};

static WORD_FIL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FIL_CHILDREN),
    value: None,
};

pub static WORD_FIL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("al"),
        dictgen::InsensitiveStr::Ascii("cker"),
        dictgen::InsensitiveStr::Ascii("eding"),
        dictgen::InsensitiveStr::Ascii("eds"),
        dictgen::InsensitiveStr::Ascii("eld"),
        dictgen::InsensitiveStr::Ascii("elds"),
        dictgen::InsensitiveStr::Ascii("enae"),
        dictgen::InsensitiveStr::Ascii("enname"),
        dictgen::InsensitiveStr::Ascii("ese"),
        dictgen::InsensitiveStr::Ascii("eshystem"),
        dictgen::InsensitiveStr::Ascii("eshystems"),
        dictgen::InsensitiveStr::Ascii("esname"),
        dictgen::InsensitiveStr::Ascii("esnames"),
        dictgen::InsensitiveStr::Ascii("ess"),
        dictgen::InsensitiveStr::Ascii("esstem"),
        dictgen::InsensitiveStr::Ascii("essytem"),
        dictgen::InsensitiveStr::Ascii("essytems"),
        dictgen::InsensitiveStr::Ascii("eststem"),
        dictgen::InsensitiveStr::Ascii("esysems"),
        dictgen::InsensitiveStr::Ascii("esysthem"),
        dictgen::InsensitiveStr::Ascii("esysthems"),
        dictgen::InsensitiveStr::Ascii("esystmes"),
        dictgen::InsensitiveStr::Ascii("esystyem"),
        dictgen::InsensitiveStr::Ascii("esystyems"),
        dictgen::InsensitiveStr::Ascii("esytem"),
        dictgen::InsensitiveStr::Ascii("esytems"),
        dictgen::InsensitiveStr::Ascii("esytsem"),
        dictgen::InsensitiveStr::Ascii("eter"),
        dictgen::InsensitiveStr::Ascii("etimes"),
        dictgen::InsensitiveStr::Ascii("eystem"),
        dictgen::InsensitiveStr::Ascii("eystems"),
        dictgen::InsensitiveStr::Ascii("iament"),
        dictgen::InsensitiveStr::Ascii("ies"),
        dictgen::InsensitiveStr::Ascii("lay"),
        dictgen::InsensitiveStr::Ascii("ld"),
        dictgen::InsensitiveStr::Ascii("le"),
        dictgen::InsensitiveStr::Ascii("lement"),
        dictgen::InsensitiveStr::Ascii("les"),
        dictgen::InsensitiveStr::Ascii("lowing"),
        dictgen::InsensitiveStr::Ascii("lung"),
        dictgen::InsensitiveStr::Ascii("mamkers"),
        dictgen::InsensitiveStr::Ascii("mmakare"),
        dictgen::InsensitiveStr::Ascii("mmakes"),
        dictgen::InsensitiveStr::Ascii("nal"),
        dictgen::InsensitiveStr::Ascii("name"),
        dictgen::InsensitiveStr::Ascii("p"),
        dictgen::InsensitiveStr::Ascii("pped"),
        dictgen::InsensitiveStr::Ascii("pping"),
        dictgen::InsensitiveStr::Ascii("ps"),
        dictgen::InsensitiveStr::Ascii("s"),
        dictgen::InsensitiveStr::Ascii("se"),
        dictgen::InsensitiveStr::Ascii("system"),
        dictgen::InsensitiveStr::Ascii("systems"),
        dictgen::InsensitiveStr::Ascii("terd"),
        dictgen::InsensitiveStr::Ascii("terig"),
        dictgen::InsensitiveStr::Ascii("terin"),
        dictgen::InsensitiveStr::Ascii("terring"),
        dictgen::InsensitiveStr::Ascii("tersing"),
        dictgen::InsensitiveStr::Ascii("terss"),
        dictgen::InsensitiveStr::Ascii("type"),
        dictgen::InsensitiveStr::Ascii("types"),
    ],
    values: &[
        &["final"],
        &["flicker"],
        &["fielding"],
        &["fields"],
        &["field"],
        &["fields"],
        &["filename"],
        &["filename"],
        &["files"],
        &["filesystem"],
        &["filesystems"],
        &["filename", "filenames"],
        &["filenames"],
        &["files"],
        &["filesystem"],
        &["filesystem"],
        &["filesystems"],
        &["filesystem"],
        &["filesystems"],
        &["filesystem"],
        &["filesystems"],
        &["filesystems"],
        &["filesystem"],
        &["filesystems"],
        &["filesystem"],
        &["filesystem", "filesystems"],
        &["filesystem"],
        &["filter"],
        &["lifetimes"],
        &["filesystem"],
        &["filesystems"],
        &["filament"],
        &["files"],
        &["fillet"],
        &["filled", "filed", "fill"],
        &["file", "fill", "filled"],
        &["filament"],
        &["files", "fills", "filled"],
        &["following"],
        &["filling"],
        &["filmmakers"],
        &["filmmakers"],
        &["filmmakers"],
        &["final"],
        &["filename"],
        &["flip"],
        &["flipped"],
        &["flipping"],
        &["flips"],
        &["fills", "files", "file"],
        &["files"],
        &["filesystem"],
        &["filesystems"],
        &["filtered"],
        &["filtering"],
        &["filtering"],
        &["filtering"],
        &["filtering"],
        &["filters"],
        &["filetype"],
        &["filetypes"],
    ],
    range: 1..=9,
};

static WORD_FIK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FIK_CHILDREN),
    value: None,
};

pub static WORD_FIK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("e")],
    values: &[&["file"]],
    range: 1..=1,
};

static WORD_FIG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FIG_CHILDREN),
    value: None,
};

pub static WORD_FIG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("hitng"),
        dictgen::InsensitiveStr::Ascii("htings"),
        dictgen::InsensitiveStr::Ascii("nernails"),
        dictgen::InsensitiveStr::Ascii("nerprint"),
        dictgen::InsensitiveStr::Ascii("thing"),
        dictgen::InsensitiveStr::Ascii("uartively"),
        dictgen::InsensitiveStr::Ascii("uratevely"),
        dictgen::InsensitiveStr::Ascii("urativeley"),
        dictgen::InsensitiveStr::Ascii("urativelly"),
        dictgen::InsensitiveStr::Ascii("urativley"),
        dictgen::InsensitiveStr::Ascii("urativly"),
        dictgen::InsensitiveStr::Ascii("urestyle"),
        dictgen::InsensitiveStr::Ascii("uretively"),
        dictgen::InsensitiveStr::Ascii("uritively"),
    ],
    values: &[
        &["fighting"],
        &["fighting"],
        &["fingernails"],
        &["fingerprint"],
        &["fighting"],
        &["figuratively"],
        &["figuratively"],
        &["figuratively"],
        &["figuratively"],
        &["figuratively"],
        &["figuratively"],
        &["figurestyles"],
        &["figuratively"],
        &["figuratively"],
    ],
    range: 5..=10,
};

static WORD_FIF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FIF_CHILDREN),
    value: None,
};

pub static WORD_FIF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ht")],
    values: &[&["fifth", "fight"]],
    range: 2..=2,
};

static WORD_FIE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FIE_CHILDREN),
    value: None,
};

pub static WORD_FIE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("d"),
        dictgen::InsensitiveStr::Ascii("dl"),
        dictgen::InsensitiveStr::Ascii("dled"),
        dictgen::InsensitiveStr::Ascii("dling"),
        dictgen::InsensitiveStr::Ascii("dlity"),
        dictgen::InsensitiveStr::Ascii("dls"),
        dictgen::InsensitiveStr::Ascii("id"),
        dictgen::InsensitiveStr::Ascii("l"),
        dictgen::InsensitiveStr::Ascii("ldlst"),
        dictgen::InsensitiveStr::Ascii("led"),
        dictgen::InsensitiveStr::Ascii("lesystem"),
        dictgen::InsensitiveStr::Ascii("lesystems"),
        dictgen::InsensitiveStr::Ascii("lname"),
        dictgen::InsensitiveStr::Ascii("lneame"),
        dictgen::InsensitiveStr::Ascii("ls"),
        dictgen::InsensitiveStr::Ascii("rcly"),
        dictgen::InsensitiveStr::Ascii("w"),
    ],
    values: &[
        &["field"],
        &["field"],
        &["fielded"],
        &["fielding"],
        &["fidelity"],
        &["fields"],
        &["field"],
        &["feel", "field", "file", "phial"],
        &["fieldlist"],
        &["field"],
        &["filesystem"],
        &["filesystems"],
        &["filename"],
        &["filename"],
        &["fields", "feels", "files", "phials"],
        &["fiercely"],
        &["few", "flew"],
    ],
    range: 1..=9,
};

static WORD_FID_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FID_CHILDREN),
    value: None,
};

pub static WORD_FID_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ality"),
        dictgen::InsensitiveStr::Ascii("dley"),
        dictgen::InsensitiveStr::Ascii("eling"),
        dictgen::InsensitiveStr::Ascii("eltiy"),
        dictgen::InsensitiveStr::Ascii("n"),
    ],
    values: &[
        &["fidelity"],
        &["fiddly"],
        &["fielding"],
        &["fidelity"],
        &["find"],
    ],
    range: 1..=5,
};

static WORD_FIC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FIC_CHILDREN),
    value: None,
};

pub static WORD_FIC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ks"),
        dictgen::InsensitiveStr::Ascii("ticious"),
        dictgen::InsensitiveStr::Ascii("ticous"),
        dictgen::InsensitiveStr::Ascii("tionaries"),
        dictgen::InsensitiveStr::Ascii("tious"),
    ],
    values: &[
        &["flicks", "fix"],
        &["fictitious"],
        &["fictitious"],
        &["dictionaries"],
        &["fictitious"],
    ],
    range: 2..=9,
};

static WORD_FIB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FIB_CHILDREN),
    value: None,
};

pub static WORD_FIB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("onaacci"),
        dictgen::InsensitiveStr::Ascii("onnacci"),
    ],
    values: &[&["fibonacci"], &["fibonacci"]],
    range: 7..=7,
};

static WORD_FIA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FIA_CHILDREN),
    value: None,
};

pub static WORD_FIA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ls"),
        dictgen::InsensitiveStr::Ascii("nite"),
        dictgen::InsensitiveStr::Ascii("nlly"),
    ],
    values: &[&["fails"], &["finite"], &["finally"]],
    range: 2..=4,
};

static WORD_FH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FH_CHILDREN),
    value: None,
};

pub static WORD_FH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("urter")],
    values: &[&["further"]],
    range: 5..=5,
};

static WORD_FE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_FE_CHILDREN),
    value: None,
};

static WORD_FE_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_FEA_NODE),
    Some(&WORD_FEB_NODE),
    Some(&WORD_FEC_NODE),
    Some(&WORD_FED_NODE),
    Some(&WORD_FEE_NODE),
    None,
    None,
    None,
    Some(&WORD_FEI_NODE),
    None,
    None,
    Some(&WORD_FEL_NODE),
    Some(&WORD_FEM_NODE),
    None,
    Some(&WORD_FEO_NODE),
    None,
    Some(&WORD_FEQ_NODE),
    Some(&WORD_FER_NODE),
    Some(&WORD_FES_NODE),
    Some(&WORD_FET_NODE),
    None,
    None,
    Some(&WORD_FEW_NODE),
    Some(&WORD_FEX_NODE),
    None,
    Some(&WORD_FEZ_NODE),
];

static WORD_FEZ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FEZ_CHILDREN),
    value: None,
};

pub static WORD_FEZ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ent")],
    values: &[&["pheasant"]],
    range: 3..=3,
};

static WORD_FEX_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FEX_CHILDREN),
    value: None,
};

pub static WORD_FEX_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ibility")],
    values: &[&["flexibility"]],
    range: 7..=7,
};

static WORD_FEW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FEW_CHILDREN),
    value: None,
};

pub static WORD_FEW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("d"),
        dictgen::InsensitiveStr::Ascii("g"),
        dictgen::InsensitiveStr::Ascii("sha"),
    ],
    values: &[&["few", "feud"], &["few", "fugue"], &["fuchsia"]],
    range: 1..=3,
};

static WORD_FET_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FET_CHILDREN),
    value: None,
};

pub static WORD_FET_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aure"),
        dictgen::InsensitiveStr::Ascii("aures"),
        dictgen::InsensitiveStr::Ascii("chs"),
        dictgen::InsensitiveStr::Ascii("hced"),
        dictgen::InsensitiveStr::Ascii("hces"),
        dictgen::InsensitiveStr::Ascii("ishers"),
        dictgen::InsensitiveStr::Ascii("ishiste"),
        dictgen::InsensitiveStr::Ascii("ishs"),
        dictgen::InsensitiveStr::Ascii("ures"),
    ],
    values: &[
        &["feature"],
        &["features"],
        &["fetches"],
        &["fetched"],
        &["fetches"],
        &["fetishes"],
        &["fetishes"],
        &["fetishes"],
        &["features"],
    ],
    range: 3..=7,
};

static WORD_FES_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FES_CHILDREN),
    value: None,
};

pub static WORD_FES_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("iable"),
        dictgen::InsensitiveStr::Ascii("itvals"),
        dictgen::InsensitiveStr::Ascii("itve"),
        dictgen::InsensitiveStr::Ascii("tivalens"),
        dictgen::InsensitiveStr::Ascii("tivales"),
        dictgen::InsensitiveStr::Ascii("tivas"),
        dictgen::InsensitiveStr::Ascii("tivle"),
    ],
    values: &[
        &["feasible"],
        &["festivals"],
        &["festive"],
        &["festivals"],
        &["festivals"],
        &["festivals"],
        &["festive"],
    ],
    range: 4..=8,
};

static WORD_FER_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FER_CHILDREN),
    value: None,
};

pub static WORD_FER_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("mantation"),
        dictgen::InsensitiveStr::Ascii("mentacion"),
        dictgen::InsensitiveStr::Ascii("mentaion"),
        dictgen::InsensitiveStr::Ascii("mentaiton"),
        dictgen::InsensitiveStr::Ascii("mentating"),
        dictgen::InsensitiveStr::Ascii("mentato"),
        dictgen::InsensitiveStr::Ascii("menterad"),
        dictgen::InsensitiveStr::Ascii("mintation"),
        dictgen::InsensitiveStr::Ascii("omone"),
        dictgen::InsensitiveStr::Ascii("talizer"),
        dictgen::InsensitiveStr::Ascii("telizer"),
        dictgen::InsensitiveStr::Ascii("til"),
        dictgen::InsensitiveStr::Ascii("tilizar"),
        dictgen::InsensitiveStr::Ascii("tilizier"),
        dictgen::InsensitiveStr::Ascii("tily"),
        dictgen::InsensitiveStr::Ascii("tilzier"),
        dictgen::InsensitiveStr::Ascii("tiziler"),
        dictgen::InsensitiveStr::Ascii("tizilers"),
    ],
    values: &[
        &["fermentation"],
        &["fermentation"],
        &["fermentation"],
        &["fermentation"],
        &["fermentation"],
        &["fermentation"],
        &["fermented"],
        &["fermentation"],
        &["pheromone"],
        &["fertilizer"],
        &["fertilizer"],
        &["fertile"],
        &["fertilizer"],
        &["fertilizer"],
        &["fertility"],
        &["fertilizer"],
        &["fertilizer"],
        &["fertilizer"],
    ],
    range: 3..=9,
};

static WORD_FEQ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FEQ_CHILDREN),
    value: None,
};

pub static WORD_FEQ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("uency")],
    values: &[&["frequency"]],
    range: 5..=5,
};

static WORD_FEO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FEO_CHILDREN),
    value: None,
};

pub static WORD_FEO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("dras"),
        dictgen::InsensitiveStr::Ascii("nsay"),
    ],
    values: &[&["fedoras"], &["fiancée"]],
    range: 4..=4,
};

static WORD_FEM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FEM_CHILDREN),
    value: None,
};

pub static WORD_FEM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("inen"),
        dictgen::InsensitiveStr::Ascii("inie"),
        dictgen::InsensitiveStr::Ascii("inim"),
        dictgen::InsensitiveStr::Ascii("inimity"),
        dictgen::InsensitiveStr::Ascii("inint"),
        dictgen::InsensitiveStr::Ascii("inisim"),
        dictgen::InsensitiveStr::Ascii("inistas"),
        dictgen::InsensitiveStr::Ascii("inisters"),
        dictgen::InsensitiveStr::Ascii("inistisk"),
        dictgen::InsensitiveStr::Ascii("initity"),
        dictgen::InsensitiveStr::Ascii("insim"),
        dictgen::InsensitiveStr::Ascii("insits"),
        dictgen::InsensitiveStr::Ascii("minist"),
        dictgen::InsensitiveStr::Ascii("pto"),
    ],
    values: &[
        &["feminine"],
        &["feminine"],
        &["feminism"],
        &["femininity"],
        &["femininity"],
        &["feminism"],
        &["feminists"],
        &["feminists"],
        &["feminists"],
        &["femininity"],
        &["feminism"],
        &["feminists"],
        &["feminist"],
        &["femto"],
    ],
    range: 3..=8,
};

static WORD_FEL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FEL_CHILDREN),
    value: None,
};

pub static WORD_FEL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("d"),
        dictgen::InsensitiveStr::Ascii("isatus"),
        dictgen::InsensitiveStr::Ascii("lowhsip"),
        dictgen::InsensitiveStr::Ascii("lowshop"),
        dictgen::InsensitiveStr::Ascii("tcher"),
        dictgen::InsensitiveStr::Ascii("xibility"),
        dictgen::InsensitiveStr::Ascii("xible"),
    ],
    values: &[
        &["field"],
        &["felicitous"],
        &["fellowship"],
        &["fellowship"],
        &["fletcher"],
        &["flexibility"],
        &["flexible"],
    ],
    range: 1..=8,
};

static WORD_FEI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FEI_CHILDREN),
    value: None,
};

pub static WORD_FEI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ld"),
        dictgen::InsensitiveStr::Ascii("lding"),
        dictgen::InsensitiveStr::Ascii("sable"),
        dictgen::InsensitiveStr::Ascii("tshes"),
    ],
    values: &[&["field"], &["fielding"], &["feasible"], &["fetishes"]],
    range: 2..=5,
};

static WORD_FEE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FEE_CHILDREN),
    value: None,
};

pub static WORD_FEE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("back"),
        dictgen::InsensitiveStr::Ascii("ded"),
        dictgen::InsensitiveStr::Ascii("k"),
        dictgen::InsensitiveStr::Ascii("ks"),
        dictgen::InsensitiveStr::Ascii("ts"),
        dictgen::InsensitiveStr::Ascii("tur"),
        dictgen::InsensitiveStr::Ascii("ture"),
    ],
    values: &[
        &["feedback"],
        &["fed"],
        &["feel"],
        &["feels"],
        &["feet", "feats"],
        &["feature"],
        &["feature"],
    ],
    range: 1..=4,
};

static WORD_FED_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FED_CHILDREN),
    value: None,
};

pub static WORD_FED_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ality"),
        dictgen::InsensitiveStr::Ascii("eracion"),
        dictgen::InsensitiveStr::Ascii("erativo"),
        dictgen::InsensitiveStr::Ascii("ility"),
        dictgen::InsensitiveStr::Ascii("orahs"),
        dictgen::InsensitiveStr::Ascii("orans"),
        dictgen::InsensitiveStr::Ascii("really"),
        dictgen::InsensitiveStr::Ascii("reated"),
    ],
    values: &[
        &["fidelity"],
        &["federation"],
        &["federation"],
        &["fidelity"],
        &["fedoras"],
        &["fedoras"],
        &["federally"],
        &["federated"],
    ],
    range: 5..=7,
};

static WORD_FEC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FEC_CHILDREN),
    value: None,
};

pub static WORD_FEC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("thed"),
        dictgen::InsensitiveStr::Ascii("thes"),
        dictgen::InsensitiveStr::Ascii("thing"),
    ],
    values: &[&["fetched"], &["fetches"], &["fetching"]],
    range: 4..=5,
};

static WORD_FEB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FEB_CHILDREN),
    value: None,
};

pub static WORD_FEB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("bruary"),
        dictgen::InsensitiveStr::Ascii("ewary"),
        dictgen::InsensitiveStr::Ascii("raury"),
        dictgen::InsensitiveStr::Ascii("ruar"),
        dictgen::InsensitiveStr::Ascii("ruray"),
        dictgen::InsensitiveStr::Ascii("uary"),
        dictgen::InsensitiveStr::Ascii("urary"),
    ],
    values: &[
        &["february"],
        &["february"],
        &["february"],
        &["february"],
        &["february"],
        &["february"],
        &["february"],
    ],
    range: 4..=6,
};

static WORD_FEA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FEA_CHILDREN),
    value: None,
};

pub static WORD_FEA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("sabile"),
        dictgen::InsensitiveStr::Ascii("sability"),
        dictgen::InsensitiveStr::Ascii("sable"),
        dictgen::InsensitiveStr::Ascii("sbile"),
        dictgen::InsensitiveStr::Ascii("tch"),
        dictgen::InsensitiveStr::Ascii("tchd"),
        dictgen::InsensitiveStr::Ascii("tched"),
        dictgen::InsensitiveStr::Ascii("tcher"),
        dictgen::InsensitiveStr::Ascii("tches"),
        dictgen::InsensitiveStr::Ascii("tching"),
        dictgen::InsensitiveStr::Ascii("tchs"),
        dictgen::InsensitiveStr::Ascii("tchss"),
        dictgen::InsensitiveStr::Ascii("tchure"),
        dictgen::InsensitiveStr::Ascii("tchured"),
        dictgen::InsensitiveStr::Ascii("tchures"),
        dictgen::InsensitiveStr::Ascii("tchuring"),
        dictgen::InsensitiveStr::Ascii("tre"),
        dictgen::InsensitiveStr::Ascii("tue"),
        dictgen::InsensitiveStr::Ascii("tued"),
        dictgen::InsensitiveStr::Ascii("tues"),
        dictgen::InsensitiveStr::Ascii("tur"),
        dictgen::InsensitiveStr::Ascii("turs"),
        dictgen::InsensitiveStr::Ascii("utre"),
        dictgen::InsensitiveStr::Ascii("utres"),
        dictgen::InsensitiveStr::Ascii("uture"),
        dictgen::InsensitiveStr::Ascii("utures"),
    ],
    values: &[
        &["feasible"],
        &["feasibility"],
        &["feasible"],
        &["feasible"],
        &["fetch", "each"],
        &["fetched"],
        &["fetched"],
        &["feather", "feature", "fetcher"],
        &["fetches", "features"],
        &["fetching"],
        &["fetches"],
        &["fetches"],
        &["feature"],
        &["featured"],
        &["features"],
        &["featuring"],
        &["feature"],
        &["feature"],
        &["featured"],
        &["features"],
        &["feature"],
        &["features"],
        &["feature"],
        &["features"],
        &["feature"],
        &["features"],
    ],
    range: 3..=8,
};

static WORD_FC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FC_CHILDREN),
    value: None,
};

pub static WORD_FC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ound")],
    values: &[&["found"]],
    range: 4..=4,
};

static WORD_FA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_FA_CHILDREN),
    value: None,
};

static WORD_FA_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    Some(&WORD_FAB_NODE),
    Some(&WORD_FAC_NODE),
    Some(&WORD_FAD_NODE),
    Some(&WORD_FAE_NODE),
    None,
    Some(&WORD_FAG_NODE),
    Some(&WORD_FAH_NODE),
    Some(&WORD_FAI_NODE),
    None,
    Some(&WORD_FAK_NODE),
    Some(&WORD_FAL_NODE),
    Some(&WORD_FAM_NODE),
    Some(&WORD_FAN_NODE),
    Some(&WORD_FAO_NODE),
    Some(&WORD_FAP_NODE),
    None,
    Some(&WORD_FAR_NODE),
    Some(&WORD_FAS_NODE),
    Some(&WORD_FAT_NODE),
    Some(&WORD_FAU_NODE),
    Some(&WORD_FAV_NODE),
    None,
    None,
    Some(&WORD_FAY_NODE),
    None,
];

static WORD_FAY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FAY_CHILDREN),
    value: None,
};

pub static WORD_FAY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("mus")],
    values: &[&["famous"]],
    range: 3..=3,
};

static WORD_FAV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FAV_CHILDREN),
    value: None,
};

pub static WORD_FAV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("oritisme"),
        dictgen::InsensitiveStr::Ascii("orits"),
        dictgen::InsensitiveStr::Ascii("orties"),
        dictgen::InsensitiveStr::Ascii("oruite"),
        dictgen::InsensitiveStr::Ascii("oruites"),
        dictgen::InsensitiveStr::Ascii("ourates"),
        dictgen::InsensitiveStr::Ascii("ourie"),
        dictgen::InsensitiveStr::Ascii("ourits"),
        dictgen::InsensitiveStr::Ascii("ouritsm"),
        dictgen::InsensitiveStr::Ascii("ourtie"),
        dictgen::InsensitiveStr::Ascii("ourties"),
        dictgen::InsensitiveStr::Ascii("outrable"),
        dictgen::InsensitiveStr::Ascii("ritt"),
        dictgen::InsensitiveStr::Ascii("uourites"),
    ],
    values: &[
        &["favorites"],
        &["favorites"],
        &["favorites"],
        &["favorite"],
        &["favorites"],
        &["favourites"],
        &["favourites"],
        &["favourites"],
        &["favourites"],
        &["favourite"],
        &["favourites"],
        &["favourable"],
        &["favorite"],
        &["favourites"],
    ],
    range: 4..=8,
};

static WORD_FAU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FAU_CHILDREN),
    value: None,
};

pub static WORD_FAU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ght"),
        dictgen::InsensitiveStr::Ascii("ilure"),
        dictgen::InsensitiveStr::Ascii("ilures"),
        dictgen::InsensitiveStr::Ascii("lsure"),
        dictgen::InsensitiveStr::Ascii("lsures"),
        dictgen::InsensitiveStr::Ascii("lure"),
        dictgen::InsensitiveStr::Ascii("lures"),
        dictgen::InsensitiveStr::Ascii("nd"),
        dictgen::InsensitiveStr::Ascii("ture"),
        dictgen::InsensitiveStr::Ascii("tured"),
        dictgen::InsensitiveStr::Ascii("tures"),
        dictgen::InsensitiveStr::Ascii("turing"),
    ],
    values: &[
        &["fought"],
        &["failure"],
        &["failures"],
        &["failure"],
        &["failures"],
        &["failure"],
        &["failures"],
        &["found", "fund"],
        &["feature"],
        &["featured"],
        &["features"],
        &["featuring"],
    ],
    range: 2..=6,
};

static WORD_FAT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FAT_CHILDREN),
    value: None,
};

pub static WORD_FAT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("alaties"),
        dictgen::InsensitiveStr::Ascii("alitites"),
        dictgen::InsensitiveStr::Ascii("c"),
        dictgen::InsensitiveStr::Ascii("er"),
        dictgen::InsensitiveStr::Ascii("ig"),
        dictgen::InsensitiveStr::Ascii("igure"),
        dictgen::InsensitiveStr::Ascii("iuge"),
        dictgen::InsensitiveStr::Ascii("ser"),
        dictgen::InsensitiveStr::Ascii("ure"),
    ],
    values: &[
        &["fatalities"],
        &["fatalities"],
        &["fact"],
        &["faster"],
        &["fatigue"],
        &["fatigue"],
        &["fatigue"],
        &["faster"],
        &["feature"],
    ],
    range: 1..=8,
};

static WORD_FAS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FAS_CHILDREN),
    value: None,
};

pub static WORD_FAS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ade"),
        dictgen::InsensitiveStr::Ascii("cianted"),
        dictgen::InsensitiveStr::Ascii("cinacion"),
        dictgen::InsensitiveStr::Ascii("cinatie"),
        dictgen::InsensitiveStr::Ascii("cinatin"),
        dictgen::InsensitiveStr::Ascii("cinatinf"),
        dictgen::InsensitiveStr::Ascii("cisation"),
        dictgen::InsensitiveStr::Ascii("cisim"),
        dictgen::InsensitiveStr::Ascii("cistes"),
        dictgen::InsensitiveStr::Ascii("cistisk"),
        dictgen::InsensitiveStr::Ascii("cits"),
        dictgen::InsensitiveStr::Ascii("cization"),
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("eeshus"),
        dictgen::InsensitiveStr::Ascii("eeshusly"),
        dictgen::InsensitiveStr::Ascii("en"),
        dictgen::InsensitiveStr::Ascii("end"),
        dictgen::InsensitiveStr::Ascii("ened"),
        dictgen::InsensitiveStr::Ascii("ening"),
        dictgen::InsensitiveStr::Ascii("ens"),
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("hionalbe"),
        dictgen::InsensitiveStr::Ascii("hionalble"),
        dictgen::InsensitiveStr::Ascii("hiond"),
        dictgen::InsensitiveStr::Ascii("hism"),
        dictgen::InsensitiveStr::Ascii("hist"),
        dictgen::InsensitiveStr::Ascii("hists"),
        dictgen::InsensitiveStr::Ascii("hoinable"),
        dictgen::InsensitiveStr::Ascii("hoined"),
        dictgen::InsensitiveStr::Ascii("hon"),
        dictgen::InsensitiveStr::Ascii("honable"),
        dictgen::InsensitiveStr::Ascii("honed"),
        dictgen::InsensitiveStr::Ascii("honing"),
        dictgen::InsensitiveStr::Ascii("hons"),
        dictgen::InsensitiveStr::Ascii("icsm"),
        dictgen::InsensitiveStr::Ascii("icst"),
        dictgen::InsensitiveStr::Ascii("icsts"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("ion"),
        dictgen::InsensitiveStr::Ascii("le"),
        dictgen::InsensitiveStr::Ascii("lely"),
        dictgen::InsensitiveStr::Ascii("odd"),
        dictgen::InsensitiveStr::Ascii("odds"),
        dictgen::InsensitiveStr::Ascii("sade"),
        dictgen::InsensitiveStr::Ascii("sinate"),
        dictgen::InsensitiveStr::Ascii("terner"),
        dictgen::InsensitiveStr::Ascii("terners"),
        dictgen::InsensitiveStr::Ascii("tner"),
        dictgen::InsensitiveStr::Ascii("tners"),
        dictgen::InsensitiveStr::Ascii("tr"),
    ],
    values: &[
        &["facade"],
        &["fascinated"],
        &["fascination"],
        &["fascinated"],
        &["fascination"],
        &["fascination"],
        &["fascination"],
        &["fascism"],
        &["fascists"],
        &["fascists"],
        &["fascist"],
        &["fascination"],
        &["faze", "phase", "false"],
        &["fazed", "phased"],
        &["facetious"],
        &["facetiously"],
        &["fasten"],
        &["fastened"],
        &["fastened"],
        &["fastening"],
        &["fasels", "fastens"],
        &["fazes", "phases"],
        &["fashionable"],
        &["fashionable"],
        &["fashioned"],
        &["fascism"],
        &["fascist"],
        &["fascists"],
        &["fashionable"],
        &["fashioned"],
        &["fashion"],
        &["fashionable"],
        &["fashioned"],
        &["fashioning"],
        &["fashions"],
        &["fascism"],
        &["fascist"],
        &["fascists"],
        &["fazing", "phasing"],
        &["fashion"],
        &["false"],
        &["falsely"],
        &["facade"],
        &["facades"],
        &["facade"],
        &["fascinate"],
        &["fastener"],
        &["fasteners"],
        &["fastener"],
        &["fasteners"],
        &["faster"],
    ],
    range: 1..=9,
};

static WORD_FAR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FAR_CHILDREN),
    value: None,
};

pub static WORD_FAR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cking"),
        dictgen::InsensitiveStr::Ascii("ction"),
        dictgen::InsensitiveStr::Ascii("ehnheit"),
        dictgen::InsensitiveStr::Ascii("enheight"),
        dictgen::InsensitiveStr::Ascii("enheit"),
        dictgen::InsensitiveStr::Ascii("est"),
        dictgen::InsensitiveStr::Ascii("henheit"),
        dictgen::InsensitiveStr::Ascii("iar"),
        dictgen::InsensitiveStr::Ascii("ies"),
        dictgen::InsensitiveStr::Ascii("masudic"),
        dictgen::InsensitiveStr::Ascii("masudical"),
        dictgen::InsensitiveStr::Ascii("masudics"),
        dictgen::InsensitiveStr::Ascii("mework"),
        dictgen::InsensitiveStr::Ascii("se"),
        dictgen::InsensitiveStr::Ascii("ses"),
        dictgen::InsensitiveStr::Ascii("sical"),
    ],
    values: &[
        &["fracking"],
        &["fraction", "faction"],
        &["fahrenheit"],
        &["fahrenheit"],
        &["fahrenheit"],
        &["fairest", "farthest"],
        &["fahrenheit"],
        &["farrier"],
        &["fairies"],
        &["pharmaceutic"],
        &["pharmaceutical"],
        &["pharmaceutics"],
        &["framework"],
        &["farce"],
        &["farces"],
        &["farcical"],
    ],
    range: 2..=9,
};

static WORD_FAP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FAP_CHILDREN),
    value: None,
};

pub static WORD_FAP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("tastically")],
    values: &[&["fantastically"]],
    range: 10..=10,
};

static WORD_FAO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FAO_CHILDREN),
    value: None,
};

pub static WORD_FAO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ming")],
    values: &[&["foaming"]],
    range: 4..=4,
};

static WORD_FAN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FAN_CHILDREN),
    value: None,
};

pub static WORD_FAN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aticals"),
        dictgen::InsensitiveStr::Ascii("aticas"),
        dictgen::InsensitiveStr::Ascii("aticos"),
        dictgen::InsensitiveStr::Ascii("aticus"),
        dictgen::InsensitiveStr::Ascii("atism"),
        dictgen::InsensitiveStr::Ascii("atsic"),
        dictgen::InsensitiveStr::Ascii("atsies"),
        dictgen::InsensitiveStr::Ascii("atsize"),
        dictgen::InsensitiveStr::Ascii("atsizing"),
        dictgen::InsensitiveStr::Ascii("atsy"),
        dictgen::InsensitiveStr::Ascii("cyness"),
        dictgen::InsensitiveStr::Ascii("dation"),
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("faction"),
        dictgen::InsensitiveStr::Ascii("fcition"),
        dictgen::InsensitiveStr::Ascii("ficiton"),
        dictgen::InsensitiveStr::Ascii("ficitons"),
        dictgen::InsensitiveStr::Ascii("serivce"),
        dictgen::InsensitiveStr::Ascii("serve"),
        dictgen::InsensitiveStr::Ascii("servie"),
        dictgen::InsensitiveStr::Ascii("servise"),
        dictgen::InsensitiveStr::Ascii("servive"),
        dictgen::InsensitiveStr::Ascii("slaughter"),
        dictgen::InsensitiveStr::Ascii("tacising"),
        dictgen::InsensitiveStr::Ascii("tacizing"),
        dictgen::InsensitiveStr::Ascii("taic"),
        dictgen::InsensitiveStr::Ascii("tasazing"),
        dictgen::InsensitiveStr::Ascii("tasiaing"),
        dictgen::InsensitiveStr::Ascii("tasiose"),
        dictgen::InsensitiveStr::Ascii("tasitcally"),
        dictgen::InsensitiveStr::Ascii("tasmically"),
        dictgen::InsensitiveStr::Ascii("tasticaly"),
        dictgen::InsensitiveStr::Ascii("tasticlly"),
        dictgen::InsensitiveStr::Ascii("tasty"),
        dictgen::InsensitiveStr::Ascii("tasyzing"),
        dictgen::InsensitiveStr::Ascii("tazise"),
        dictgen::InsensitiveStr::Ascii("tazising"),
        dictgen::InsensitiveStr::Ascii("tistically"),
    ],
    values: &[
        &["fanatics"],
        &["fanatics"],
        &["fanatics"],
        &["fanatics"],
        &["fanaticism"],
        &["fanatics"],
        &["fantasies"],
        &["fantasize"],
        &["fantasizing"],
        &["fantasy"],
        &["fanciness"],
        &["foundation"],
        &["fan", "feign"],
        &["fanfiction"],
        &["fanfiction"],
        &["fanfiction"],
        &["fanfiction"],
        &["fanservice"],
        &["fanservice"],
        &["fanservice"],
        &["fanservice"],
        &["fanservice"],
        &["manslaughter"],
        &["fantasising"],
        &["fantasizing"],
        &["fanatic"],
        &["fantasizing"],
        &["fantasizing"],
        &["fantasies"],
        &["fantastically"],
        &["fantastically"],
        &["fantastically"],
        &["fantastically"],
        &["fantasy"],
        &["fantasizing"],
        &["fantasise"],
        &["fantasising"],
        &["fantastically"],
    ],
    range: 1..=10,
};

static WORD_FAM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FAM_CHILDREN),
    value: None,
};

pub static WORD_FAM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ilair"),
        dictgen::InsensitiveStr::Ascii("ilairity"),
        dictgen::InsensitiveStr::Ascii("ilairize"),
        dictgen::InsensitiveStr::Ascii("ilar"),
        dictgen::InsensitiveStr::Ascii("iles"),
        dictgen::InsensitiveStr::Ascii("iliair"),
        dictgen::InsensitiveStr::Ascii("iliare"),
        dictgen::InsensitiveStr::Ascii("iliaries"),
        dictgen::InsensitiveStr::Ascii("iliarizate"),
        dictgen::InsensitiveStr::Ascii("iliarlize"),
        dictgen::InsensitiveStr::Ascii("iliarty"),
        dictgen::InsensitiveStr::Ascii("iliary"),
        dictgen::InsensitiveStr::Ascii("iliarze"),
        dictgen::InsensitiveStr::Ascii("ilierize"),
        dictgen::InsensitiveStr::Ascii("iliies"),
        dictgen::InsensitiveStr::Ascii("iliy"),
        dictgen::InsensitiveStr::Ascii("illiar"),
        dictgen::InsensitiveStr::Ascii("illy"),
        dictgen::InsensitiveStr::Ascii("lilies"),
        dictgen::InsensitiveStr::Ascii("lily"),
        dictgen::InsensitiveStr::Ascii("ly"),
        dictgen::InsensitiveStr::Ascii("oulsy"),
        dictgen::InsensitiveStr::Ascii("oust"),
        dictgen::InsensitiveStr::Ascii("ousy"),
    ],
    values: &[
        &["familiar"],
        &["familiarity"],
        &["familiarize"],
        &["familiar"],
        &["families"],
        &["familiar"],
        &["familiarize"],
        &["familiarize"],
        &["familiarize"],
        &["familiarize"],
        &["familiarity"],
        &["familiarity"],
        &["familiarize"],
        &["familiarize"],
        &["families"],
        &["family"],
        &["familiar"],
        &["family"],
        &["families"],
        &["family"],
        &["family"],
        &["famously"],
        &["famous"],
        &["famously"],
    ],
    range: 2..=10,
};

static WORD_FAL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FAL_CHILDREN),
    value: None,
};

pub static WORD_FAL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cones"),
        dictgen::InsensitiveStr::Ascii("esly"),
        dictgen::InsensitiveStr::Ascii("g"),
        dictgen::InsensitiveStr::Ascii("gs"),
        dictgen::InsensitiveStr::Ascii("gship"),
        dictgen::InsensitiveStr::Ascii("ied"),
        dictgen::InsensitiveStr::Ascii("ired"),
        dictgen::InsensitiveStr::Ascii("iure"),
        dictgen::InsensitiveStr::Ascii("iures"),
        dictgen::InsensitiveStr::Ascii("labck"),
        dictgen::InsensitiveStr::Ascii("latious"),
        dictgen::InsensitiveStr::Ascii("lbacl"),
        dictgen::InsensitiveStr::Ascii("lbck"),
        dictgen::InsensitiveStr::Ascii("lhrough"),
        dictgen::InsensitiveStr::Ascii("licious"),
        dictgen::InsensitiveStr::Ascii("lthough"),
        dictgen::InsensitiveStr::Ascii("lthruogh"),
        dictgen::InsensitiveStr::Ascii("ltrough"),
        dictgen::InsensitiveStr::Ascii("methrower"),
        dictgen::InsensitiveStr::Ascii("seley"),
        dictgen::InsensitiveStr::Ascii("sh"),
        dictgen::InsensitiveStr::Ascii("shbacks"),
        dictgen::InsensitiveStr::Ascii("shed"),
        dictgen::InsensitiveStr::Ascii("shes"),
        dictgen::InsensitiveStr::Ascii("shing"),
        dictgen::InsensitiveStr::Ascii("sley"),
        dictgen::InsensitiveStr::Ascii("sly"),
        dictgen::InsensitiveStr::Ascii("so"),
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("ure"),
        dictgen::InsensitiveStr::Ascii("ures"),
        dictgen::InsensitiveStr::Ascii("vored"),
        dictgen::InsensitiveStr::Ascii("vors"),
        dictgen::InsensitiveStr::Ascii("vours"),
    ],
    values: &[
        &["falcons"],
        &["falsely"],
        &["flag"],
        &["flags"],
        &["flagship"],
        &["failed"],
        &["flaired"],
        &["failure"],
        &["failures"],
        &["fallback"],
        &["fallacious"],
        &["fallback"],
        &["fallback"],
        &["fallthrough"],
        &["fallacious"],
        &["fallthrough"],
        &["fallthrough"],
        &["fallthrough"],
        &["flamethrower"],
        &["falsely"],
        &["flash", "false"],
        &["flashbacks"],
        &["flashed"],
        &["flashes"],
        &["flashing"],
        &["falsely"],
        &["falsely"],
        &["false"],
        &["fault"],
        &["failure"],
        &["failures"],
        &["flavored"],
        &["flavors"],
        &["flavours"],
    ],
    range: 1..=9,
};

static WORD_FAK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FAK_CHILDREN),
    value: None,
};

pub static WORD_FAK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("tor"),
        dictgen::InsensitiveStr::Ascii("tored"),
        dictgen::InsensitiveStr::Ascii("toring"),
        dictgen::InsensitiveStr::Ascii("tors"),
    ],
    values: &[&["factor"], &["factored"], &["factoring"], &["factors"]],
    range: 3..=6,
};

static WORD_FAI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FAI_CHILDREN),
    value: None,
};

pub static WORD_FAI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("eld"),
        dictgen::InsensitiveStr::Ascii("ld"),
        dictgen::InsensitiveStr::Ascii("lded"),
        dictgen::InsensitiveStr::Ascii("le"),
        dictgen::InsensitiveStr::Ascii("ler"),
        dictgen::InsensitiveStr::Ascii("les"),
        dictgen::InsensitiveStr::Ascii("licies"),
        dictgen::InsensitiveStr::Ascii("licy"),
        dictgen::InsensitiveStr::Ascii("lied"),
        dictgen::InsensitiveStr::Ascii("liure"),
        dictgen::InsensitiveStr::Ascii("liures"),
        dictgen::InsensitiveStr::Ascii("liver"),
        dictgen::InsensitiveStr::Ascii("ll"),
        dictgen::InsensitiveStr::Ascii("lled"),
        dictgen::InsensitiveStr::Ascii("llure"),
        dictgen::InsensitiveStr::Ascii("lng"),
        dictgen::InsensitiveStr::Ascii("lre"),
        dictgen::InsensitiveStr::Ascii("lrue"),
        dictgen::InsensitiveStr::Ascii("lsave"),
        dictgen::InsensitiveStr::Ascii("lsaves"),
        dictgen::InsensitiveStr::Ascii("lt"),
        dictgen::InsensitiveStr::Ascii("lture"),
        dictgen::InsensitiveStr::Ascii("ltures"),
        dictgen::InsensitiveStr::Ascii("luare"),
        dictgen::InsensitiveStr::Ascii("lue"),
        dictgen::InsensitiveStr::Ascii("luer"),
        dictgen::InsensitiveStr::Ascii("luers"),
        dictgen::InsensitiveStr::Ascii("lues"),
        dictgen::InsensitiveStr::Ascii("lured"),
        dictgen::InsensitiveStr::Ascii("lurs"),
        dictgen::InsensitiveStr::Ascii("ncee"),
        dictgen::InsensitiveStr::Ascii("reness"),
        dictgen::InsensitiveStr::Ascii("roh"),
        dictgen::InsensitiveStr::Ascii("ulre"),
        dictgen::InsensitiveStr::Ascii("ulres"),
        dictgen::InsensitiveStr::Ascii("way"),
        dictgen::InsensitiveStr::Ascii("ways"),
    ],
    values: &[
        &["failed", "fade"],
        &["failed"],
        &["failed"],
        &["failed"],
        &["failed", "fail"],
        &["failure"],
        &["fails", "failed"],
        &["facilities"],
        &["facility"],
        &["failed"],
        &["failure"],
        &["failures"],
        &["failover"],
        &["fail"],
        &["failed"],
        &["failure"],
        &["failing"],
        &["failure"],
        &["failure"],
        &["failsafe"],
        &["failsafes"],
        &["fail", "failed"],
        &["failure"],
        &["failures"],
        &["failure"],
        &["failure"],
        &["failure"],
        &["failures"],
        &["failures"],
        &["failed"],
        &["failures"],
        &["fiancee"],
        &["fairness"],
        &["pharaoh"],
        &["failure"],
        &["failures"],
        &["fairway"],
        &["fairways"],
    ],
    range: 2..=6,
};

static WORD_FAH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FAH_CHILDREN),
    value: None,
};

pub static WORD_FAH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ernheit"),
        dictgen::InsensitiveStr::Ascii("renheight"),
        dictgen::InsensitiveStr::Ascii("renhiet"),
    ],
    values: &[&["fahrenheit"], &["fahrenheit"], &["fahrenheit"]],
    range: 7..=9,
};

static WORD_FAG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FAG_CHILDREN),
    value: None,
};

pub static WORD_FAG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("gotts"),
        dictgen::InsensitiveStr::Ascii("gotus"),
    ],
    values: &[&["faggots"], &["faggots"]],
    range: 5..=5,
};

static WORD_FAE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FAE_CHILDREN),
    value: None,
};

pub static WORD_FAE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ture"),
        dictgen::InsensitiveStr::Ascii("tures"),
    ],
    values: &[&["feature"], &["features"]],
    range: 4..=5,
};

static WORD_FAD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FAD_CHILDREN),
    value: None,
};

pub static WORD_FAD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ind")],
    values: &[&["fading"]],
    range: 3..=3,
};

static WORD_FAC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FAC_CHILDREN),
    value: None,
};

pub static WORD_FAC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ce"),
        dictgen::InsensitiveStr::Ascii("ebok"),
        dictgen::InsensitiveStr::Ascii("eboook"),
        dictgen::InsensitiveStr::Ascii("edrwaing"),
        dictgen::InsensitiveStr::Ascii("eis"),
        dictgen::InsensitiveStr::Ascii("epam"),
        dictgen::InsensitiveStr::Ascii("eplam"),
        dictgen::InsensitiveStr::Ascii("iliate"),
        dictgen::InsensitiveStr::Ascii("iliated"),
        dictgen::InsensitiveStr::Ascii("iliates"),
        dictgen::InsensitiveStr::Ascii("iliating"),
        dictgen::InsensitiveStr::Ascii("ilisi"),
        dictgen::InsensitiveStr::Ascii("ilitait"),
        dictgen::InsensitiveStr::Ascii("ilitant"),
        dictgen::InsensitiveStr::Ascii("ilitare"),
        dictgen::InsensitiveStr::Ascii("ilitarte"),
        dictgen::InsensitiveStr::Ascii("ilitatile"),
        dictgen::InsensitiveStr::Ascii("ilites"),
        dictgen::InsensitiveStr::Ascii("ilitiate"),
        dictgen::InsensitiveStr::Ascii("ilitiates"),
        dictgen::InsensitiveStr::Ascii("ilititate"),
        dictgen::InsensitiveStr::Ascii("ilitiy"),
        dictgen::InsensitiveStr::Ascii("illitate"),
        dictgen::InsensitiveStr::Ascii("illities"),
        dictgen::InsensitiveStr::Ascii("iltate"),
        dictgen::InsensitiveStr::Ascii("ilties"),
        dictgen::InsensitiveStr::Ascii("iltiy"),
        dictgen::InsensitiveStr::Ascii("inated"),
        dictgen::InsensitiveStr::Ascii("irity"),
        dictgen::InsensitiveStr::Ascii("isnated"),
        dictgen::InsensitiveStr::Ascii("isnation"),
        dictgen::InsensitiveStr::Ascii("ist"),
        dictgen::InsensitiveStr::Ascii("itilies"),
        dictgen::InsensitiveStr::Ascii("lons"),
        dictgen::InsensitiveStr::Ascii("or"),
        dictgen::InsensitiveStr::Ascii("orite"),
        dictgen::InsensitiveStr::Ascii("orites"),
        dictgen::InsensitiveStr::Ascii("ors"),
        dictgen::InsensitiveStr::Ascii("our"),
        dictgen::InsensitiveStr::Ascii("ourite"),
        dictgen::InsensitiveStr::Ascii("ourites"),
        dictgen::InsensitiveStr::Ascii("ours"),
        dictgen::InsensitiveStr::Ascii("sinated"),
        dictgen::InsensitiveStr::Ascii("sination"),
        dictgen::InsensitiveStr::Ascii("sism"),
        dictgen::InsensitiveStr::Ascii("sist"),
        dictgen::InsensitiveStr::Ascii("sists"),
        dictgen::InsensitiveStr::Ascii("tization"),
        dictgen::InsensitiveStr::Ascii("tores"),
        dictgen::InsensitiveStr::Ascii("torizaiton"),
        dictgen::InsensitiveStr::Ascii("torys"),
        dictgen::InsensitiveStr::Ascii("ttories"),
        dictgen::InsensitiveStr::Ascii("ttory"),
        dictgen::InsensitiveStr::Ascii("tuallity"),
        dictgen::InsensitiveStr::Ascii("tualy"),
        dictgen::InsensitiveStr::Ascii("utally"),
    ],
    values: &[
        &["face"],
        &["facebook"],
        &["facebook"],
        &["facedrawing"],
        &["faces"],
        &["facepalm"],
        &["facepalm"],
        &["facilitate"],
        &["facilitated"],
        &["facilitates"],
        &["facilitating"],
        &["facilities"],
        &["facilitate"],
        &["facilitate"],
        &["facilitate"],
        &["facilitate"],
        &["facilitate"],
        &["facilities"],
        &["facilitate"],
        &["facilitates"],
        &["facilitate"],
        &["facility"],
        &["facilitate"],
        &["facilities"],
        &["facilitate"],
        &["facilities"],
        &["facility"],
        &["fascinated"],
        &["facility"],
        &["fascinated"],
        &["fascination"],
        &["fascist"],
        &["facilities"],
        &["falcons"],
        &["favor", "faker"],
        &["favorite"],
        &["favorites"],
        &["favors", "fakers"],
        &["favour"],
        &["favourite"],
        &["favourites"],
        &["favours"],
        &["fascinated"],
        &["fascination"],
        &["fascism"],
        &["fascist"],
        &["fascists"],
        &["factorization"],
        &["factors"],
        &["factorization"],
        &["factors", "factories"],
        &["factories"],
        &["factory"],
        &["factually"],
        &["factually"],
        &["factually"],
    ],
    range: 2..=10,
};

static WORD_FAB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_FAB_CHILDREN),
    value: None,
};

pub static WORD_FAB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ility"),
        dictgen::InsensitiveStr::Ascii("ircate"),
        dictgen::InsensitiveStr::Ascii("ircated"),
        dictgen::InsensitiveStr::Ascii("ircates"),
        dictgen::InsensitiveStr::Ascii("ircatings"),
        dictgen::InsensitiveStr::Ascii("ircation"),
        dictgen::InsensitiveStr::Ascii("oulus"),
        dictgen::InsensitiveStr::Ascii("riacted"),
        dictgen::InsensitiveStr::Ascii("ricacion"),
        dictgen::InsensitiveStr::Ascii("ricas"),
        dictgen::InsensitiveStr::Ascii("ricatie"),
        dictgen::InsensitiveStr::Ascii("rices"),
        dictgen::InsensitiveStr::Ascii("ricus"),
        dictgen::InsensitiveStr::Ascii("rikation"),
        dictgen::InsensitiveStr::Ascii("ulos"),
    ],
    values: &[
        &["facility"],
        &["fabricate"],
        &["fabricated"],
        &["fabricates"],
        &["fabricating"],
        &["fabrication"],
        &["fabulous"],
        &["fabricated"],
        &["fabrication"],
        &["fabrics"],
        &["fabricated"],
        &["fabrics"],
        &["fabrics"],
        &["fabrication"],
        &["fabulous"],
    ],
    range: 4..=9,
};

static WORD_E_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_E_CHILDREN),
    value: None,
};

static WORD_E_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_EA_NODE),
    Some(&WORD_EB_NODE),
    Some(&WORD_EC_NODE),
    Some(&WORD_ED_NODE),
    Some(&WORD_EE_NODE),
    Some(&WORD_EF_NODE),
    Some(&WORD_EG_NODE),
    Some(&WORD_EH_NODE),
    Some(&WORD_EI_NODE),
    Some(&WORD_EJ_NODE),
    None,
    Some(&WORD_EL_NODE),
    Some(&WORD_EM_NODE),
    Some(&WORD_EN_NODE),
    None,
    Some(&WORD_EP_NODE),
    Some(&WORD_EQ_NODE),
    Some(&WORD_ER_NODE),
    Some(&WORD_ES_NODE),
    Some(&WORD_ET_NODE),
    Some(&WORD_EU_NODE),
    Some(&WORD_EV_NODE),
    Some(&WORD_EW_NODE),
    Some(&WORD_EX_NODE),
    Some(&WORD_EY_NODE),
    Some(&WORD_EZ_NODE),
];

static WORD_EZ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EZ_CHILDREN),
    value: None,
};

pub static WORD_EZ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("drop")],
    values: &[&["eavesdrop"]],
    range: 4..=4,
};

static WORD_EY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EY_CHILDREN),
    value: None,
};

pub static WORD_EY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ar"),
        dictgen::InsensitiveStr::Ascii("ars"),
        dictgen::InsensitiveStr::Ascii("asr"),
        dictgen::InsensitiveStr::Ascii("eballers"),
        dictgen::InsensitiveStr::Ascii("eballls"),
        dictgen::InsensitiveStr::Ascii("ebals"),
        dictgen::InsensitiveStr::Ascii("ebros"),
        dictgen::InsensitiveStr::Ascii("ebrowes"),
        dictgen::InsensitiveStr::Ascii("ebrowns"),
        dictgen::InsensitiveStr::Ascii("erone"),
        dictgen::InsensitiveStr::Ascii("esahdow"),
        dictgen::InsensitiveStr::Ascii("eshdaow"),
        dictgen::InsensitiveStr::Ascii("gptian"),
        dictgen::InsensitiveStr::Ascii("gptians"),
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("tmology"),
    ],
    values: &[
        &["year", "eyas"],
        &["years", "eyas"],
        &["years", "eyas"],
        &["eyeballs"],
        &["eyeballs"],
        &["eyeballs"],
        &["eyebrows"],
        &["eyebrows"],
        &["eyebrows"],
        &["everyone"],
        &["eyeshadow"],
        &["eyeshadow"],
        &["egyptian"],
        &["egyptians"],
        &["yet"],
        &["etymology"],
    ],
    range: 1..=8,
};

static WORD_EX_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_EX_CHILDREN),
    value: None,
};

static WORD_EX_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_EXA_NODE),
    None,
    Some(&WORD_EXC_NODE),
    None,
    Some(&WORD_EXE_NODE),
    None,
    None,
    Some(&WORD_EXH_NODE),
    Some(&WORD_EXI_NODE),
    None,
    None,
    Some(&WORD_EXL_NODE),
    Some(&WORD_EXM_NODE),
    Some(&WORD_EXN_NODE),
    Some(&WORD_EXO_NODE),
    Some(&WORD_EXP_NODE),
    None,
    Some(&WORD_EXR_NODE),
    Some(&WORD_EXS_NODE),
    Some(&WORD_EXT_NODE),
    Some(&WORD_EXU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_EXU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXU_CHILDREN),
    value: None,
};

pub static WORD_EXU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("berent"),
        dictgen::InsensitiveStr::Ascii("cuted"),
        dictgen::InsensitiveStr::Ascii("rpt"),
        dictgen::InsensitiveStr::Ascii("rpts"),
    ],
    values: &[&["exuberant"], &["executed"], &["excerpt"], &["excerpts"]],
    range: 3..=6,
};

static WORD_EXT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_EXT_CHILDREN),
    value: None,
};

static WORD_EXT_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_EXTA_NODE),
    None,
    None,
    None,
    Some(&WORD_EXTE_NODE),
    None,
    None,
    None,
    Some(&WORD_EXTI_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_EXTN_NODE),
    Some(&WORD_EXTO_NODE),
    None,
    None,
    Some(&WORD_EXTR_NODE),
    None,
    None,
    Some(&WORD_EXTU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_EXTU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXTU_CHILDREN),
    value: None,
};

pub static WORD_EXTU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("rd"),
        dictgen::InsensitiveStr::Ascii("rde"),
        dictgen::InsensitiveStr::Ascii("rded"),
        dictgen::InsensitiveStr::Ascii("rdes"),
        dictgen::InsensitiveStr::Ascii("rding"),
    ],
    values: &[
        &["extrude"],
        &["extrude"],
        &["extruded"],
        &["extrudes"],
        &["extruding"],
    ],
    range: 2..=5,
};

static WORD_EXTR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_EXTR_CHILDREN),
    value: None,
};

static WORD_EXTR_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_EXTRA_NODE),
    None,
    None,
    None,
    Some(&WORD_EXTRE_NODE),
    None,
    None,
    None,
    Some(&WORD_EXTRI_NODE),
    None,
    None,
    None,
    Some(&WORD_EXTRM_NODE),
    None,
    Some(&WORD_EXTRO_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_EXTRU_NODE),
    None,
    None,
    None,
    Some(&WORD_EXTRY_NODE),
    None,
];

static WORD_EXTRY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXTRY_CHILDREN),
    value: Some(&["entry"]),
};

pub static WORD_EXTRY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[],
    values: &[],
    range: 0..=0,
};

static WORD_EXTRU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXTRU_CHILDREN),
    value: None,
};

pub static WORD_EXTRU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ciating")],
    values: &[&["excruciating"]],
    range: 7..=7,
};

static WORD_EXTRO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXTRO_CHILDREN),
    value: None,
};

pub static WORD_EXTRO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ardinarily"),
        dictgen::InsensitiveStr::Ascii("ardinary"),
        dictgen::InsensitiveStr::Ascii("dinary"),
        dictgen::InsensitiveStr::Ascii("polate"),
        dictgen::InsensitiveStr::Ascii("rdinarily"),
        dictgen::InsensitiveStr::Ascii("rdinary"),
        dictgen::InsensitiveStr::Ascii("tion"),
    ],
    values: &[
        &["extraordinarily"],
        &["extraordinary"],
        &["extraordinary"],
        &["extrapolate"],
        &["extraordinarily"],
        &["extraordinary"],
        &["extortion"],
    ],
    range: 4..=10,
};

static WORD_EXTRM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXTRM_CHILDREN),
    value: None,
};

pub static WORD_EXTRM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ities")],
    values: &[&["extremities"]],
    range: 5..=5,
};

static WORD_EXTRI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXTRI_CHILDREN),
    value: None,
};

pub static WORD_EXTRI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("me"),
        dictgen::InsensitiveStr::Ascii("mely"),
        dictgen::InsensitiveStr::Ascii("mists"),
        dictgen::InsensitiveStr::Ascii("mly"),
        dictgen::InsensitiveStr::Ascii("nsict"),
    ],
    values: &[
        &["extreme"],
        &["extremely"],
        &["extremists"],
        &["extremely"],
        &["extrinsic"],
    ],
    range: 2..=5,
};

static WORD_EXTRE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXTRE_CHILDREN),
    value: None,
};

pub static WORD_EXTRE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("am"),
        dictgen::InsensitiveStr::Ascii("amely"),
        dictgen::InsensitiveStr::Ascii("amily"),
        dictgen::InsensitiveStr::Ascii("amly"),
        dictgen::InsensitiveStr::Ascii("ams"),
        dictgen::InsensitiveStr::Ascii("em"),
        dictgen::InsensitiveStr::Ascii("emly"),
        dictgen::InsensitiveStr::Ascii("ems"),
        dictgen::InsensitiveStr::Ascii("m"),
        dictgen::InsensitiveStr::Ascii("maly"),
        dictgen::InsensitiveStr::Ascii("maste"),
        dictgen::InsensitiveStr::Ascii("meley"),
        dictgen::InsensitiveStr::Ascii("melly"),
        dictgen::InsensitiveStr::Ascii("meme"),
        dictgen::InsensitiveStr::Ascii("memely"),
        dictgen::InsensitiveStr::Ascii("memly"),
        dictgen::InsensitiveStr::Ascii("meophile"),
        dictgen::InsensitiveStr::Ascii("mers"),
        dictgen::InsensitiveStr::Ascii("mests"),
        dictgen::InsensitiveStr::Ascii("mised"),
        dictgen::InsensitiveStr::Ascii("misim"),
        dictgen::InsensitiveStr::Ascii("misme"),
        dictgen::InsensitiveStr::Ascii("mistas"),
        dictgen::InsensitiveStr::Ascii("miste"),
        dictgen::InsensitiveStr::Ascii("mistes"),
        dictgen::InsensitiveStr::Ascii("mistisk"),
        dictgen::InsensitiveStr::Ascii("mitys"),
        dictgen::InsensitiveStr::Ascii("mley"),
        dictgen::InsensitiveStr::Ascii("mly"),
        dictgen::InsensitiveStr::Ascii("ms"),
        dictgen::InsensitiveStr::Ascii("nal"),
        dictgen::InsensitiveStr::Ascii("nally"),
        dictgen::InsensitiveStr::Ascii("naly"),
    ],
    values: &[
        &["extreme"],
        &["extremely"],
        &["extremely"],
        &["extremely"],
        &["extremes"],
        &["extreme"],
        &["extremely"],
        &["extremes"],
        &["extremum", "extreme"],
        &["extremely"],
        &["extremes"],
        &["extremely"],
        &["extremely"],
        &["extreme"],
        &["extremely"],
        &["extremely"],
        &["extremophile"],
        &["extremes"],
        &["extremists"],
        &["extremes"],
        &["extremism"],
        &["extremes"],
        &["extremists"],
        &["extremes"],
        &["extremists"],
        &["extremists"],
        &["extremities"],
        &["extremely"],
        &["extremely"],
        &["extremes", "extrema"],
        &["external"],
        &["externally"],
        &["externally"],
    ],
    range: 1..=8,
};

static WORD_EXTRA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXTRA_CHILDREN),
    value: None,
};

pub static WORD_EXTRA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("c"),
        dictgen::InsensitiveStr::Ascii("ccion"),
        dictgen::InsensitiveStr::Ascii("ced"),
        dictgen::InsensitiveStr::Ascii("cing"),
        dictgen::InsensitiveStr::Ascii("cter"),
        dictgen::InsensitiveStr::Ascii("ctet"),
        dictgen::InsensitiveStr::Ascii("ctin"),
        dictgen::InsensitiveStr::Ascii("ctino"),
        dictgen::InsensitiveStr::Ascii("ctins"),
        dictgen::InsensitiveStr::Ascii("ctivo"),
        dictgen::InsensitiveStr::Ascii("ctnow"),
        dictgen::InsensitiveStr::Ascii("cto"),
        dictgen::InsensitiveStr::Ascii("diction"),
        dictgen::InsensitiveStr::Ascii("dtion"),
        dictgen::InsensitiveStr::Ascii("enous"),
        dictgen::InsensitiveStr::Ascii("gavant"),
        dictgen::InsensitiveStr::Ascii("nous"),
        dictgen::InsensitiveStr::Ascii("odrinarily"),
        dictgen::InsensitiveStr::Ascii("odrinary"),
        dictgen::InsensitiveStr::Ascii("ordianry"),
        dictgen::InsensitiveStr::Ascii("ordiary"),
        dictgen::InsensitiveStr::Ascii("ordinair"),
        dictgen::InsensitiveStr::Ascii("ordinairily"),
        dictgen::InsensitiveStr::Ascii("ordinairly"),
        dictgen::InsensitiveStr::Ascii("ordinairy"),
        dictgen::InsensitiveStr::Ascii("ordinaly"),
        dictgen::InsensitiveStr::Ascii("ordinarely"),
        dictgen::InsensitiveStr::Ascii("ordinarilly"),
        dictgen::InsensitiveStr::Ascii("ordinarly"),
        dictgen::InsensitiveStr::Ascii("ordinaryly"),
        dictgen::InsensitiveStr::Ascii("ordinay"),
        dictgen::InsensitiveStr::Ascii("oridnary"),
        dictgen::InsensitiveStr::Ascii("palate"),
        dictgen::InsensitiveStr::Ascii("ploate"),
        dictgen::InsensitiveStr::Ascii("polant"),
        dictgen::InsensitiveStr::Ascii("polare"),
        dictgen::InsensitiveStr::Ascii("pole"),
        dictgen::InsensitiveStr::Ascii("polerat"),
        dictgen::InsensitiveStr::Ascii("poliate"),
        dictgen::InsensitiveStr::Ascii("polite"),
        dictgen::InsensitiveStr::Ascii("poloate"),
        dictgen::InsensitiveStr::Ascii("pulate"),
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("ted"),
        dictgen::InsensitiveStr::Ascii("terrestial"),
        dictgen::InsensitiveStr::Ascii("terrestials"),
        dictgen::InsensitiveStr::Ascii("tes"),
        dictgen::InsensitiveStr::Ascii("ting"),
        dictgen::InsensitiveStr::Ascii("tion"),
        dictgen::InsensitiveStr::Ascii("tor"),
        dictgen::InsensitiveStr::Ascii("tors"),
        dictgen::InsensitiveStr::Ascii("ts"),
        dictgen::InsensitiveStr::Ascii("vagent"),
        dictgen::InsensitiveStr::Ascii("vagina"),
        dictgen::InsensitiveStr::Ascii("vegant"),
        dictgen::InsensitiveStr::Ascii("version"),
        dictgen::InsensitiveStr::Ascii("vigant"),
        dictgen::InsensitiveStr::Ascii("vogant"),
        dictgen::InsensitiveStr::Ascii("xt"),
        dictgen::InsensitiveStr::Ascii("xted"),
        dictgen::InsensitiveStr::Ascii("xting"),
        dictgen::InsensitiveStr::Ascii("xtors"),
        dictgen::InsensitiveStr::Ascii("xts"),
    ],
    values: &[
        &["extract"],
        &["extraction"],
        &["extracted"],
        &["extracting"],
        &["extractor"],
        &["extracted"],
        &["extraction"],
        &["extracting"],
        &["extractions"],
        &["extraction"],
        &["extraction"],
        &["extraction"],
        &["extradition"],
        &["extraction"],
        &["extraneous"],
        &["extravagant"],
        &["extraneous"],
        &["extraordinarily"],
        &["extraordinary"],
        &["extraordinary"],
        &["extraordinary"],
        &["extraordinary"],
        &["extraordinarily"],
        &["extraordinarily"],
        &["extraordinary"],
        &["extraordinary"],
        &["extraordinarily"],
        &["extraordinary"],
        &["extraordinary", "extraordinarily"],
        &["extraordinarily"],
        &["extraordinary"],
        &["extraordinary"],
        &["extrapolate"],
        &["extrapolate"],
        &["extrapolate"],
        &["extrapolate"],
        &["extrapolate"],
        &["extrapolate"],
        &["extrapolate"],
        &["extrapolate"],
        &["extrapolate"],
        &["extrapolate"],
        &["extract"],
        &["extracted"],
        &["extraterrestrial"],
        &["extraterrestrials"],
        &["extracts"],
        &["exctracting", "extracting"],
        &["extraction"],
        &["extractor"],
        &["extractors"],
        &["extracts"],
        &["extravagant"],
        &["extravagant"],
        &["extravagant"],
        &["extroversion"],
        &["extravagant"],
        &["extravagant"],
        &["extract"],
        &["extracted"],
        &["extracting"],
        &["extractors"],
        &["extracts"],
    ],
    range: 1..=11,
};

static WORD_EXTO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXTO_CHILDREN),
    value: None,
};

pub static WORD_EXTO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ics"),
        dictgen::InsensitiveStr::Ascii("rtin"),
    ],
    values: &[&["exotics"], &["extortion"]],
    range: 3..=4,
};

static WORD_EXTN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXTN_CHILDREN),
    value: None,
};

pub static WORD_EXTN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("esion")],
    values: &[&["extension"]],
    range: 5..=5,
};

static WORD_EXTI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXTI_CHILDREN),
    value: None,
};

pub static WORD_EXTI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("mate"),
        dictgen::InsensitiveStr::Ascii("mated"),
        dictgen::InsensitiveStr::Ascii("mates"),
        dictgen::InsensitiveStr::Ascii("mating"),
        dictgen::InsensitiveStr::Ascii("mation"),
        dictgen::InsensitiveStr::Ascii("mations"),
        dictgen::InsensitiveStr::Ascii("mator"),
        dictgen::InsensitiveStr::Ascii("mators"),
        dictgen::InsensitiveStr::Ascii("ng"),
        dictgen::InsensitiveStr::Ascii("nt"),
        dictgen::InsensitiveStr::Ascii("st"),
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("ted"),
        dictgen::InsensitiveStr::Ascii("ting"),
        dictgen::InsensitiveStr::Ascii("ts"),
    ],
    values: &[
        &["estimate"],
        &["estimated"],
        &["estimates"],
        &["estimating"],
        &["estimation"],
        &["estimations"],
        &["estimator"],
        &["estimators"],
        &["existing", "exiting", "texting"],
        &["extinct", "extant"],
        &["exist"],
        &["exit"],
        &["excited", "exited"],
        &["exciting", "exiting"],
        &["exits", "excites"],
    ],
    range: 1..=7,
};

static WORD_EXTE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_EXTE_CHILDREN),
    value: None,
};

static WORD_EXTE_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    None,
    Some(&WORD_EXTED_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_EXTEM_NODE),
    Some(&WORD_EXTEN_NODE),
    None,
    Some(&WORD_EXTEP_NODE),
    None,
    Some(&WORD_EXTER_NODE),
    Some(&WORD_EXTES_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_EXTES_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXTES_CHILDREN),
    value: None,
};

pub static WORD_EXTES_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ion"),
        dictgen::InsensitiveStr::Ascii("ions"),
        dictgen::InsensitiveStr::Ascii("nion"),
        dictgen::InsensitiveStr::Ascii("nions"),
    ],
    values: &[
        &["extension"],
        &["extensions"],
        &["extension"],
        &["extensions"],
    ],
    range: 3..=5,
};

static WORD_EXTER_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXTER_CHILDREN),
    value: None,
};

pub static WORD_EXTER_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("al"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("eme"),
        dictgen::InsensitiveStr::Ascii("ioara"),
        dictgen::InsensitiveStr::Ascii("ioare"),
        dictgen::InsensitiveStr::Ascii("iour"),
        dictgen::InsensitiveStr::Ascii("mal"),
        dictgen::InsensitiveStr::Ascii("mally"),
        dictgen::InsensitiveStr::Ascii("me"),
        dictgen::InsensitiveStr::Ascii("mely"),
        dictgen::InsensitiveStr::Ascii("mest"),
        dictgen::InsensitiveStr::Ascii("mism"),
        dictgen::InsensitiveStr::Ascii("mist"),
        dictgen::InsensitiveStr::Ascii("mists"),
        dictgen::InsensitiveStr::Ascii("mly"),
        dictgen::InsensitiveStr::Ascii("mporaneous"),
        dictgen::InsensitiveStr::Ascii("naly"),
        dictgen::InsensitiveStr::Ascii("nel"),
        dictgen::InsensitiveStr::Ascii("nelly"),
        dictgen::InsensitiveStr::Ascii("nels"),
    ],
    values: &[
        &["external"],
        &["exerted"],
        &["extreme"],
        &["exterior"],
        &["exterior"],
        &["exterior"],
        &["external", "extremal"],
        &["externally"],
        &["extreme"],
        &["extremely"],
        &["extremest"],
        &["extremism"],
        &["extremist"],
        &["extremists"],
        &["extremely"],
        &["extemporaneous"],
        &["externally"],
        &["external"],
        &["externally"],
        &["externals"],
    ],
    range: 2..=10,
};

static WORD_EXTEP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXTEP_CHILDREN),
    value: None,
};

pub static WORD_EXTEP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ect"),
        dictgen::InsensitiveStr::Ascii("ecting"),
        dictgen::InsensitiveStr::Ascii("ects"),
    ],
    values: &[&["expect"], &["expecting"], &["expects"]],
    range: 3..=6,
};

static WORD_EXTEN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXTEN_CHILDREN),
    value: Some(&["extent"]),
};

pub static WORD_EXTEN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("al"),
        dictgen::InsensitiveStr::Ascii("ally"),
        dictgen::InsensitiveStr::Ascii("dded"),
        dictgen::InsensitiveStr::Ascii("des"),
        dictgen::InsensitiveStr::Ascii("det"),
        dictgen::InsensitiveStr::Ascii("dos"),
        dictgen::InsensitiveStr::Ascii("dsions"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("eded"),
        dictgen::InsensitiveStr::Ascii("ion"),
        dictgen::InsensitiveStr::Ascii("ions"),
        dictgen::InsensitiveStr::Ascii("isble"),
        dictgen::InsensitiveStr::Ascii("nsions"),
        dictgen::InsensitiveStr::Ascii("sability"),
        dictgen::InsensitiveStr::Ascii("siable"),
        dictgen::InsensitiveStr::Ascii("sibity"),
        dictgen::InsensitiveStr::Ascii("sie"),
        dictgen::InsensitiveStr::Ascii("silbe"),
        dictgen::InsensitiveStr::Ascii("siones"),
        dictgen::InsensitiveStr::Ascii("sis"),
        dictgen::InsensitiveStr::Ascii("sivelly"),
        dictgen::InsensitiveStr::Ascii("sivley"),
        dictgen::InsensitiveStr::Ascii("sivly"),
        dictgen::InsensitiveStr::Ascii("son"),
        dictgen::InsensitiveStr::Ascii("stion"),
        dictgen::InsensitiveStr::Ascii("stions"),
        dictgen::InsensitiveStr::Ascii("ted"),
        dictgen::InsensitiveStr::Ascii("tion"),
        dictgen::InsensitiveStr::Ascii("tions"),
    ],
    values: &[
        &["external"],
        &["externally"],
        &["extended"],
        &["extends"],
        &["extended"],
        &["extends"],
        &["extensions"],
        &["extended"],
        &["extended"],
        &["extension"],
        &["extension", "extensions"],
        &["extensible"],
        &["extensions"],
        &["extensibility"],
        &["extensible"],
        &["extensibility"],
        &["extensive"],
        &["extensible"],
        &["extensions"],
        &["extensions"],
        &["extensively"],
        &["extensively"],
        &["extensively"],
        &["extension"],
        &["extension"],
        &["extensions"],
        &["extended"],
        &["extension"],
        &["extensions"],
    ],
    range: 2..=8,
};

static WORD_EXTEM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXTEM_CHILDREN),
    value: None,
};

pub static WORD_EXTEM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ely")],
    values: &[&["extremely"]],
    range: 3..=3,
};

static WORD_EXTED_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXTED_CHILDREN),
    value: Some(&["extend"]),
};

pub static WORD_EXTED_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("er"),
        dictgen::InsensitiveStr::Ascii("ers"),
        dictgen::InsensitiveStr::Ascii("n"),
        dictgen::InsensitiveStr::Ascii("ned"),
        dictgen::InsensitiveStr::Ascii("ner"),
        dictgen::InsensitiveStr::Ascii("ners"),
        dictgen::InsensitiveStr::Ascii("ns"),
    ],
    values: &[
        &["extended"],
        &["extender"],
        &["extenders"],
        &["extend"],
        &["extended"],
        &["extender"],
        &["extenders"],
        &["extends"],
    ],
    range: 1..=4,
};

static WORD_EXTA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXTA_CHILDREN),
    value: None,
};

pub static WORD_EXTA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ct"),
        dictgen::InsensitiveStr::Ascii("ction"),
        dictgen::InsensitiveStr::Ascii("ctly"),
        dictgen::InsensitiveStr::Ascii("cy"),
        dictgen::InsensitiveStr::Ascii("rnal"),
        dictgen::InsensitiveStr::Ascii("rnally"),
        dictgen::InsensitiveStr::Ascii("tic"),
    ],
    values: &[
        &["extract", "exact"],
        &["extraction"],
        &["exactly"],
        &["ecstasy"],
        &["external"],
        &["externally"],
        &["ecstatic"],
    ],
    range: 2..=6,
};

static WORD_EXS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXS_CHILDREN),
    value: None,
};

pub static WORD_EXS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ist"),
        dictgen::InsensitiveStr::Ascii("istence"),
        dictgen::InsensitiveStr::Ascii("istent"),
        dictgen::InsensitiveStr::Ascii("isting"),
        dictgen::InsensitiveStr::Ascii("ists"),
        dictgen::InsensitiveStr::Ascii("it"),
        dictgen::InsensitiveStr::Ascii("itance"),
        dictgen::InsensitiveStr::Ascii("ited"),
        dictgen::InsensitiveStr::Ascii("itence"),
        dictgen::InsensitiveStr::Ascii("itent"),
        dictgen::InsensitiveStr::Ascii("iting"),
        dictgen::InsensitiveStr::Ascii("its"),
        dictgen::InsensitiveStr::Ascii("pect"),
        dictgen::InsensitiveStr::Ascii("pected"),
        dictgen::InsensitiveStr::Ascii("pectedly"),
        dictgen::InsensitiveStr::Ascii("pecting"),
        dictgen::InsensitiveStr::Ascii("pects"),
        dictgen::InsensitiveStr::Ascii("pense"),
        dictgen::InsensitiveStr::Ascii("pensed"),
        dictgen::InsensitiveStr::Ascii("penses"),
        dictgen::InsensitiveStr::Ascii("tacy"),
        dictgen::InsensitiveStr::Ascii("ted"),
        dictgen::InsensitiveStr::Ascii("ting"),
        dictgen::InsensitiveStr::Ascii("tream"),
        dictgen::InsensitiveStr::Ascii("ts"),
    ],
    values: &[
        &["exists", "exist"],
        &["existence"],
        &["existent"],
        &["existing"],
        &["exists"],
        &["exist", "exit"],
        &["existence"],
        &["existed", "excited"],
        &["existence"],
        &["existent"],
        &["existing"],
        &["exists", "exist"],
        &["expect"],
        &["expected"],
        &["expectedly"],
        &["expecting"],
        &["expects"],
        &["expense"],
        &["expensed"],
        &["expenses"],
        &["ecstasy"],
        &["existed"],
        &["existing"],
        &["extreme"],
        &["exists"],
    ],
    range: 2..=8,
};

static WORD_EXR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXR_CHILDREN),
    value: None,
};

pub static WORD_EXR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("a"),
        dictgen::InsensitiveStr::Ascii("act"),
        dictgen::InsensitiveStr::Ascii("ension"),
        dictgen::InsensitiveStr::Ascii("ensions"),
        dictgen::InsensitiveStr::Ascii("essed"),
        dictgen::InsensitiveStr::Ascii("ession"),
    ],
    values: &[
        &["extra"],
        &["extract"],
        &["extension"],
        &["extensions"],
        &["expressed"],
        &["expression"],
    ],
    range: 1..=7,
};

static WORD_EXP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_EXP_CHILDREN),
    value: None,
};

static WORD_EXP_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_EXPA_NODE),
    None,
    Some(&WORD_EXPC_NODE),
    None,
    Some(&WORD_EXPE_NODE),
    None,
    None,
    None,
    Some(&WORD_EXPI_NODE),
    None,
    None,
    Some(&WORD_EXPL_NODE),
    None,
    None,
    Some(&WORD_EXPO_NODE),
    Some(&WORD_EXPP_NODE),
    None,
    Some(&WORD_EXPR_NODE),
    None,
    Some(&WORD_EXPT_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_EXPT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXPT_CHILDREN),
    value: None,
};

pub static WORD_EXPT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ected")],
    values: &[&["expected"]],
    range: 5..=5,
};

static WORD_EXPR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXPR_CHILDREN),
    value: None,
};

pub static WORD_EXPR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ensive"),
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("esed"),
        dictgen::InsensitiveStr::Ascii("eses"),
        dictgen::InsensitiveStr::Ascii("esing"),
        dictgen::InsensitiveStr::Ascii("esion"),
        dictgen::InsensitiveStr::Ascii("esions"),
        dictgen::InsensitiveStr::Ascii("esison"),
        dictgen::InsensitiveStr::Ascii("essable"),
        dictgen::InsensitiveStr::Ascii("esscoin"),
        dictgen::InsensitiveStr::Ascii("esse"),
        dictgen::InsensitiveStr::Ascii("essens"),
        dictgen::InsensitiveStr::Ascii("essie"),
        dictgen::InsensitiveStr::Ascii("essief"),
        dictgen::InsensitiveStr::Ascii("essin"),
        dictgen::InsensitiveStr::Ascii("essino"),
        dictgen::InsensitiveStr::Ascii("essiong"),
        dictgen::InsensitiveStr::Ascii("essivos"),
        dictgen::InsensitiveStr::Ascii("essley"),
        dictgen::InsensitiveStr::Ascii("esso"),
        dictgen::InsensitiveStr::Ascii("esss"),
        dictgen::InsensitiveStr::Ascii("esssion"),
        dictgen::InsensitiveStr::Ascii("esssions"),
        dictgen::InsensitiveStr::Ascii("esssive"),
        dictgen::InsensitiveStr::Ascii("essview"),
        dictgen::InsensitiveStr::Ascii("essy"),
        dictgen::InsensitiveStr::Ascii("iation"),
        dictgen::InsensitiveStr::Ascii("ience"),
        dictgen::InsensitiveStr::Ascii("ienced"),
        dictgen::InsensitiveStr::Ascii("iences"),
        dictgen::InsensitiveStr::Ascii("ies"),
        dictgen::InsensitiveStr::Ascii("imental"),
        dictgen::InsensitiveStr::Ascii("opiate"),
        dictgen::InsensitiveStr::Ascii("opiated"),
        dictgen::InsensitiveStr::Ascii("opiates"),
        dictgen::InsensitiveStr::Ascii("opiating"),
        dictgen::InsensitiveStr::Ascii("opiation"),
        dictgen::InsensitiveStr::Ascii("ot"),
        dictgen::InsensitiveStr::Ascii("oted"),
        dictgen::InsensitiveStr::Ascii("oting"),
        dictgen::InsensitiveStr::Ascii("ots"),
        dictgen::InsensitiveStr::Ascii("ted"),
    ],
    values: &[
        &["expressive"],
        &["express"],
        &["expressed"],
        &["express", "expresses"],
        &["expressing"],
        &["expression"],
        &["expression", "expressions"],
        &["expressions"],
        &["expressible"],
        &["expression"],
        &["expressive"],
        &["expresses"],
        &["expressive"],
        &["expressive"],
        &["expression"],
        &["expression"],
        &["expressing", "expression"],
        &["expressions"],
        &["expressly"],
        &["espresso"],
        &["expresses", "express"],
        &["expression"],
        &["expressions"],
        &["expressive"],
        &["expressive"],
        &["expressly"],
        &["expiration"],
        &["experience"],
        &["experienced"],
        &["experiences"],
        &["expires"],
        &["experimental"],
        &["expropriate"],
        &["expropriated"],
        &["expropriates"],
        &["expropriating"],
        &["expropriation"],
        &["export"],
        &["exported"],
        &["exporting"],
        &["exports"],
        &["exported"],
    ],
    range: 2..=8,
};

static WORD_EXPP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXPP_CHILDREN),
    value: None,
};

pub static WORD_EXPP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ort"),
        dictgen::InsensitiveStr::Ascii("ressed"),
    ],
    values: &[&["export"], &["expressed"]],
    range: 3..=6,
};

static WORD_EXPO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXPO_CHILDREN),
    value: None,
};

pub static WORD_EXPO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ch"),
        dictgen::InsensitiveStr::Ascii("dential"),
        dictgen::InsensitiveStr::Ascii("dentially"),
        dictgen::InsensitiveStr::Ascii("dition"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("ent"),
        dictgen::InsensitiveStr::Ascii("ential"),
        dictgen::InsensitiveStr::Ascii("entially"),
        dictgen::InsensitiveStr::Ascii("entntial"),
        dictgen::InsensitiveStr::Ascii("ert"),
        dictgen::InsensitiveStr::Ascii("erted"),
        dictgen::InsensitiveStr::Ascii("it"),
        dictgen::InsensitiveStr::Ascii("itation"),
        dictgen::InsensitiveStr::Ascii("ited"),
        dictgen::InsensitiveStr::Ascii("its"),
        dictgen::InsensitiveStr::Ascii("lde"),
        dictgen::InsensitiveStr::Ascii("ldes"),
        dictgen::InsensitiveStr::Ascii("lding"),
        dictgen::InsensitiveStr::Ascii("lit"),
        dictgen::InsensitiveStr::Ascii("litation"),
        dictgen::InsensitiveStr::Ascii("litative"),
        dictgen::InsensitiveStr::Ascii("lited"),
        dictgen::InsensitiveStr::Ascii("liting"),
        dictgen::InsensitiveStr::Ascii("lits"),
        dictgen::InsensitiveStr::Ascii("lsion"),
        dictgen::InsensitiveStr::Ascii("lsions"),
        dictgen::InsensitiveStr::Ascii("lsive"),
        dictgen::InsensitiveStr::Ascii("lsives"),
        dictgen::InsensitiveStr::Ascii("nant"),
        dictgen::InsensitiveStr::Ascii("nantation"),
        dictgen::InsensitiveStr::Ascii("nantial"),
        dictgen::InsensitiveStr::Ascii("nantially"),
        dictgen::InsensitiveStr::Ascii("nantialy"),
        dictgen::InsensitiveStr::Ascii("nants"),
        dictgen::InsensitiveStr::Ascii("nencial"),
        dictgen::InsensitiveStr::Ascii("nencially"),
        dictgen::InsensitiveStr::Ascii("nental"),
        dictgen::InsensitiveStr::Ascii("nentation"),
        dictgen::InsensitiveStr::Ascii("nentialy"),
        dictgen::InsensitiveStr::Ascii("nentiel"),
        dictgen::InsensitiveStr::Ascii("nentiell"),
        dictgen::InsensitiveStr::Ascii("nentiella"),
        dictgen::InsensitiveStr::Ascii("netial"),
        dictgen::InsensitiveStr::Ascii("ression"),
        dictgen::InsensitiveStr::Ascii("rs"),
        dictgen::InsensitiveStr::Ascii("rtas"),
        dictgen::InsensitiveStr::Ascii("rtes"),
        dictgen::InsensitiveStr::Ascii("rtet"),
        dictgen::InsensitiveStr::Ascii("rtfs"),
        dictgen::InsensitiveStr::Ascii("sees"),
        dictgen::InsensitiveStr::Ascii("sicion"),
        dictgen::InsensitiveStr::Ascii("sitivo"),
        dictgen::InsensitiveStr::Ascii("sito"),
        dictgen::InsensitiveStr::Ascii("sse"),
        dictgen::InsensitiveStr::Ascii("tition"),
    ],
    values: &[
        &["epoch"],
        &["exponential"],
        &["exponentially"],
        &["exposition"],
        &["exposed"],
        &["exponent"],
        &["exponential"],
        &["exponentially"],
        &["exponential"],
        &["export", "expert"],
        &["exported"],
        &["exploit"],
        &["exploitation"],
        &["exploited"],
        &["exploits"],
        &["explode"],
        &["explodes"],
        &["exploding"],
        &["exploit"],
        &["exploitation"],
        &["exploitative"],
        &["exploited"],
        &["exploiting"],
        &["exploits"],
        &["explosion"],
        &["explosions"],
        &["explosive"],
        &["explosives"],
        &["exponent"],
        &["exponentiation"],
        &["exponential"],
        &["exponentially"],
        &["exponentially"],
        &["exponents"],
        &["exponential"],
        &["exponentially"],
        &["exponential"],
        &["exponentiation"],
        &["exponentially"],
        &["exponential"],
        &["exponential"],
        &["exponential"],
        &["exponential"],
        &["expression"],
        &["exports"],
        &["exports"],
        &["exports"],
        &["exported", "exporter"],
        &["exports"],
        &["exposes"],
        &["exposition"],
        &["exposition"],
        &["exposition"],
        &["exposes"],
        &["exposition"],
    ],
    range: 2..=9,
};

static WORD_EXPL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_EXPL_CHILDREN),
    value: None,
};

static WORD_EXPL_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_EXPLA_NODE),
    None,
    Some(&WORD_EXPLC_NODE),
    None,
    Some(&WORD_EXPLE_NODE),
    None,
    None,
    None,
    Some(&WORD_EXPLI_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_EXPLO_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_EXPLU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_EXPLU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXPLU_CHILDREN),
    value: None,
};

pub static WORD_EXPLU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("sions")],
    values: &[&["explosions"]],
    range: 5..=5,
};

static WORD_EXPLO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXPLO_CHILDREN),
    value: None,
};

pub static WORD_EXPLO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("deds"),
        dictgen::InsensitiveStr::Ascii("die"),
        dictgen::InsensitiveStr::Ascii("ds"),
        dictgen::InsensitiveStr::Ascii("iding"),
        dictgen::InsensitiveStr::Ascii("int"),
        dictgen::InsensitiveStr::Ascii("itaion"),
        dictgen::InsensitiveStr::Ascii("itaiton"),
        dictgen::InsensitiveStr::Ascii("itatie"),
        dictgen::InsensitiveStr::Ascii("itating"),
        dictgen::InsensitiveStr::Ascii("ites"),
        dictgen::InsensitiveStr::Ascii("ition"),
        dictgen::InsensitiveStr::Ascii("itions"),
        dictgen::InsensitiveStr::Ascii("ititive"),
        dictgen::InsensitiveStr::Ascii("nation"),
        dictgen::InsensitiveStr::Ascii("racion"),
        dictgen::InsensitiveStr::Ascii("rare"),
        dictgen::InsensitiveStr::Ascii("rarea"),
        dictgen::InsensitiveStr::Ascii("rating"),
        dictgen::InsensitiveStr::Ascii("rerers"),
        dictgen::InsensitiveStr::Ascii("reres"),
        dictgen::InsensitiveStr::Ascii("rtation"),
        dictgen::InsensitiveStr::Ascii("se"),
        dictgen::InsensitiveStr::Ascii("sie"),
        dictgen::InsensitiveStr::Ascii("sin"),
        dictgen::InsensitiveStr::Ascii("siones"),
        dictgen::InsensitiveStr::Ascii("sivas"),
        dictgen::InsensitiveStr::Ascii("ssion"),
        dictgen::InsensitiveStr::Ascii("ssive"),
        dictgen::InsensitiveStr::Ascii("svies"),
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("tacion"),
        dictgen::InsensitiveStr::Ascii("tation"),
        dictgen::InsensitiveStr::Ascii("ted"),
        dictgen::InsensitiveStr::Ascii("tiation"),
        dictgen::InsensitiveStr::Ascii("tiative"),
        dictgen::InsensitiveStr::Ascii("tied"),
        dictgen::InsensitiveStr::Ascii("ting"),
        dictgen::InsensitiveStr::Ascii("tions"),
    ],
    values: &[
        &["explodes"],
        &["explode"],
        &["explodes"],
        &["exploiting"],
        &["exploit"],
        &["exploitation"],
        &["exploitation"],
        &["exploitative"],
        &["exploitation"],
        &["exploits"],
        &["exploiting", "explosion", "exploitation", "exploit"],
        &["explosions", "exploitations", "exploits"],
        &["exploitative"],
        &["exploration"],
        &["exploration"],
        &["explorer"],
        &["explorer"],
        &["exploration"],
        &["explorers"],
        &["explorers"],
        &["exploitation"],
        &["explodes"],
        &["explosive"],
        &["explosions"],
        &["explosions"],
        &["explosives"],
        &["explosions"],
        &["explosives"],
        &["explosives"],
        &["exploit", "explore"],
        &["exploration"],
        &["exploitation", "exploration"],
        &["explode"],
        &["exploitation"],
        &["exploitative"],
        &["exploited"],
        &["exploiting", "exploring"],
        &["explosions"],
    ],
    range: 1..=7,
};

static WORD_EXPLI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXPLI_CHILDREN),
    value: None,
};

pub static WORD_EXPLI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("an"),
        dictgen::InsensitiveStr::Ascii("cat"),
        dictgen::InsensitiveStr::Ascii("catia"),
        dictgen::InsensitiveStr::Ascii("catie"),
        dictgen::InsensitiveStr::Ascii("catif"),
        dictgen::InsensitiveStr::Ascii("catii"),
        dictgen::InsensitiveStr::Ascii("cete"),
        dictgen::InsensitiveStr::Ascii("cetely"),
        dictgen::InsensitiveStr::Ascii("cetly"),
        dictgen::InsensitiveStr::Ascii("ciet"),
        dictgen::InsensitiveStr::Ascii("cilt"),
        dictgen::InsensitiveStr::Ascii("cilty"),
        dictgen::InsensitiveStr::Ascii("cite"),
        dictgen::InsensitiveStr::Ascii("cited"),
        dictgen::InsensitiveStr::Ascii("citelly"),
        dictgen::InsensitiveStr::Ascii("citely"),
        dictgen::InsensitiveStr::Ascii("citily"),
        dictgen::InsensitiveStr::Ascii("cits"),
        dictgen::InsensitiveStr::Ascii("city"),
        dictgen::InsensitiveStr::Ascii("cityly"),
        dictgen::InsensitiveStr::Ascii("ct"),
        dictgen::InsensitiveStr::Ascii("cte"),
        dictgen::InsensitiveStr::Ascii("ctely"),
        dictgen::InsensitiveStr::Ascii("ctily"),
        dictgen::InsensitiveStr::Ascii("ctly"),
        dictgen::InsensitiveStr::Ascii("cty"),
        dictgen::InsensitiveStr::Ascii("n"),
        dictgen::InsensitiveStr::Ascii("nation"),
        dictgen::InsensitiveStr::Ascii("nations"),
        dictgen::InsensitiveStr::Ascii("natory"),
        dictgen::InsensitiveStr::Ascii("ned"),
        dictgen::InsensitiveStr::Ascii("ns"),
        dictgen::InsensitiveStr::Ascii("ot"),
        dictgen::InsensitiveStr::Ascii("otation"),
        dictgen::InsensitiveStr::Ascii("oted"),
        dictgen::InsensitiveStr::Ascii("oting"),
        dictgen::InsensitiveStr::Ascii("ots"),
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("tictly"),
        dictgen::InsensitiveStr::Ascii("tit"),
        dictgen::InsensitiveStr::Ascii("tly"),
        dictgen::InsensitiveStr::Ascii("xitely"),
        dictgen::InsensitiveStr::Ascii("zit"),
        dictgen::InsensitiveStr::Ascii("zitly"),
    ],
    values: &[
        &["explain"],
        &["explicate"],
        &["explicit"],
        &["explicit"],
        &["explicit"],
        &["explicit"],
        &["explicit", "explicitly"],
        &["explicitly"],
        &["explicitly"],
        &["explicit"],
        &["explicit"],
        &["explicitly"],
        &["explicit", "explicitly"],
        &["explicit", "explicitly"],
        &["explicitly"],
        &["explicitly"],
        &["explicitly"],
        &["explicit"],
        &["explicitly"],
        &["explicitly"],
        &["explicit"],
        &["explicate", "explicit"],
        &["explicitly"],
        &["explicitly"],
        &["explicitly"],
        &["explicitly", "explicit"],
        &["explain"],
        &["explanation"],
        &["explanations"],
        &["explanatory"],
        &["explained"],
        &["explains"],
        &["exploit"],
        &["exploitation"],
        &["exploited"],
        &["exploiting"],
        &["exploits"],
        &["explicit"],
        &["explicitly"],
        &["explicit"],
        &["explicitly"],
        &["explicitly"],
        &["explicit"],
        &["explicitly"],
    ],
    range: 1..=7,
};

static WORD_EXPLE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXPLE_CHILDREN),
    value: None,
};

pub static WORD_EXPLE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cit"),
        dictgen::InsensitiveStr::Ascii("citely"),
        dictgen::InsensitiveStr::Ascii("citily"),
        dictgen::InsensitiveStr::Ascii("citly"),
        dictgen::InsensitiveStr::Ascii("nation"),
        dictgen::InsensitiveStr::Ascii("nations"),
        dictgen::InsensitiveStr::Ascii("natory"),
    ],
    values: &[
        &["explicit"],
        &["explicitly"],
        &["explicitly"],
        &["explicitly"],
        &["explanation"],
        &["explanations"],
        &["explanatory"],
    ],
    range: 3..=7,
};

static WORD_EXPLC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXPLC_CHILDREN),
    value: None,
};

pub static WORD_EXPLC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("it"),
        dictgen::InsensitiveStr::Ascii("itly"),
    ],
    values: &[&["explicit"], &["explicitly"]],
    range: 2..=4,
};

static WORD_EXPLA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXPLA_CHILDREN),
    value: None,
};

pub static WORD_EXPLA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ination"),
        dictgen::InsensitiveStr::Ascii("inations"),
        dictgen::InsensitiveStr::Ascii("inatory"),
        dictgen::InsensitiveStr::Ascii("ind"),
        dictgen::InsensitiveStr::Ascii("ines"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("inging"),
        dictgen::InsensitiveStr::Ascii("inig"),
        dictgen::InsensitiveStr::Ascii("intory"),
        dictgen::InsensitiveStr::Ascii("naiton"),
        dictgen::InsensitiveStr::Ascii("naitons"),
        dictgen::InsensitiveStr::Ascii("natin"),
        dictgen::InsensitiveStr::Ascii("ne"),
        dictgen::InsensitiveStr::Ascii("ned"),
        dictgen::InsensitiveStr::Ascii("nes"),
        dictgen::InsensitiveStr::Ascii("netary"),
        dictgen::InsensitiveStr::Ascii("netory"),
        dictgen::InsensitiveStr::Ascii("ning"),
        dictgen::InsensitiveStr::Ascii("nitary"),
        dictgen::InsensitiveStr::Ascii("notory"),
        dictgen::InsensitiveStr::Ascii("ntion"),
        dictgen::InsensitiveStr::Ascii("ntions"),
    ],
    values: &[
        &["explanation"],
        &["explanations"],
        &["explanatory"],
        &["explained"],
        &["explains"],
        &["explaining"],
        &["explaining"],
        &["explaining"],
        &["explanatory"],
        &["explanations", "explanation"],
        &["explanations"],
        &["explanations"],
        &["explain"],
        &["explained"],
        &["explains"],
        &["explanatory"],
        &["explanatory"],
        &["explaining"],
        &["explanatory"],
        &["explanatory"],
        &["explanation"],
        &["explanations"],
    ],
    range: 2..=8,
};

static WORD_EXPI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXPI_CHILDREN),
    value: None,
};

pub static WORD_EXPI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cit"),
        dictgen::InsensitiveStr::Ascii("citly"),
        dictgen::InsensitiveStr::Ascii("dentures"),
        dictgen::InsensitiveStr::Ascii("detion"),
        dictgen::InsensitiveStr::Ascii("dition"),
        dictgen::InsensitiveStr::Ascii("ditions"),
        dictgen::InsensitiveStr::Ascii("erence"),
        dictgen::InsensitiveStr::Ascii("erenced"),
        dictgen::InsensitiveStr::Ascii("erences"),
        dictgen::InsensitiveStr::Ascii("erencing"),
        dictgen::InsensitiveStr::Ascii("erience"),
        dictgen::InsensitiveStr::Ascii("eriences"),
        dictgen::InsensitiveStr::Ascii("ermental"),
        dictgen::InsensitiveStr::Ascii("ers"),
        dictgen::InsensitiveStr::Ascii("licitely"),
        dictgen::InsensitiveStr::Ascii("nation"),
        dictgen::InsensitiveStr::Ascii("reds"),
        dictgen::InsensitiveStr::Ascii("reitme"),
        dictgen::InsensitiveStr::Ascii("rement"),
        dictgen::InsensitiveStr::Ascii("remental"),
        dictgen::InsensitiveStr::Ascii("rementation"),
        dictgen::InsensitiveStr::Ascii("remented"),
        dictgen::InsensitiveStr::Ascii("rementing"),
        dictgen::InsensitiveStr::Ascii("rements"),
        dictgen::InsensitiveStr::Ascii("riation"),
        dictgen::InsensitiveStr::Ascii("rie"),
        dictgen::InsensitiveStr::Ascii("ried"),
        dictgen::InsensitiveStr::Ascii("rience"),
        dictgen::InsensitiveStr::Ascii("riences"),
        dictgen::InsensitiveStr::Ascii("rimental"),
        dictgen::InsensitiveStr::Ascii("riy"),
        dictgen::InsensitiveStr::Ascii("te"),
        dictgen::InsensitiveStr::Ascii("ted"),
    ],
    values: &[
        &["explicit"],
        &["explicitly"],
        &["expenditures"],
        &["expedition"],
        &["expedition"],
        &["expeditions"],
        &["experience"],
        &["experienced"],
        &["experiences"],
        &["experiencing"],
        &["experience"],
        &["experiences"],
        &["experimental"],
        &["expires"],
        &["explicitly"],
        &["expiration"],
        &["expires"],
        &["expiretime"],
        &["experiment"],
        &["experimental"],
        &["experimentation"],
        &["experimented"],
        &["experimenting"],
        &["experiments"],
        &["expiration"],
        &["expire"],
        &["expired"],
        &["experience"],
        &["experiences"],
        &["experimental"],
        &["expiry"],
        &["expedite", "expire"],
        &["expedited", "expired"],
    ],
    range: 2..=11,
};

static WORD_EXPE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_EXPE_CHILDREN),
    value: None,
};

static WORD_EXPE_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    Some(&WORD_EXPEC_NODE),
    Some(&WORD_EXPED_NODE),
    Some(&WORD_EXPEE_NODE),
    None,
    None,
    None,
    Some(&WORD_EXPEI_NODE),
    None,
    None,
    Some(&WORD_EXPEL_NODE),
    Some(&WORD_EXPEM_NODE),
    Some(&WORD_EXPEN_NODE),
    None,
    Some(&WORD_EXPEP_NODE),
    None,
    Some(&WORD_EXPER_NODE),
    Some(&WORD_EXPES_NODE),
    Some(&WORD_EXPET_NODE),
    None,
    None,
    Some(&WORD_EXPEW_NODE),
    Some(&WORD_EXPEX_NODE),
    None,
    None,
];

static WORD_EXPEX_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXPEX_CHILDREN),
    value: None,
};

pub static WORD_EXPEX_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ct"),
        dictgen::InsensitiveStr::Ascii("cted"),
        dictgen::InsensitiveStr::Ascii("ctedly"),
        dictgen::InsensitiveStr::Ascii("cting"),
        dictgen::InsensitiveStr::Ascii("cts"),
        dictgen::InsensitiveStr::Ascii("nasion"),
        dictgen::InsensitiveStr::Ascii("nasions"),
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("tancy"),
        dictgen::InsensitiveStr::Ascii("ted"),
        dictgen::InsensitiveStr::Ascii("tedly"),
        dictgen::InsensitiveStr::Ascii("ting"),
        dictgen::InsensitiveStr::Ascii("ts"),
    ],
    values: &[
        &["expect"],
        &["expected"],
        &["expectedly"],
        &["expecting"],
        &["expects"],
        &["expansion"],
        &["expansions"],
        &["expect"],
        &["expectancy"],
        &["expected"],
        &["expectedly"],
        &["expecting"],
        &["expects"],
    ],
    range: 1..=7,
};

static WORD_EXPEW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXPEW_CHILDREN),
    value: None,
};

pub static WORD_EXPEW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("riment"),
        dictgen::InsensitiveStr::Ascii("rimental"),
        dictgen::InsensitiveStr::Ascii("rimentally"),
        dictgen::InsensitiveStr::Ascii("rimentation"),
        dictgen::InsensitiveStr::Ascii("rimentations"),
        dictgen::InsensitiveStr::Ascii("rimented"),
        dictgen::InsensitiveStr::Ascii("rimentel"),
        dictgen::InsensitiveStr::Ascii("rimentelly"),
        dictgen::InsensitiveStr::Ascii("rimenter"),
        dictgen::InsensitiveStr::Ascii("rimenters"),
        dictgen::InsensitiveStr::Ascii("rimenting"),
        dictgen::InsensitiveStr::Ascii("riments"),
    ],
    values: &[
        &["experiment"],
        &["experimental"],
        &["experimentally"],
        &["experimentation"],
        &["experimentations"],
        &["experimented"],
        &["experimental"],
        &["experimentally"],
        &["experimenter"],
        &["experimenters"],
        &["experimenting"],
        &["experiments"],
    ],
    range: 6..=12,
};

static WORD_EXPET_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXPET_CHILDREN),
    value: Some(&["expect", "expat"]),
};

pub static WORD_EXPET_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ancy"),
        dictgen::InsensitiveStr::Ascii("ation"),
        dictgen::InsensitiveStr::Ascii("c"),
        dictgen::InsensitiveStr::Ascii("ced"),
        dictgen::InsensitiveStr::Ascii("cedly"),
        dictgen::InsensitiveStr::Ascii("cing"),
        dictgen::InsensitiveStr::Ascii("cs"),
        dictgen::InsensitiveStr::Ascii("ct"),
        dictgen::InsensitiveStr::Ascii("cted"),
        dictgen::InsensitiveStr::Ascii("ctedly"),
        dictgen::InsensitiveStr::Ascii("cting"),
        dictgen::InsensitiveStr::Ascii("cts"),
        dictgen::InsensitiveStr::Ascii("ect"),
        dictgen::InsensitiveStr::Ascii("ected"),
        dictgen::InsensitiveStr::Ascii("ectedly"),
        dictgen::InsensitiveStr::Ascii("ecting"),
        dictgen::InsensitiveStr::Ascii("ectly"),
        dictgen::InsensitiveStr::Ascii("ects"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("edly"),
        dictgen::InsensitiveStr::Ascii("iment"),
        dictgen::InsensitiveStr::Ascii("imental"),
        dictgen::InsensitiveStr::Ascii("imentally"),
        dictgen::InsensitiveStr::Ascii("imentation"),
        dictgen::InsensitiveStr::Ascii("imentations"),
        dictgen::InsensitiveStr::Ascii("imented"),
        dictgen::InsensitiveStr::Ascii("imentel"),
        dictgen::InsensitiveStr::Ascii("imentelly"),
        dictgen::InsensitiveStr::Ascii("imenter"),
        dictgen::InsensitiveStr::Ascii("imenters"),
        dictgen::InsensitiveStr::Ascii("imenting"),
        dictgen::InsensitiveStr::Ascii("iments"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("ion"),
        dictgen::InsensitiveStr::Ascii("ional"),
        dictgen::InsensitiveStr::Ascii("ions"),
        dictgen::InsensitiveStr::Ascii("s"),
    ],
    values: &[
        &["expectancy"],
        &["expectation"],
        &["expect"],
        &["expected"],
        &["expectedly"],
        &["expecting"],
        &["expects"],
        &["expect"],
        &["expected"],
        &["expectedly"],
        &["expecting"],
        &["expects"],
        &["expect"],
        &["expected"],
        &["expectedly"],
        &["expecting"],
        &["expectedly"],
        &["expects"],
        &["expected"],
        &["expectedly"],
        &["experiment"],
        &["experimental"],
        &["experimentally"],
        &["experimentation"],
        &["experimentations"],
        &["experimented"],
        &["experimental"],
        &["experimentally"],
        &["experimenter"],
        &["experimenters"],
        &["experimenting"],
        &["experiments"],
        &["expecting"],
        &["exception"],
        &["exceptional"],
        &["exceptions"],
        &["expects"],
    ],
    range: 1..=11,
};

static WORD_EXPES_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXPES_CHILDREN),
    value: None,
};

pub static WORD_EXPES_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("ive"),
        dictgen::InsensitiveStr::Ascii("nce"),
        dictgen::InsensitiveStr::Ascii("nces"),
        dictgen::InsensitiveStr::Ascii("ncive"),
        dictgen::InsensitiveStr::Ascii("s"),
        dictgen::InsensitiveStr::Ascii("sed"),
        dictgen::InsensitiveStr::Ascii("ses"),
        dictgen::InsensitiveStr::Ascii("sing"),
        dictgen::InsensitiveStr::Ascii("sion"),
        dictgen::InsensitiveStr::Ascii("sions"),
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("ted"),
        dictgen::InsensitiveStr::Ascii("tedly"),
        dictgen::InsensitiveStr::Ascii("ting"),
    ],
    values: &[
        &["expense"],
        &["expenses"],
        &["expensive"],
        &["expense"],
        &["expenses"],
        &["expensive"],
        &["express"],
        &["expressed"],
        &["expresses"],
        &["expressing"],
        &["expression"],
        &["expressions"],
        &["expect"],
        &["expected"],
        &["expectedly"],
        &["expecting"],
    ],
    range: 1..=5,
};

static WORD_EXPER_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_EXPER_CHILDREN),
    value: None,
};

static WORD_EXPER_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_EXPERA_NODE),
    None,
    Some(&WORD_EXPERC_NODE),
    None,
    Some(&WORD_EXPERE_NODE),
    None,
    None,
    None,
    Some(&WORD_EXPERI_NODE),
    None,
    None,
    None,
    Some(&WORD_EXPERM_NODE),
    Some(&WORD_EXPERN_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_EXPERS_NODE),
    Some(&WORD_EXPERT_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_EXPERT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXPERT_CHILDREN),
    value: None,
};

pub static WORD_EXPERT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("as"),
        dictgen::InsensitiveStr::Ascii("is"),
        dictgen::InsensitiveStr::Ascii("os"),
    ],
    values: &[&["experts"], &["experts"], &["experts"]],
    range: 2..=2,
};

static WORD_EXPERS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXPERS_CHILDREN),
    value: Some(&["express"]),
};

pub static WORD_EXPERS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("ion"),
        dictgen::InsensitiveStr::Ascii("ions"),
        dictgen::InsensitiveStr::Ascii("ive"),
        dictgen::InsensitiveStr::Ascii("s"),
        dictgen::InsensitiveStr::Ascii("sed"),
        dictgen::InsensitiveStr::Ascii("ses"),
        dictgen::InsensitiveStr::Ascii("sing"),
        dictgen::InsensitiveStr::Ascii("sion"),
        dictgen::InsensitiveStr::Ascii("sions"),
    ],
    values: &[
        &["expense", "express"],
        &["expressed"],
        &["expenses", "expresses"],
        &["expressing"],
        &["expression"],
        &["expressions"],
        &["expensive"],
        &["express"],
        &["expressed"],
        &["expresses"],
        &["expressing"],
        &["expression"],
        &["expressions"],
    ],
    range: 1..=5,
};

static WORD_EXPERN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXPERN_CHILDREN),
    value: None,
};

pub static WORD_EXPERN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("al")],
    values: &[&["external"]],
    range: 2..=2,
};

static WORD_EXPERM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXPERM_CHILDREN),
    value: None,
};

pub static WORD_EXPERM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("enet"),
        dictgen::InsensitiveStr::Ascii("enetal"),
        dictgen::InsensitiveStr::Ascii("enetally"),
        dictgen::InsensitiveStr::Ascii("enetation"),
        dictgen::InsensitiveStr::Ascii("enetations"),
        dictgen::InsensitiveStr::Ascii("eneted"),
        dictgen::InsensitiveStr::Ascii("enetel"),
        dictgen::InsensitiveStr::Ascii("enetelly"),
        dictgen::InsensitiveStr::Ascii("eneter"),
        dictgen::InsensitiveStr::Ascii("eneters"),
        dictgen::InsensitiveStr::Ascii("eneting"),
        dictgen::InsensitiveStr::Ascii("enets"),
        dictgen::InsensitiveStr::Ascii("ent"),
        dictgen::InsensitiveStr::Ascii("ental"),
        dictgen::InsensitiveStr::Ascii("entally"),
        dictgen::InsensitiveStr::Ascii("entation"),
        dictgen::InsensitiveStr::Ascii("entations"),
        dictgen::InsensitiveStr::Ascii("ented"),
        dictgen::InsensitiveStr::Ascii("entel"),
        dictgen::InsensitiveStr::Ascii("entelly"),
        dictgen::InsensitiveStr::Ascii("enter"),
        dictgen::InsensitiveStr::Ascii("enters"),
        dictgen::InsensitiveStr::Ascii("enting"),
        dictgen::InsensitiveStr::Ascii("ents"),
        dictgen::InsensitiveStr::Ascii("ient"),
        dictgen::InsensitiveStr::Ascii("iental"),
        dictgen::InsensitiveStr::Ascii("ientally"),
        dictgen::InsensitiveStr::Ascii("ientation"),
        dictgen::InsensitiveStr::Ascii("ientations"),
        dictgen::InsensitiveStr::Ascii("iented"),
        dictgen::InsensitiveStr::Ascii("ientel"),
        dictgen::InsensitiveStr::Ascii("ientelly"),
        dictgen::InsensitiveStr::Ascii("ienter"),
        dictgen::InsensitiveStr::Ascii("ienters"),
        dictgen::InsensitiveStr::Ascii("ienting"),
        dictgen::InsensitiveStr::Ascii("ients"),
        dictgen::InsensitiveStr::Ascii("iment"),
        dictgen::InsensitiveStr::Ascii("imental"),
        dictgen::InsensitiveStr::Ascii("imentally"),
        dictgen::InsensitiveStr::Ascii("imentation"),
        dictgen::InsensitiveStr::Ascii("imentations"),
        dictgen::InsensitiveStr::Ascii("imented"),
        dictgen::InsensitiveStr::Ascii("imentel"),
        dictgen::InsensitiveStr::Ascii("imentelly"),
        dictgen::InsensitiveStr::Ascii("imenter"),
        dictgen::InsensitiveStr::Ascii("imenters"),
        dictgen::InsensitiveStr::Ascii("imenting"),
        dictgen::InsensitiveStr::Ascii("iments"),
        dictgen::InsensitiveStr::Ascii("inent"),
        dictgen::InsensitiveStr::Ascii("inental"),
        dictgen::InsensitiveStr::Ascii("inentally"),
        dictgen::InsensitiveStr::Ascii("inentation"),
        dictgen::InsensitiveStr::Ascii("inentations"),
        dictgen::InsensitiveStr::Ascii("inents"),
    ],
    values: &[
        &["experiment"],
        &["experimental"],
        &["experimentally"],
        &["experimentation"],
        &["experimentations"],
        &["experimented"],
        &["experimental"],
        &["experimentally"],
        &["experimenter"],
        &["experimenters"],
        &["experimenting"],
        &["experiments"],
        &["experiment"],
        &["experimental"],
        &["experimentally"],
        &["experimentation"],
        &["experimentations"],
        &["experimented"],
        &["experimental"],
        &["experimentally"],
        &["experimenter"],
        &["experimenters"],
        &["experimenting"],
        &["experiments"],
        &["experiments", "experiment"],
        &["experimental"],
        &["experimentally"],
        &["experimentation"],
        &["experimentations"],
        &["experimented"],
        &["experimental"],
        &["experimentally"],
        &["experimenter"],
        &["experimenters"],
        &["experimenting"],
        &["experiments"],
        &["experiment"],
        &["experimental"],
        &["experimentally"],
        &["experimentation"],
        &["experimentations"],
        &["experimented"],
        &["experimental"],
        &["experimentally"],
        &["experimenter"],
        &["experimenters"],
        &["experimenting"],
        &["experiments"],
        &["experiment"],
        &["experimental"],
        &["experimentally"],
        &["experimentation"],
        &["experimentations"],
        &["experiments"],
    ],
    range: 3..=11,
};

static WORD_EXPERI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_EXPERI_CHILDREN),
    value: None,
};

static WORD_EXPERI_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_EXPERIA_NODE),
    None,
    Some(&WORD_EXPERIC_NODE),
    None,
    Some(&WORD_EXPERIE_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_EXPERIM_NODE),
    Some(&WORD_EXPERIN_NODE),
    None,
    None,
    None,
    Some(&WORD_EXPERIR_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_EXPERIR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXPERIR_CHILDREN),
    value: None,
};

pub static WORD_EXPERIR_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("ation"),
            dictgen::InsensitiveStr::Ascii("ations"),
        ],
        values: &[&["expiration"], &["expirations"]],
        range: 5..=6,
    };

static WORD_EXPERIN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXPERIN_CHILDREN),
    value: None,
};

pub static WORD_EXPERIN_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("ece"),
            dictgen::InsensitiveStr::Ascii("eced"),
            dictgen::InsensitiveStr::Ascii("ement"),
            dictgen::InsensitiveStr::Ascii("emental"),
            dictgen::InsensitiveStr::Ascii("ementally"),
            dictgen::InsensitiveStr::Ascii("ementation"),
            dictgen::InsensitiveStr::Ascii("ementations"),
            dictgen::InsensitiveStr::Ascii("emented"),
            dictgen::InsensitiveStr::Ascii("ementel"),
            dictgen::InsensitiveStr::Ascii("ementelly"),
            dictgen::InsensitiveStr::Ascii("ementer"),
            dictgen::InsensitiveStr::Ascii("ementers"),
            dictgen::InsensitiveStr::Ascii("ementing"),
            dictgen::InsensitiveStr::Ascii("ements"),
        ],
        values: &[
            &["experience"],
            &["experienced"],
            &["experiment"],
            &["experimental"],
            &["experimentally"],
            &["experimentation"],
            &["experimentations"],
            &["experimented"],
            &["experimental"],
            &["experimentally"],
            &["experimenter"],
            &["experimenters"],
            &["experimenting"],
            &["experiments"],
        ],
        range: 3..=11,
    };

static WORD_EXPERIM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_EXPERIM_CHILDREN),
    value: Some(&["experiment"]),
};

static WORD_EXPERIM_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_EXPERIMA_NODE),
    None,
    None,
    Some(&WORD_EXPERIMD_NODE),
    Some(&WORD_EXPERIME_NODE),
    None,
    None,
    None,
    Some(&WORD_EXPERIMI_NODE),
    None,
    None,
    None,
    Some(&WORD_EXPERIMM_NODE),
    Some(&WORD_EXPERIMN_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_EXPERIMS_NODE),
    Some(&WORD_EXPERIMT_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_EXPERIMT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXPERIMT_CHILDREN),
    value: None,
};

pub static WORD_EXPERIMT_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("en"),
            dictgen::InsensitiveStr::Ascii("enal"),
            dictgen::InsensitiveStr::Ascii("enally"),
            dictgen::InsensitiveStr::Ascii("enation"),
            dictgen::InsensitiveStr::Ascii("enations"),
            dictgen::InsensitiveStr::Ascii("ened"),
            dictgen::InsensitiveStr::Ascii("enel"),
            dictgen::InsensitiveStr::Ascii("enelly"),
            dictgen::InsensitiveStr::Ascii("ener"),
            dictgen::InsensitiveStr::Ascii("eners"),
            dictgen::InsensitiveStr::Ascii("ening"),
            dictgen::InsensitiveStr::Ascii("ens"),
        ],
        values: &[
            &["experiment"],
            &["experimental"],
            &["experimentally"],
            &["experimentation"],
            &["experimentations"],
            &["experimented"],
            &["experimental"],
            &["experimentally"],
            &["experimenter"],
            &["experimenters"],
            &["experimenting"],
            &["experiments"],
        ],
        range: 2..=8,
    };

static WORD_EXPERIMS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXPERIMS_CHILDREN),
    value: Some(&["experiments"]),
};

pub static WORD_EXPERIMS_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[],
        values: &[],
        range: 0..=0,
    };

static WORD_EXPERIMN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXPERIMN_CHILDREN),
    value: None,
};

pub static WORD_EXPERIMN_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("et"),
            dictgen::InsensitiveStr::Ascii("etal"),
            dictgen::InsensitiveStr::Ascii("etally"),
            dictgen::InsensitiveStr::Ascii("etation"),
            dictgen::InsensitiveStr::Ascii("etations"),
            dictgen::InsensitiveStr::Ascii("eted"),
            dictgen::InsensitiveStr::Ascii("etel"),
            dictgen::InsensitiveStr::Ascii("etelly"),
            dictgen::InsensitiveStr::Ascii("eter"),
            dictgen::InsensitiveStr::Ascii("eters"),
            dictgen::InsensitiveStr::Ascii("eting"),
            dictgen::InsensitiveStr::Ascii("ets"),
            dictgen::InsensitiveStr::Ascii("t"),
            dictgen::InsensitiveStr::Ascii("tal"),
            dictgen::InsensitiveStr::Ascii("tally"),
            dictgen::InsensitiveStr::Ascii("tation"),
            dictgen::InsensitiveStr::Ascii("tations"),
            dictgen::InsensitiveStr::Ascii("ted"),
            dictgen::InsensitiveStr::Ascii("tel"),
            dictgen::InsensitiveStr::Ascii("telly"),
            dictgen::InsensitiveStr::Ascii("ter"),
            dictgen::InsensitiveStr::Ascii("ters"),
            dictgen::InsensitiveStr::Ascii("ting"),
            dictgen::InsensitiveStr::Ascii("ts"),
        ],
        values: &[
            &["experiment"],
            &["experimental"],
            &["experimentally"],
            &["experimentation"],
            &["experimentations"],
            &["experimented"],
            &["experimental"],
            &["experimentally"],
            &["experimenter"],
            &["experimenters"],
            &["experimenting"],
            &["experiments"],
            &["experiment"],
            &["experimental"],
            &["experimentally"],
            &["experimentation"],
            &["experimentations"],
            &["experimented"],
            &["experimental"],
            &["experimentally"],
            &["experimenter"],
            &["experimenters"],
            &["experimenting"],
            &["experiments"],
        ],
        range: 1..=8,
    };

static WORD_EXPERIMM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXPERIMM_CHILDREN),
    value: None,
};

pub static WORD_EXPERIMM_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("ent"),
            dictgen::InsensitiveStr::Ascii("ental"),
            dictgen::InsensitiveStr::Ascii("entally"),
            dictgen::InsensitiveStr::Ascii("entation"),
            dictgen::InsensitiveStr::Ascii("entations"),
            dictgen::InsensitiveStr::Ascii("ented"),
            dictgen::InsensitiveStr::Ascii("entel"),
            dictgen::InsensitiveStr::Ascii("entelly"),
            dictgen::InsensitiveStr::Ascii("enter"),
            dictgen::InsensitiveStr::Ascii("enters"),
            dictgen::InsensitiveStr::Ascii("enting"),
            dictgen::InsensitiveStr::Ascii("ents"),
        ],
        values: &[
            &["experiment"],
            &["experimental"],
            &["experimentally"],
            &["experimentation"],
            &["experimentations"],
            &["experimented"],
            &["experimental"],
            &["experimentally"],
            &["experimenter"],
            &["experimenters"],
            &["experimenting"],
            &["experiments"],
        ],
        range: 3..=9,
    };

static WORD_EXPERIMI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXPERIMI_CHILDREN),
    value: None,
};

pub static WORD_EXPERIMI_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("ng"),
            dictgen::InsensitiveStr::Ascii("nt"),
            dictgen::InsensitiveStr::Ascii("ntal"),
            dictgen::InsensitiveStr::Ascii("ntally"),
            dictgen::InsensitiveStr::Ascii("ntation"),
            dictgen::InsensitiveStr::Ascii("ntations"),
            dictgen::InsensitiveStr::Ascii("nted"),
            dictgen::InsensitiveStr::Ascii("ntel"),
            dictgen::InsensitiveStr::Ascii("ntelly"),
            dictgen::InsensitiveStr::Ascii("nter"),
            dictgen::InsensitiveStr::Ascii("nters"),
            dictgen::InsensitiveStr::Ascii("nting"),
            dictgen::InsensitiveStr::Ascii("nts"),
        ],
        values: &[
            &["experimenting"],
            &["experiment"],
            &["experimental"],
            &["experimentally"],
            &["experimentation"],
            &["experimentations"],
            &["experimented"],
            &["experimental"],
            &["experimentally"],
            &["experimenter"],
            &["experimenters"],
            &["experimenting"],
            &["experiments"],
        ],
        range: 2..=8,
    };

static WORD_EXPERIME_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_EXPERIME_CHILDREN),
    value: None,
};

static WORD_EXPERIME_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    None,
    Some(&WORD_EXPERIMED_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_EXPERIMEL_NODE),
    None,
    Some(&WORD_EXPERIMEN_NODE),
    None,
    None,
    None,
    Some(&WORD_EXPERIMER_NODE),
    None,
    Some(&WORD_EXPERIMET_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_EXPERIMET_NODE: dictgen::DictTrieNode<&'static [&'static str]> =
    dictgen::DictTrieNode {
        children: dictgen::DictTrieChild::Flat(&WORD_EXPERIMET_CHILDREN),
        value: Some(&["experiments", "experiment"]),
    };

pub static WORD_EXPERIMET_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("al"),
            dictgen::InsensitiveStr::Ascii("ally"),
            dictgen::InsensitiveStr::Ascii("ation"),
            dictgen::InsensitiveStr::Ascii("ations"),
            dictgen::InsensitiveStr::Ascii("ed"),
            dictgen::InsensitiveStr::Ascii("el"),
            dictgen::InsensitiveStr::Ascii("elly"),
            dictgen::InsensitiveStr::Ascii("ent"),
            dictgen::InsensitiveStr::Ascii("ental"),
            dictgen::InsensitiveStr::Ascii("entally"),
            dictgen::InsensitiveStr::Ascii("entation"),
            dictgen::InsensitiveStr::Ascii("entations"),
            dictgen::InsensitiveStr::Ascii("ented"),
            dictgen::InsensitiveStr::Ascii("entel"),
            dictgen::InsensitiveStr::Ascii("entelly"),
            dictgen::InsensitiveStr::Ascii("enter"),
            dictgen::InsensitiveStr::Ascii("enters"),
            dictgen::InsensitiveStr::Ascii("enting"),
            dictgen::InsensitiveStr::Ascii("ents"),
            dictgen::InsensitiveStr::Ascii("er"),
            dictgen::InsensitiveStr::Ascii("ers"),
            dictgen::InsensitiveStr::Ascii("ing"),
            dictgen::InsensitiveStr::Ascii("n"),
            dictgen::InsensitiveStr::Ascii("nal"),
            dictgen::InsensitiveStr::Ascii("nally"),
            dictgen::InsensitiveStr::Ascii("nation"),
            dictgen::InsensitiveStr::Ascii("nations"),
            dictgen::InsensitiveStr::Ascii("ned"),
            dictgen::InsensitiveStr::Ascii("nel"),
            dictgen::InsensitiveStr::Ascii("nelly"),
            dictgen::InsensitiveStr::Ascii("ner"),
            dictgen::InsensitiveStr::Ascii("ners"),
            dictgen::InsensitiveStr::Ascii("ning"),
            dictgen::InsensitiveStr::Ascii("ns"),
            dictgen::InsensitiveStr::Ascii("s"),
        ],
        values: &[
            &["experimental"],
            &["experimentally"],
            &["experimentation"],
            &["experimentations"],
            &["experimented"],
            &["experimental"],
            &["experimentally"],
            &["experiment"],
            &["experimental"],
            &["experimentally"],
            &["experimentation"],
            &["experimentations"],
            &["experimented"],
            &["experimental"],
            &["experimentally"],
            &["experimenter"],
            &["experimenters"],
            &["experimenting"],
            &["experiments"],
            &["experimenter"],
            &["experimenters"],
            &["experimenting"],
            &["experiment"],
            &["experimental"],
            &["experimentally"],
            &["experimentation"],
            &["experimentations"],
            &["experimented"],
            &["experimental"],
            &["experimentally"],
            &["experimenter"],
            &["experimenters"],
            &["experimenting"],
            &["experiments"],
            &["experiments"],
        ],
        range: 1..=9,
    };

static WORD_EXPERIMER_NODE: dictgen::DictTrieNode<&'static [&'static str]> =
    dictgen::DictTrieNode {
        children: dictgen::DictTrieChild::Flat(&WORD_EXPERIMER_CHILDREN),
        value: Some(&["experimenter"]),
    };

pub static WORD_EXPERIMER_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[dictgen::InsensitiveStr::Ascii("s")],
        values: &[&["experimenters"]],
        range: 1..=1,
    };

static WORD_EXPERIMEN_NODE: dictgen::DictTrieNode<&'static [&'static str]> =
    dictgen::DictTrieNode {
        children: dictgen::DictTrieChild::Nested(&WORD_EXPERIMEN_CHILDREN),
        value: Some(&["experiment"]),
    };

static WORD_EXPERIMEN_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_EXPERIMENA_NODE),
    None,
    None,
    None,
    Some(&WORD_EXPERIMENE_NODE),
    None,
    None,
    None,
    Some(&WORD_EXPERIMENI_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_EXPERIMENS_NODE),
    Some(&WORD_EXPERIMENT_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_EXPERIMENT_NODE: dictgen::DictTrieNode<&'static [&'static str]> =
    dictgen::DictTrieNode {
        children: dictgen::DictTrieChild::Flat(&WORD_EXPERIMENT_CHILDREN),
        value: None,
    };

pub static WORD_EXPERIMENT_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("aal"),
            dictgen::InsensitiveStr::Ascii("aally"),
            dictgen::InsensitiveStr::Ascii("aat"),
            dictgen::InsensitiveStr::Ascii("aatl"),
            dictgen::InsensitiveStr::Ascii("aatlly"),
            dictgen::InsensitiveStr::Ascii("aats"),
            dictgen::InsensitiveStr::Ascii("acion"),
            dictgen::InsensitiveStr::Ascii("aed"),
            dictgen::InsensitiveStr::Ascii("aer"),
            dictgen::InsensitiveStr::Ascii("aing"),
            dictgen::InsensitiveStr::Ascii("aion"),
            dictgen::InsensitiveStr::Ascii("aions"),
            dictgen::InsensitiveStr::Ascii("ais"),
            dictgen::InsensitiveStr::Ascii("ait"),
            dictgen::InsensitiveStr::Ascii("aital"),
            dictgen::InsensitiveStr::Ascii("aitally"),
            dictgen::InsensitiveStr::Ascii("aited"),
            dictgen::InsensitiveStr::Ascii("aiter"),
            dictgen::InsensitiveStr::Ascii("aiters"),
            dictgen::InsensitiveStr::Ascii("aitng"),
            dictgen::InsensitiveStr::Ascii("aiton"),
            dictgen::InsensitiveStr::Ascii("aitons"),
            dictgen::InsensitiveStr::Ascii("an"),
            dictgen::InsensitiveStr::Ascii("at"),
            dictgen::InsensitiveStr::Ascii("atal"),
            dictgen::InsensitiveStr::Ascii("atally"),
            dictgen::InsensitiveStr::Ascii("atation"),
            dictgen::InsensitiveStr::Ascii("atations"),
            dictgen::InsensitiveStr::Ascii("ated"),
            dictgen::InsensitiveStr::Ascii("ater"),
            dictgen::InsensitiveStr::Ascii("atin"),
            dictgen::InsensitiveStr::Ascii("ating"),
            dictgen::InsensitiveStr::Ascii("atl"),
            dictgen::InsensitiveStr::Ascii("atlly"),
            dictgen::InsensitiveStr::Ascii("atly"),
            dictgen::InsensitiveStr::Ascii("el"),
            dictgen::InsensitiveStr::Ascii("ella"),
            dictgen::InsensitiveStr::Ascii("elly"),
            dictgen::InsensitiveStr::Ascii("erade"),
            dictgen::InsensitiveStr::Ascii("es"),
            dictgen::InsensitiveStr::Ascii("ion"),
            dictgen::InsensitiveStr::Ascii("le"),
            dictgen::InsensitiveStr::Ascii("ors"),
            dictgen::InsensitiveStr::Ascii("os"),
            dictgen::InsensitiveStr::Ascii("t"),
            dictgen::InsensitiveStr::Ascii("ted"),
            dictgen::InsensitiveStr::Ascii("ter"),
            dictgen::InsensitiveStr::Ascii("ters"),
            dictgen::InsensitiveStr::Ascii("ts"),
            dictgen::InsensitiveStr::Ascii("ul"),
        ],
        values: &[
            &["experimental"],
            &["experimentally"],
            &["experiment"],
            &["experimental"],
            &["experimentally"],
            &["experiments"],
            &["experimentation"],
            &["experimented"],
            &["experimenter"],
            &["experimenting"],
            &["experimentation"],
            &["experimentations"],
            &["experiments"],
            &["experiment"],
            &["experimental"],
            &["experimentally"],
            &["experimented"],
            &["experimenter"],
            &["experimenters"],
            &["experimenting"],
            &["experimentation"],
            &["experimentations"],
            &["experimentation"],
            &["experimental"],
            &["experimental"],
            &["experimentally"],
            &["experimentation"],
            &["experimentations"],
            &["experimented"],
            &["experimenter"],
            &["experimentation", "experimenting"],
            &["experimentation", "experimenting"],
            &["experimental"],
            &["experimentally"],
            &["experimentally"],
            &["experimental"],
            &["experimental"],
            &["experimentally"],
            &["experimented"],
            &["experiments"],
            &["experimenting"],
            &["experimented"],
            &["experiments"],
            &["experiments"],
            &["experiment"],
            &["experimented"],
            &["experimenter"],
            &["experimenters"],
            &["experiments"],
            &["experimental"],
        ],
        range: 1..=8,
    };

static WORD_EXPERIMENS_NODE: dictgen::DictTrieNode<&'static [&'static str]> =
    dictgen::DictTrieNode {
        children: dictgen::DictTrieChild::Flat(&WORD_EXPERIMENS_CHILDREN),
        value: Some(&["experiments"]),
    };

pub static WORD_EXPERIMENS_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[],
        values: &[],
        range: 0..=0,
    };

static WORD_EXPERIMENI_NODE: dictgen::DictTrieNode<&'static [&'static str]> =
    dictgen::DictTrieNode {
        children: dictgen::DictTrieChild::Flat(&WORD_EXPERIMENI_CHILDREN),
        value: None,
    };

pub static WORD_EXPERIMENI_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[dictgen::InsensitiveStr::Ascii("ng")],
        values: &[&["experimenting"]],
        range: 2..=2,
    };

static WORD_EXPERIMENE_NODE: dictgen::DictTrieNode<&'static [&'static str]> =
    dictgen::DictTrieNode {
        children: dictgen::DictTrieChild::Flat(&WORD_EXPERIMENE_CHILDREN),
        value: None,
    };

pub static WORD_EXPERIMENE_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("d"),
            dictgen::InsensitiveStr::Ascii("l"),
            dictgen::InsensitiveStr::Ascii("lly"),
            dictgen::InsensitiveStr::Ascii("r"),
            dictgen::InsensitiveStr::Ascii("rs"),
        ],
        values: &[
            &["experimented"],
            &["experimental"],
            &["experimentally"],
            &["experimenter"],
            &["experimenters"],
        ],
        range: 1..=3,
    };

static WORD_EXPERIMENA_NODE: dictgen::DictTrieNode<&'static [&'static str]> =
    dictgen::DictTrieNode {
        children: dictgen::DictTrieChild::Flat(&WORD_EXPERIMENA_CHILDREN),
        value: None,
    };

pub static WORD_EXPERIMENA_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("l"),
            dictgen::InsensitiveStr::Ascii("lly"),
            dictgen::InsensitiveStr::Ascii("t"),
            dictgen::InsensitiveStr::Ascii("tal"),
            dictgen::InsensitiveStr::Ascii("tally"),
            dictgen::InsensitiveStr::Ascii("tation"),
            dictgen::InsensitiveStr::Ascii("tations"),
            dictgen::InsensitiveStr::Ascii("ted"),
            dictgen::InsensitiveStr::Ascii("tel"),
            dictgen::InsensitiveStr::Ascii("telly"),
            dictgen::InsensitiveStr::Ascii("ter"),
            dictgen::InsensitiveStr::Ascii("ters"),
            dictgen::InsensitiveStr::Ascii("ting"),
            dictgen::InsensitiveStr::Ascii("tion"),
            dictgen::InsensitiveStr::Ascii("tions"),
            dictgen::InsensitiveStr::Ascii("ts"),
        ],
        values: &[
            &["experimental"],
            &["experimentally"],
            &["experiment"],
            &["experimental"],
            &["experimentally"],
            &["experimentation"],
            &["experimentations"],
            &["experimented"],
            &["experimental"],
            &["experimentally"],
            &["experimenter"],
            &["experimenters"],
            &["experimenting"],
            &["experimentation"],
            &["experimentations"],
            &["experiments"],
        ],
        range: 1..=7,
    };

static WORD_EXPERIMEL_NODE: dictgen::DictTrieNode<&'static [&'static str]> =
    dictgen::DictTrieNode {
        children: dictgen::DictTrieChild::Flat(&WORD_EXPERIMEL_CHILDREN),
        value: Some(&["experimental"]),
    };

pub static WORD_EXPERIMEL_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[dictgen::InsensitiveStr::Ascii("ly")],
        values: &[&["experimentally"]],
        range: 2..=2,
    };

static WORD_EXPERIMED_NODE: dictgen::DictTrieNode<&'static [&'static str]> =
    dictgen::DictTrieNode {
        children: dictgen::DictTrieChild::Flat(&WORD_EXPERIMED_CHILDREN),
        value: Some(&["experimented"]),
    };

pub static WORD_EXPERIMED_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[],
        values: &[],
        range: 0..=0,
    };

static WORD_EXPERIMD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXPERIMD_CHILDREN),
    value: None,
};

pub static WORD_EXPERIMD_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("nt"),
            dictgen::InsensitiveStr::Ascii("ntal"),
            dictgen::InsensitiveStr::Ascii("ntally"),
            dictgen::InsensitiveStr::Ascii("ntation"),
            dictgen::InsensitiveStr::Ascii("ntations"),
            dictgen::InsensitiveStr::Ascii("nted"),
            dictgen::InsensitiveStr::Ascii("ntel"),
            dictgen::InsensitiveStr::Ascii("ntelly"),
            dictgen::InsensitiveStr::Ascii("nter"),
            dictgen::InsensitiveStr::Ascii("nters"),
            dictgen::InsensitiveStr::Ascii("nting"),
            dictgen::InsensitiveStr::Ascii("nts"),
        ],
        values: &[
            &["experiment"],
            &["experimental"],
            &["experimentally"],
            &["experimentation"],
            &["experimentations"],
            &["experimented"],
            &["experimental"],
            &["experimentally"],
            &["experimenter"],
            &["experimenters"],
            &["experimenting"],
            &["experiments"],
        ],
        range: 2..=8,
    };

static WORD_EXPERIMA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXPERIMA_CHILDREN),
    value: None,
};

pub static WORD_EXPERIMA_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("l"),
            dictgen::InsensitiveStr::Ascii("lly"),
            dictgen::InsensitiveStr::Ascii("nent"),
            dictgen::InsensitiveStr::Ascii("nental"),
            dictgen::InsensitiveStr::Ascii("nentally"),
            dictgen::InsensitiveStr::Ascii("nentation"),
            dictgen::InsensitiveStr::Ascii("nentations"),
            dictgen::InsensitiveStr::Ascii("nented"),
            dictgen::InsensitiveStr::Ascii("nentel"),
            dictgen::InsensitiveStr::Ascii("nentelly"),
            dictgen::InsensitiveStr::Ascii("nenter"),
            dictgen::InsensitiveStr::Ascii("nenters"),
            dictgen::InsensitiveStr::Ascii("nenting"),
            dictgen::InsensitiveStr::Ascii("nents"),
            dictgen::InsensitiveStr::Ascii("net"),
            dictgen::InsensitiveStr::Ascii("netal"),
            dictgen::InsensitiveStr::Ascii("netally"),
            dictgen::InsensitiveStr::Ascii("netation"),
            dictgen::InsensitiveStr::Ascii("netations"),
            dictgen::InsensitiveStr::Ascii("neted"),
            dictgen::InsensitiveStr::Ascii("netel"),
            dictgen::InsensitiveStr::Ascii("netelly"),
            dictgen::InsensitiveStr::Ascii("neter"),
            dictgen::InsensitiveStr::Ascii("neters"),
            dictgen::InsensitiveStr::Ascii("neting"),
            dictgen::InsensitiveStr::Ascii("nets"),
            dictgen::InsensitiveStr::Ascii("nt"),
            dictgen::InsensitiveStr::Ascii("ntal"),
            dictgen::InsensitiveStr::Ascii("ntally"),
            dictgen::InsensitiveStr::Ascii("ntation"),
            dictgen::InsensitiveStr::Ascii("ntations"),
            dictgen::InsensitiveStr::Ascii("nted"),
            dictgen::InsensitiveStr::Ascii("ntel"),
            dictgen::InsensitiveStr::Ascii("ntelly"),
            dictgen::InsensitiveStr::Ascii("nter"),
            dictgen::InsensitiveStr::Ascii("nters"),
            dictgen::InsensitiveStr::Ascii("nting"),
            dictgen::InsensitiveStr::Ascii("nts"),
            dictgen::InsensitiveStr::Ascii("tion"),
            dictgen::InsensitiveStr::Ascii("tions"),
        ],
        values: &[
            &["experimental"],
            &["experimentally"],
            &["experiment"],
            &["experimental"],
            &["experimentally"],
            &["experimentation"],
            &["experimentations"],
            &["experimented"],
            &["experimental"],
            &["experimentally"],
            &["experimenter"],
            &["experimenters"],
            &["experimenting"],
            &["experiments"],
            &["experiment"],
            &["experimental"],
            &["experimentally"],
            &["experimentation"],
            &["experimentations"],
            &["experimented"],
            &["experimental"],
            &["experimentally"],
            &["experimenter"],
            &["experimenters"],
            &["experimenting"],
            &["experiments"],
            &["experiment"],
            &["experimental"],
            &["experimentally"],
            &["experimentation"],
            &["experimentations"],
            &["experimented"],
            &["experimental"],
            &["experimentally"],
            &["experimenter"],
            &["experimenters"],
            &["experimenting"],
            &["experiments"],
            &["experimentation"],
            &["experimentations"],
        ],
        range: 1..=10,
    };

static WORD_EXPERIE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXPERIE_CHILDREN),
    value: None,
};

pub static WORD_EXPERIE_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("ced"),
            dictgen::InsensitiveStr::Ascii("ces"),
            dictgen::InsensitiveStr::Ascii("ment"),
            dictgen::InsensitiveStr::Ascii("mnt"),
            dictgen::InsensitiveStr::Ascii("mntal"),
            dictgen::InsensitiveStr::Ascii("mnted"),
            dictgen::InsensitiveStr::Ascii("mnts"),
            dictgen::InsensitiveStr::Ascii("nceing"),
            dictgen::InsensitiveStr::Ascii("ned"),
            dictgen::InsensitiveStr::Ascii("ning"),
            dictgen::InsensitiveStr::Ascii("nse"),
            dictgen::InsensitiveStr::Ascii("nshial"),
            dictgen::InsensitiveStr::Ascii("nsial"),
            dictgen::InsensitiveStr::Ascii("s"),
        ],
        values: &[
            &["experienced"],
            &["experiences"],
            &["experiment"],
            &["experiment"],
            &["experimental"],
            &["experimented"],
            &["experiments"],
            &["experiencing"],
            &["experienced"],
            &["experiencing"],
            &["experiences"],
            &["experiential"],
            &["experiential"],
            &["expires"],
        ],
        range: 1..=6,
    };

static WORD_EXPERIC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXPERIC_CHILDREN),
    value: None,
};

pub static WORD_EXPERIC_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("e"),
            dictgen::InsensitiveStr::Ascii("ed"),
            dictgen::InsensitiveStr::Ascii("es"),
            dictgen::InsensitiveStr::Ascii("ing"),
        ],
        values: &[
            &["experience"],
            &["experienced"],
            &["experiences"],
            &["experiencing"],
        ],
        range: 1..=3,
    };

static WORD_EXPERIA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXPERIA_CHILDREN),
    value: None,
};

pub static WORD_EXPERIA_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("nce"),
            dictgen::InsensitiveStr::Ascii("nced"),
            dictgen::InsensitiveStr::Ascii("nces"),
            dictgen::InsensitiveStr::Ascii("ncial"),
            dictgen::InsensitiveStr::Ascii("ncing"),
            dictgen::InsensitiveStr::Ascii("nsial"),
            dictgen::InsensitiveStr::Ascii("ntial"),
            dictgen::InsensitiveStr::Ascii("tion"),
            dictgen::InsensitiveStr::Ascii("tions"),
        ],
        values: &[
            &["experience"],
            &["experienced"],
            &["experiences"],
            &["experiential"],
            &["experiencing"],
            &["experiential"],
            &["experiential"],
            &["expiration"],
            &["expirations"],
        ],
        range: 3..=5,
    };

static WORD_EXPERE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXPERE_CHILDREN),
    value: None,
};

pub static WORD_EXPERE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ince"),
        dictgen::InsensitiveStr::Ascii("inced"),
        dictgen::InsensitiveStr::Ascii("inces"),
        dictgen::InsensitiveStr::Ascii("incing"),
        dictgen::InsensitiveStr::Ascii("ment"),
        dictgen::InsensitiveStr::Ascii("mental"),
        dictgen::InsensitiveStr::Ascii("mentally"),
        dictgen::InsensitiveStr::Ascii("mentation"),
        dictgen::InsensitiveStr::Ascii("mentations"),
        dictgen::InsensitiveStr::Ascii("mented"),
        dictgen::InsensitiveStr::Ascii("mentel"),
        dictgen::InsensitiveStr::Ascii("mentelly"),
        dictgen::InsensitiveStr::Ascii("menter"),
        dictgen::InsensitiveStr::Ascii("menters"),
        dictgen::InsensitiveStr::Ascii("menting"),
        dictgen::InsensitiveStr::Ascii("ments"),
        dictgen::InsensitiveStr::Ascii("nce"),
        dictgen::InsensitiveStr::Ascii("nced"),
        dictgen::InsensitiveStr::Ascii("nces"),
        dictgen::InsensitiveStr::Ascii("ncing"),
        dictgen::InsensitiveStr::Ascii("s"),
        dictgen::InsensitiveStr::Ascii("sed"),
        dictgen::InsensitiveStr::Ascii("sion"),
        dictgen::InsensitiveStr::Ascii("sions"),
        dictgen::InsensitiveStr::Ascii("ss"),
        dictgen::InsensitiveStr::Ascii("ssed"),
        dictgen::InsensitiveStr::Ascii("sses"),
        dictgen::InsensitiveStr::Ascii("ssing"),
        dictgen::InsensitiveStr::Ascii("ssion"),
        dictgen::InsensitiveStr::Ascii("ssions"),
    ],
    values: &[
        &["experience"],
        &["experienced"],
        &["experiences"],
        &["experiencing"],
        &["experiment"],
        &["experimental"],
        &["experimentally"],
        &["experimentation"],
        &["experimentations"],
        &["experimented"],
        &["experimental"],
        &["experimentally"],
        &["experimenter"],
        &["experimenters"],
        &["experimenting"],
        &["experiments"],
        &["experience"],
        &["experienced"],
        &["experiences"],
        &["experiencing"],
        &["express"],
        &["expressed"],
        &["expression"],
        &["expressions"],
        &["express"],
        &["expressed"],
        &["expresses"],
        &["expressing"],
        &["expression"],
        &["expressions"],
    ],
    range: 1..=10,
};

static WORD_EXPERC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXPERC_CHILDREN),
    value: None,
};

pub static WORD_EXPERC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("ted"),
        dictgen::InsensitiveStr::Ascii("ting"),
        dictgen::InsensitiveStr::Ascii("ts"),
    ],
    values: &[
        &["expect", "excerpt"],
        &["expected", "excerpted"],
        &["expecting"],
        &["expects"],
    ],
    range: 1..=4,
};

static WORD_EXPERA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXPERA_CHILDREN),
    value: None,
};

pub static WORD_EXPERA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ment"),
        dictgen::InsensitiveStr::Ascii("mental"),
        dictgen::InsensitiveStr::Ascii("mentally"),
        dictgen::InsensitiveStr::Ascii("mentation"),
        dictgen::InsensitiveStr::Ascii("mentations"),
        dictgen::InsensitiveStr::Ascii("mented"),
        dictgen::InsensitiveStr::Ascii("mentel"),
        dictgen::InsensitiveStr::Ascii("mentelly"),
        dictgen::InsensitiveStr::Ascii("menter"),
        dictgen::InsensitiveStr::Ascii("menters"),
        dictgen::InsensitiveStr::Ascii("menting"),
        dictgen::InsensitiveStr::Ascii("ments"),
        dictgen::InsensitiveStr::Ascii("tion"),
    ],
    values: &[
        &["experiment"],
        &["experimental"],
        &["experimentally"],
        &["experimentation"],
        &["experimentations"],
        &["experimented"],
        &["experimental"],
        &["experimentally"],
        &["experimenter"],
        &["experimenters"],
        &["experimenting"],
        &["experiments"],
        &["expiration"],
    ],
    range: 4..=10,
};

static WORD_EXPEP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXPEP_CHILDREN),
    value: None,
};

pub static WORD_EXPEP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ect"),
        dictgen::InsensitiveStr::Ascii("ected"),
        dictgen::InsensitiveStr::Ascii("ectedly"),
        dictgen::InsensitiveStr::Ascii("ecting"),
        dictgen::InsensitiveStr::Ascii("ects"),
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("ted"),
        dictgen::InsensitiveStr::Ascii("tedly"),
        dictgen::InsensitiveStr::Ascii("ting"),
        dictgen::InsensitiveStr::Ascii("tion"),
        dictgen::InsensitiveStr::Ascii("tions"),
        dictgen::InsensitiveStr::Ascii("ts"),
    ],
    values: &[
        &["expect"],
        &["expected"],
        &["expectedly"],
        &["expecting"],
        &["expects"],
        &["expect", "except"],
        &["expected"],
        &["expectedly"],
        &["expecting"],
        &["exception"],
        &["exceptions"],
        &["expects"],
    ],
    range: 1..=7,
};

static WORD_EXPEN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXPEN_CHILDREN),
    value: None,
};

pub static WORD_EXPEN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ce"),
        dictgen::InsensitiveStr::Ascii("ces"),
        dictgen::InsensitiveStr::Ascii("cive"),
        dictgen::InsensitiveStr::Ascii("dature"),
        dictgen::InsensitiveStr::Ascii("datures"),
        dictgen::InsensitiveStr::Ascii("deble"),
        dictgen::InsensitiveStr::Ascii("deture"),
        dictgen::InsensitiveStr::Ascii("detures"),
        dictgen::InsensitiveStr::Ascii("dible"),
        dictgen::InsensitiveStr::Ascii("sable"),
        dictgen::InsensitiveStr::Ascii("sie"),
        dictgen::InsensitiveStr::Ascii("sve"),
        dictgen::InsensitiveStr::Ascii("tancy"),
        dictgen::InsensitiveStr::Ascii("titure"),
        dictgen::InsensitiveStr::Ascii("titures"),
    ],
    values: &[
        &["expense"],
        &["expense", "expenses"],
        &["expensive"],
        &["expenditure"],
        &["expenditures"],
        &["expendable"],
        &["expenditure"],
        &["expenditures"],
        &["expendable"],
        &["expendable"],
        &["expense"],
        &["expense"],
        &["expectancy"],
        &["expenditure"],
        &["expenditures"],
    ],
    range: 2..=7,
};

static WORD_EXPEM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXPEM_CHILDREN),
    value: None,
};

pub static WORD_EXPEM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ent"),
        dictgen::InsensitiveStr::Ascii("ental"),
        dictgen::InsensitiveStr::Ascii("entally"),
        dictgen::InsensitiveStr::Ascii("entation"),
        dictgen::InsensitiveStr::Ascii("entations"),
        dictgen::InsensitiveStr::Ascii("ented"),
        dictgen::InsensitiveStr::Ascii("entel"),
        dictgen::InsensitiveStr::Ascii("entelly"),
        dictgen::InsensitiveStr::Ascii("enter"),
        dictgen::InsensitiveStr::Ascii("enters"),
        dictgen::InsensitiveStr::Ascii("enting"),
        dictgen::InsensitiveStr::Ascii("ents"),
        dictgen::InsensitiveStr::Ascii("plar"),
        dictgen::InsensitiveStr::Ascii("plars"),
        dictgen::InsensitiveStr::Ascii("plary"),
        dictgen::InsensitiveStr::Ascii("pt"),
        dictgen::InsensitiveStr::Ascii("pted"),
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("ted"),
        dictgen::InsensitiveStr::Ascii("tion"),
        dictgen::InsensitiveStr::Ascii("tions"),
        dictgen::InsensitiveStr::Ascii("ts"),
    ],
    values: &[
        &["experiment"],
        &["experimental"],
        &["experimentally"],
        &["experimentation"],
        &["experimentations"],
        &["experimented"],
        &["experimental"],
        &["experimentally"],
        &["experimenter"],
        &["experimenters"],
        &["experimenting"],
        &["experiments"],
        &["exemplar"],
        &["exemplars"],
        &["exemplary"],
        &["exempt"],
        &["exempted"],
        &["exempt"],
        &["exempted"],
        &["exemption"],
        &["exemptions"],
        &["exempts"],
    ],
    range: 1..=9,
};

static WORD_EXPEL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXPEL_CHILDREN),
    value: None,
};

pub static WORD_EXPEL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("l"),
        dictgen::InsensitiveStr::Ascii("ls"),
    ],
    values: &[&["expel"], &["expels"]],
    range: 1..=2,
};

static WORD_EXPEI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXPEI_CHILDREN),
    value: None,
};

pub static WORD_EXPEI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ence"),
        dictgen::InsensitiveStr::Ascii("enced"),
        dictgen::InsensitiveStr::Ascii("ences"),
        dictgen::InsensitiveStr::Ascii("encing"),
        dictgen::InsensitiveStr::Ascii("ment"),
        dictgen::InsensitiveStr::Ascii("mental"),
        dictgen::InsensitiveStr::Ascii("mentally"),
        dictgen::InsensitiveStr::Ascii("mentation"),
        dictgen::InsensitiveStr::Ascii("mentations"),
        dictgen::InsensitiveStr::Ascii("mented"),
        dictgen::InsensitiveStr::Ascii("mentel"),
        dictgen::InsensitiveStr::Ascii("mentelly"),
        dictgen::InsensitiveStr::Ascii("menter"),
        dictgen::InsensitiveStr::Ascii("menters"),
        dictgen::InsensitiveStr::Ascii("menting"),
        dictgen::InsensitiveStr::Ascii("ments"),
        dictgen::InsensitiveStr::Ascii("riment"),
        dictgen::InsensitiveStr::Ascii("rimental"),
        dictgen::InsensitiveStr::Ascii("rimentally"),
        dictgen::InsensitiveStr::Ascii("rimentation"),
        dictgen::InsensitiveStr::Ascii("rimentations"),
        dictgen::InsensitiveStr::Ascii("rimented"),
        dictgen::InsensitiveStr::Ascii("rimentel"),
        dictgen::InsensitiveStr::Ascii("rimentelly"),
        dictgen::InsensitiveStr::Ascii("rimenter"),
        dictgen::InsensitiveStr::Ascii("rimenters"),
        dictgen::InsensitiveStr::Ascii("rimenting"),
        dictgen::InsensitiveStr::Ascii("riments"),
    ],
    values: &[
        &["experience"],
        &["experienced"],
        &["experiences"],
        &["experiencing"],
        &["experiment"],
        &["experimental"],
        &["experimentally"],
        &["experimentation"],
        &["experimentations"],
        &["experimented"],
        &["experimental"],
        &["experimentally"],
        &["experimenter"],
        &["experimenters"],
        &["experimenting"],
        &["experiments"],
        &["experiment"],
        &["experimental"],
        &["experimentally"],
        &["experimentation"],
        &["experimentations"],
        &["experimented"],
        &["experimental"],
        &["experimentally"],
        &["experimenter"],
        &["experimenters"],
        &["experimenting"],
        &["experiments"],
    ],
    range: 4..=12,
};

static WORD_EXPEE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXPEE_CHILDREN),
    value: None,
};

pub static WORD_EXPEE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ct"),
        dictgen::InsensitiveStr::Ascii("cted"),
        dictgen::InsensitiveStr::Ascii("ctedly"),
        dictgen::InsensitiveStr::Ascii("cting"),
        dictgen::InsensitiveStr::Ascii("cts"),
        dictgen::InsensitiveStr::Ascii("nse"),
        dictgen::InsensitiveStr::Ascii("nses"),
        dictgen::InsensitiveStr::Ascii("nsive"),
    ],
    values: &[
        &["expect"],
        &["expected"],
        &["expectedly"],
        &["expecting"],
        &["expects"],
        &["expense"],
        &["expenses"],
        &["expensive"],
    ],
    range: 2..=6,
};

static WORD_EXPED_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXPED_CHILDREN),
    value: None,
};

pub static WORD_EXPED_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("etion"),
        dictgen::InsensitiveStr::Ascii("iated"),
        dictgen::InsensitiveStr::Ascii("icion"),
        dictgen::InsensitiveStr::Ascii("itivo"),
        dictgen::InsensitiveStr::Ascii("ito"),
        dictgen::InsensitiveStr::Ascii("itonary"),
    ],
    values: &[
        &["expedition"],
        &["expedited"],
        &["expedition"],
        &["expedition"],
        &["expedition"],
        &["expeditionary"],
    ],
    range: 3..=7,
};

static WORD_EXPEC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXPEC_CHILDREN),
    value: None,
};

pub static WORD_EXPEC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("eted"),
        dictgen::InsensitiveStr::Ascii("ially"),
        dictgen::InsensitiveStr::Ascii("taion"),
        dictgen::InsensitiveStr::Ascii("taions"),
        dictgen::InsensitiveStr::Ascii("tansy"),
        dictgen::InsensitiveStr::Ascii("tantcy"),
        dictgen::InsensitiveStr::Ascii("tany"),
        dictgen::InsensitiveStr::Ascii("tating"),
        dictgen::InsensitiveStr::Ascii("tatoins"),
        dictgen::InsensitiveStr::Ascii("tatons"),
        dictgen::InsensitiveStr::Ascii("td"),
        dictgen::InsensitiveStr::Ascii("te"),
        dictgen::InsensitiveStr::Ascii("tency"),
        dictgen::InsensitiveStr::Ascii("tes"),
        dictgen::InsensitiveStr::Ascii("tion"),
        dictgen::InsensitiveStr::Ascii("tional"),
        dictgen::InsensitiveStr::Ascii("tionally"),
        dictgen::InsensitiveStr::Ascii("tions"),
        dictgen::InsensitiveStr::Ascii("tus"),
    ],
    values: &[
        &["expected"],
        &["expected"],
        &["especially"],
        &["expectation"],
        &["expectations"],
        &["expectancy"],
        &["expectancy"],
        &["expectancy"],
        &["expectation"],
        &["expectations"],
        &["expectations"],
        &["expected"],
        &["expected"],
        &["expectancy"],
        &["expects"],
        &["exception", "expectation"],
        &["exceptional"],
        &["exceptionally"],
        &["exceptions", "expectations"],
        &["expects"],
    ],
    range: 2..=8,
};

static WORD_EXPC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXPC_CHILDREN),
    value: None,
};

pub static WORD_EXPC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eption"),
        dictgen::InsensitiveStr::Ascii("et"),
        dictgen::InsensitiveStr::Ascii("etation"),
        dictgen::InsensitiveStr::Ascii("etations"),
        dictgen::InsensitiveStr::Ascii("eted"),
        dictgen::InsensitiveStr::Ascii("eting"),
        dictgen::InsensitiveStr::Ascii("ets"),
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("ted"),
        dictgen::InsensitiveStr::Ascii("tedly"),
        dictgen::InsensitiveStr::Ascii("ting"),
    ],
    values: &[
        &["exception"],
        &["except", "expect"],
        &["expectation"],
        &["expectations"],
        &["expected"],
        &["expecting"],
        &["expects"],
        &["expect"],
        &["expected"],
        &["expectedly"],
        &["expecting"],
    ],
    range: 1..=8,
};

static WORD_EXPA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXPA_CHILDREN),
    value: None,
};

pub static WORD_EXPA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("lin"),
        dictgen::InsensitiveStr::Ascii("lined"),
        dictgen::InsensitiveStr::Ascii("lining"),
        dictgen::InsensitiveStr::Ascii("lins"),
        dictgen::InsensitiveStr::Ascii("nation"),
        dictgen::InsensitiveStr::Ascii("nations"),
        dictgen::InsensitiveStr::Ascii("nble"),
        dictgen::InsensitiveStr::Ascii("ndas"),
        dictgen::InsensitiveStr::Ascii("ndes"),
        dictgen::InsensitiveStr::Ascii("ned"),
        dictgen::InsensitiveStr::Ascii("ning"),
        dictgen::InsensitiveStr::Ascii("nion"),
        dictgen::InsensitiveStr::Ascii("nions"),
        dictgen::InsensitiveStr::Ascii("nisons"),
        dictgen::InsensitiveStr::Ascii("nisve"),
        dictgen::InsensitiveStr::Ascii("nshion"),
        dictgen::InsensitiveStr::Ascii("nshions"),
        dictgen::InsensitiveStr::Ascii("nsie"),
        dictgen::InsensitiveStr::Ascii("nsiones"),
        dictgen::InsensitiveStr::Ascii("nsivos"),
        dictgen::InsensitiveStr::Ascii("nssion"),
        dictgen::InsensitiveStr::Ascii("ntions"),
        dictgen::InsensitiveStr::Ascii("ration"),
        dictgen::InsensitiveStr::Ascii("sion"),
        dictgen::InsensitiveStr::Ascii("triot"),
    ],
    values: &[
        &["explain"],
        &["explained"],
        &["explaining"],
        &["explains"],
        &["explanation", "expansion"],
        &["explanations", "expansions"],
        &["expandable"],
        &["expands"],
        &["expands"],
        &["expand", "expanded", "explained"],
        &["expanding"],
        &["expansion"],
        &["expansions"],
        &["expansions"],
        &["expansive"],
        &["expansion"],
        &["expansions"],
        &["expansive"],
        &["expansions"],
        &["expansions"],
        &["expansions", "expansion"],
        &["expansions"],
        &["expiration"],
        &["expansion"],
        &["expatriate"],
    ],
    range: 3..=7,
};

static WORD_EXO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXO_CHILDREN),
    value: None,
};

pub static WORD_EXO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("itcs"),
        dictgen::InsensitiveStr::Ascii("licit"),
        dictgen::InsensitiveStr::Ascii("licitly"),
        dictgen::InsensitiveStr::Ascii("norate"),
        dictgen::InsensitiveStr::Ascii("rbatant"),
        dictgen::InsensitiveStr::Ascii("rbatent"),
        dictgen::InsensitiveStr::Ascii("rbidant"),
        dictgen::InsensitiveStr::Ascii("rbirant"),
        dictgen::InsensitiveStr::Ascii("rbitent"),
        dictgen::InsensitiveStr::Ascii("rt"),
        dictgen::InsensitiveStr::Ascii("rted"),
        dictgen::InsensitiveStr::Ascii("skelaton"),
        dictgen::InsensitiveStr::Ascii("ticas"),
        dictgen::InsensitiveStr::Ascii("ticos"),
    ],
    values: &[
        &["exotics"],
        &["explicit"],
        &["explicitly"],
        &["exonerate"],
        &["exorbitant"],
        &["exorbitant"],
        &["exorbitant"],
        &["exorbitant"],
        &["exorbitant"],
        &["export", "exhort"],
        &["exported", "extorted", "exerted"],
        &["exoskeleton"],
        &["exotics"],
        &["exotics"],
    ],
    range: 2..=8,
};

static WORD_EXN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXN_CHILDREN),
    value: None,
};

pub static WORD_EXN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ternal"),
        dictgen::InsensitiveStr::Ascii("ternalities"),
        dictgen::InsensitiveStr::Ascii("ternality"),
        dictgen::InsensitiveStr::Ascii("ternally"),
        dictgen::InsensitiveStr::Ascii("try"),
    ],
    values: &[
        &["external"],
        &["externalities"],
        &["externality"],
        &["externally"],
        &["entry"],
    ],
    range: 3..=11,
};

static WORD_EXM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXM_CHILDREN),
    value: None,
};

pub static WORD_EXM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aine"),
        dictgen::InsensitiveStr::Ascii("ained"),
        dictgen::InsensitiveStr::Ascii("aines"),
        dictgen::InsensitiveStr::Ascii("aple"),
        dictgen::InsensitiveStr::Ascii("aples"),
        dictgen::InsensitiveStr::Ascii("ple"),
        dictgen::InsensitiveStr::Ascii("port"),
    ],
    values: &[
        &["examine"],
        &["examined"],
        &["examines"],
        &["example"],
        &["examples"],
        &["example"],
        &["export"],
    ],
    range: 3..=5,
};

static WORD_EXL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXL_CHILDREN),
    value: None,
};

pub static WORD_EXL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("amation"),
        dictgen::InsensitiveStr::Ascii("ated"),
        dictgen::InsensitiveStr::Ascii("camation"),
        dictgen::InsensitiveStr::Ascii("cude"),
        dictgen::InsensitiveStr::Ascii("cuded"),
        dictgen::InsensitiveStr::Ascii("cudes"),
        dictgen::InsensitiveStr::Ascii("cuding"),
        dictgen::InsensitiveStr::Ascii("cusion"),
        dictgen::InsensitiveStr::Ascii("cusions"),
        dictgen::InsensitiveStr::Ascii("cusive"),
        dictgen::InsensitiveStr::Ascii("cusively"),
        dictgen::InsensitiveStr::Ascii("cusives"),
        dictgen::InsensitiveStr::Ascii("cusivity"),
        dictgen::InsensitiveStr::Ascii("icit"),
        dictgen::InsensitiveStr::Ascii("icite"),
        dictgen::InsensitiveStr::Ascii("icitely"),
        dictgen::InsensitiveStr::Ascii("icitly"),
        dictgen::InsensitiveStr::Ascii("iled"),
        dictgen::InsensitiveStr::Ascii("poding"),
        dictgen::InsensitiveStr::Ascii("poit"),
        dictgen::InsensitiveStr::Ascii("poited"),
        dictgen::InsensitiveStr::Ascii("poits"),
        dictgen::InsensitiveStr::Ascii("porer"),
        dictgen::InsensitiveStr::Ascii("porers"),
        dictgen::InsensitiveStr::Ascii("posion"),
        dictgen::InsensitiveStr::Ascii("ude"),
        dictgen::InsensitiveStr::Ascii("uded"),
        dictgen::InsensitiveStr::Ascii("udes"),
        dictgen::InsensitiveStr::Ascii("uding"),
        dictgen::InsensitiveStr::Ascii("usion"),
        dictgen::InsensitiveStr::Ascii("usionary"),
        dictgen::InsensitiveStr::Ascii("usions"),
        dictgen::InsensitiveStr::Ascii("usive"),
        dictgen::InsensitiveStr::Ascii("usively"),
    ],
    values: &[
        &["exclamation"],
        &["exalted"],
        &["exclamation"],
        &["exclude"],
        &["excluded"],
        &["excludes"],
        &["excluding"],
        &["exclusion"],
        &["exclusions"],
        &["exclusive"],
        &["exclusively"],
        &["exclusives"],
        &["exclusivity"],
        &["explicit"],
        &["explicit"],
        &["explicitly"],
        &["explicitly"],
        &["exiled"],
        &["exploding"],
        &["exploit"],
        &["exploited"],
        &["exploits"],
        &["explorer"],
        &["explorers"],
        &["explosion"],
        &["exclude", "exude"],
        &["excluded", "exuded"],
        &["excludes", "exudes"],
        &["excluding", "exuding"],
        &["exclusion"],
        &["exclusionary"],
        &["exclusions"],
        &["exclusive"],
        &["exclusively"],
    ],
    range: 3..=8,
};

static WORD_EXI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXI_CHILDREN),
    value: None,
};

pub static WORD_EXI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("bition"),
        dictgen::InsensitiveStr::Ascii("bitions"),
        dictgen::InsensitiveStr::Ascii("ctement"),
        dictgen::InsensitiveStr::Ascii("cting"),
        dictgen::InsensitiveStr::Ascii("lerate"),
        dictgen::InsensitiveStr::Ascii("lerated"),
        dictgen::InsensitiveStr::Ascii("lerates"),
        dictgen::InsensitiveStr::Ascii("lerating"),
        dictgen::InsensitiveStr::Ascii("nct"),
        dictgen::InsensitiveStr::Ascii("pration"),
        dictgen::InsensitiveStr::Ascii("pre"),
        dictgen::InsensitiveStr::Ascii("pred"),
        dictgen::InsensitiveStr::Ascii("pres"),
        dictgen::InsensitiveStr::Ascii("sing"),
        dictgen::InsensitiveStr::Ascii("sit"),
        dictgen::InsensitiveStr::Ascii("sited"),
        dictgen::InsensitiveStr::Ascii("sitent"),
        dictgen::InsensitiveStr::Ascii("siting"),
        dictgen::InsensitiveStr::Ascii("sitng"),
        dictgen::InsensitiveStr::Ascii("sits"),
        dictgen::InsensitiveStr::Ascii("stance"),
        dictgen::InsensitiveStr::Ascii("stane"),
        dictgen::InsensitiveStr::Ascii("stant"),
        dictgen::InsensitiveStr::Ascii("stantes"),
        dictgen::InsensitiveStr::Ascii("stantial"),
        dictgen::InsensitiveStr::Ascii("status"),
        dictgen::InsensitiveStr::Ascii("stencd"),
        dictgen::InsensitiveStr::Ascii("stencial"),
        dictgen::InsensitiveStr::Ascii("stend"),
        dictgen::InsensitiveStr::Ascii("stenial"),
        dictgen::InsensitiveStr::Ascii("stense"),
        dictgen::InsensitiveStr::Ascii("stensial"),
        dictgen::InsensitiveStr::Ascii("stenta"),
        dictgen::InsensitiveStr::Ascii("stental"),
        dictgen::InsensitiveStr::Ascii("stentiel"),
        dictgen::InsensitiveStr::Ascii("stentiella"),
        dictgen::InsensitiveStr::Ascii("stet"),
        dictgen::InsensitiveStr::Ascii("stin"),
        dictgen::InsensitiveStr::Ascii("stince"),
        dictgen::InsensitiveStr::Ascii("stnace"),
        dictgen::InsensitiveStr::Ascii("stng"),
        dictgen::InsensitiveStr::Ascii("stsing"),
        dictgen::InsensitiveStr::Ascii("stting"),
        dictgen::InsensitiveStr::Ascii("stung"),
        dictgen::InsensitiveStr::Ascii("sty"),
        dictgen::InsensitiveStr::Ascii("stying"),
        dictgen::InsensitiveStr::Ascii("tance"),
        dictgen::InsensitiveStr::Ascii("tation"),
        dictgen::InsensitiveStr::Ascii("tations"),
        dictgen::InsensitiveStr::Ascii("te"),
        dictgen::InsensitiveStr::Ascii("tsing"),
        dictgen::InsensitiveStr::Ascii("tss"),
        dictgen::InsensitiveStr::Ascii("tt"),
        dictgen::InsensitiveStr::Ascii("tted"),
        dictgen::InsensitiveStr::Ascii("tting"),
        dictgen::InsensitiveStr::Ascii("tts"),
        dictgen::InsensitiveStr::Ascii("xst"),
        dictgen::InsensitiveStr::Ascii("xt"),
    ],
    values: &[
        &["exhibition"],
        &["exhibitions"],
        &["excitement"],
        &["exciting"],
        &["exhilarate"],
        &["exhilarated"],
        &["exhilarates"],
        &["exhilarating"],
        &["extinct"],
        &["expiration"],
        &["expire"],
        &["expired"],
        &["expires"],
        &["existing"],
        &["exist"],
        &["existed"],
        &["existent"],
        &["existing"],
        &["existing"],
        &["exists"],
        &["existence"],
        &["existence"],
        &["existent"],
        &["existent"],
        &["existential"],
        &["exitstatus"],
        &["existence"],
        &["existential"],
        &["existed", "existent"],
        &["existential"],
        &["existence"],
        &["existential"],
        &["existential"],
        &["existential"],
        &["existential"],
        &["existential"],
        &["existent"],
        &["existing"],
        &["existence"],
        &["existence"],
        &["existing"],
        &["existing"],
        &["existing"],
        &["existing"],
        &["exist"],
        &["existing"],
        &["existence"],
        &["excitation"],
        &["excitations"],
        &["exit", "excite", "exits"],
        &["existing", "exiting"],
        &["exists", "exits"],
        &["exit"],
        &["exited"],
        &["exiting"],
        &["exits"],
        &["exist"],
        &["exist"],
    ],
    range: 2..=10,
};

static WORD_EXH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXH_CHILDREN),
    value: None,
};

pub static WORD_EXH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("alted"),
        dictgen::InsensitiveStr::Ascii("ange"),
        dictgen::InsensitiveStr::Ascii("anged"),
        dictgen::InsensitiveStr::Ascii("anges"),
        dictgen::InsensitiveStr::Ascii("anging"),
        dictgen::InsensitiveStr::Ascii("asut"),
        dictgen::InsensitiveStr::Ascii("asuted"),
        dictgen::InsensitiveStr::Ascii("asuting"),
        dictgen::InsensitiveStr::Ascii("asution"),
        dictgen::InsensitiveStr::Ascii("asutive"),
        dictgen::InsensitiveStr::Ascii("aused"),
        dictgen::InsensitiveStr::Ascii("austin"),
        dictgen::InsensitiveStr::Ascii("austivo"),
        dictgen::InsensitiveStr::Ascii("austn"),
        dictgen::InsensitiveStr::Ascii("austo"),
        dictgen::InsensitiveStr::Ascii("autivity"),
        dictgen::InsensitiveStr::Ascii("cuast"),
        dictgen::InsensitiveStr::Ascii("cuasted"),
        dictgen::InsensitiveStr::Ascii("ibicion"),
        dictgen::InsensitiveStr::Ascii("ibites"),
        dictgen::InsensitiveStr::Ascii("ibitin"),
        dictgen::InsensitiveStr::Ascii("ibitons"),
        dictgen::InsensitiveStr::Ascii("ibtion"),
        dictgen::InsensitiveStr::Ascii("ilerate"),
        dictgen::InsensitiveStr::Ascii("ilerated"),
        dictgen::InsensitiveStr::Ascii("ilerates"),
        dictgen::InsensitiveStr::Ascii("ilerating"),
        dictgen::InsensitiveStr::Ascii("ist"),
        dictgen::InsensitiveStr::Ascii("istance"),
        dictgen::InsensitiveStr::Ascii("isted"),
        dictgen::InsensitiveStr::Ascii("istence"),
        dictgen::InsensitiveStr::Ascii("isting"),
        dictgen::InsensitiveStr::Ascii("ists"),
        dictgen::InsensitiveStr::Ascii("orbitent"),
        dictgen::InsensitiveStr::Ascii("orbitently"),
        dictgen::InsensitiveStr::Ascii("ostive"),
        dictgen::InsensitiveStr::Ascii("uast"),
        dictgen::InsensitiveStr::Ascii("uasted"),
        dictgen::InsensitiveStr::Ascii("uasting"),
        dictgen::InsensitiveStr::Ascii("uastion"),
        dictgen::InsensitiveStr::Ascii("ustiveness"),
    ],
    values: &[
        &["exalted"],
        &["exchange"],
        &["exchanged"],
        &["exchanges"],
        &["exchanging"],
        &["exhaust"],
        &["exhausted"],
        &["exhausting"],
        &["exhaustion"],
        &["exhaustive"],
        &["exhausted"],
        &["exhaustion"],
        &["exhaustion"],
        &["exhaustion"],
        &["exhaustion"],
        &["exhaustivity"],
        &["exhaust"],
        &["exhausted"],
        &["exhibition"],
        &["exhibits"],
        &["exhibition"],
        &["exhibits"],
        &["exhibition"],
        &["exhilarate"],
        &["exhilarated"],
        &["exhilarates"],
        &["exhilarating"],
        &["exist"],
        &["existence"],
        &["existed"],
        &["existence"],
        &["existing"],
        &["exists"],
        &["exorbitant"],
        &["exorbitantly"],
        &["exhaustive"],
        &["exhaust"],
        &["exhausted"],
        &["exhausting"],
        &["exhaustion"],
        &["exhaustiveness"],
    ],
    range: 3..=10,
};

static WORD_EXE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_EXE_CHILDREN),
    value: None,
};

static WORD_EXE_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    Some(&WORD_EXEC_NODE),
    None,
    Some(&WORD_EXEE_NODE),
    None,
    Some(&WORD_EXEG_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_EXEL_NODE),
    Some(&WORD_EXEM_NODE),
    Some(&WORD_EXEN_NODE),
    None,
    Some(&WORD_EXEP_NODE),
    Some(&WORD_EXEQ_NODE),
    Some(&WORD_EXER_NODE),
    Some(&WORD_EXES_NODE),
    None,
    Some(&WORD_EXEU_NODE),
    None,
    None,
    Some(&WORD_EXEX_NODE),
    None,
    None,
];

static WORD_EXEX_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXEX_CHILDREN),
    value: None,
};

pub static WORD_EXEX_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("utable")],
    values: &[&["executable"]],
    range: 6..=6,
};

static WORD_EXEU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXEU_CHILDREN),
    value: None,
};

pub static WORD_EXEU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cte"),
        dictgen::InsensitiveStr::Ascii("cted"),
        dictgen::InsensitiveStr::Ascii("ctes"),
        dictgen::InsensitiveStr::Ascii("cting"),
        dictgen::InsensitiveStr::Ascii("ction"),
        dictgen::InsensitiveStr::Ascii("ctioner"),
        dictgen::InsensitiveStr::Ascii("ctions"),
        dictgen::InsensitiveStr::Ascii("tion"),
    ],
    values: &[
        &["execute"],
        &["executed"],
        &["executes"],
        &["executing"],
        &["execution"],
        &["executioner"],
        &["executions"],
        &["execution"],
    ],
    range: 3..=7,
};

static WORD_EXES_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXES_CHILDREN),
    value: None,
};

pub static WORD_EXES_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("sive")],
    values: &[&["excessive"]],
    range: 4..=4,
};

static WORD_EXER_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXER_CHILDREN),
    value: None,
};

pub static WORD_EXER_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("bate"),
        dictgen::InsensitiveStr::Ascii("bated"),
        dictgen::InsensitiveStr::Ascii("cices"),
        dictgen::InsensitiveStr::Ascii("cicing"),
        dictgen::InsensitiveStr::Ascii("cide"),
        dictgen::InsensitiveStr::Ascii("cies"),
        dictgen::InsensitiveStr::Ascii("ciese"),
        dictgen::InsensitiveStr::Ascii("ciesed"),
        dictgen::InsensitiveStr::Ascii("cieses"),
        dictgen::InsensitiveStr::Ascii("ciesing"),
        dictgen::InsensitiveStr::Ascii("ciseing"),
        dictgen::InsensitiveStr::Ascii("cize"),
        dictgen::InsensitiveStr::Ascii("cized"),
        dictgen::InsensitiveStr::Ascii("cizes"),
        dictgen::InsensitiveStr::Ascii("cizing"),
        dictgen::InsensitiveStr::Ascii("imental"),
        dictgen::InsensitiveStr::Ascii("nal"),
        dictgen::InsensitiveStr::Ascii("pt"),
        dictgen::InsensitiveStr::Ascii("pts"),
        dictgen::InsensitiveStr::Ascii("sice"),
        dictgen::InsensitiveStr::Ascii("siced"),
        dictgen::InsensitiveStr::Ascii("sices"),
        dictgen::InsensitiveStr::Ascii("sicing"),
        dictgen::InsensitiveStr::Ascii("sise"),
        dictgen::InsensitiveStr::Ascii("sised"),
        dictgen::InsensitiveStr::Ascii("sises"),
        dictgen::InsensitiveStr::Ascii("sising"),
        dictgen::InsensitiveStr::Ascii("size"),
        dictgen::InsensitiveStr::Ascii("sized"),
        dictgen::InsensitiveStr::Ascii("sizes"),
        dictgen::InsensitiveStr::Ascii("sizing"),
        dictgen::InsensitiveStr::Ascii("ternal"),
    ],
    values: &[
        &["exacerbate"],
        &["exacerbated"],
        &["exercise"],
        &["exercising"],
        &["exercised"],
        &["exercise"],
        &["exercises", "exercise"],
        &["exercised"],
        &["exercises"],
        &["exercising"],
        &["exercising"],
        &["exercise"],
        &["exercised"],
        &["exercise", "exercises"],
        &["exercising"],
        &["experimental"],
        &["external"],
        &["excerpt"],
        &["excerpts"],
        &["exercise"],
        &["exercised"],
        &["exercises"],
        &["exercising"],
        &["exercise"],
        &["exercised"],
        &["exercises"],
        &["exercising"],
        &["exercise"],
        &["exercised"],
        &["exercises"],
        &["exercising"],
        &["external"],
    ],
    range: 2..=7,
};

static WORD_EXEQ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXEQ_CHILDREN),
    value: None,
};

pub static WORD_EXEQ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ution")],
    values: &[&["execution"]],
    range: 5..=5,
};

static WORD_EXEP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXEP_CHILDREN),
    value: None,
};

pub static WORD_EXEP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ct"),
        dictgen::InsensitiveStr::Ascii("cted"),
        dictgen::InsensitiveStr::Ascii("cts"),
        dictgen::InsensitiveStr::Ascii("ect"),
        dictgen::InsensitiveStr::Ascii("ectation"),
        dictgen::InsensitiveStr::Ascii("ectations"),
        dictgen::InsensitiveStr::Ascii("ected"),
        dictgen::InsensitiveStr::Ascii("ectedly"),
        dictgen::InsensitiveStr::Ascii("ecting"),
        dictgen::InsensitiveStr::Ascii("ects"),
        dictgen::InsensitiveStr::Ascii("mtion"),
        dictgen::InsensitiveStr::Ascii("mtions"),
        dictgen::InsensitiveStr::Ascii("riment"),
        dictgen::InsensitiveStr::Ascii("rimental"),
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("tion"),
        dictgen::InsensitiveStr::Ascii("tional"),
        dictgen::InsensitiveStr::Ascii("tions"),
    ],
    values: &[
        &["expect"],
        &["expected"],
        &["expects"],
        &["expect"],
        &["expectation"],
        &["expectations"],
        &["expected"],
        &["expectedly"],
        &["expecting"],
        &["expects"],
        &["exemption"],
        &["exemptions"],
        &["experiment"],
        &["experimental"],
        &["except", "exempt"],
        &["exception", "exemption"],
        &["exceptional"],
        &["exceptions"],
    ],
    range: 1..=9,
};

static WORD_EXEN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXEN_CHILDREN),
    value: None,
};

pub static WORD_EXEN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ded"),
        dictgen::InsensitiveStr::Ascii("sion"),
        dictgen::InsensitiveStr::Ascii("sions"),
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("tended"),
    ],
    values: &[
        &["extended"],
        &["extension"],
        &["extensions"],
        &["extent"],
        &["extended"],
    ],
    range: 1..=6,
};

static WORD_EXEM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXEM_CHILDREN),
    value: None,
};

pub static WORD_EXEM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("pel"),
        dictgen::InsensitiveStr::Ascii("pels"),
        dictgen::InsensitiveStr::Ascii("ple"),
        dictgen::InsensitiveStr::Ascii("ples"),
    ],
    values: &[&["example"], &["examples"], &["example"], &["examples"]],
    range: 3..=4,
};

static WORD_EXEL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXEL_CHILDREN),
    value: None,
};

pub static WORD_EXEL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ent"),
        dictgen::InsensitiveStr::Ascii("lent"),
    ],
    values: &[&["excellent"], &["excellent"]],
    range: 3..=4,
};

static WORD_EXEG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXEG_CHILDREN),
    value: None,
};

pub static WORD_EXEG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("gerating"),
        dictgen::InsensitiveStr::Ascii("geration"),
    ],
    values: &[&["exaggerating"], &["exaggeration"]],
    range: 8..=8,
};

static WORD_EXEE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXEE_CHILDREN),
    value: None,
};

pub static WORD_EXEE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("d"),
        dictgen::InsensitiveStr::Ascii("ding"),
        dictgen::InsensitiveStr::Ascii("dingly"),
        dictgen::InsensitiveStr::Ascii("ds"),
    ],
    values: &[&["exceed"], &["exceeding"], &["exceedingly"], &["exceeds"]],
    range: 1..=6,
};

static WORD_EXEC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_EXEC_CHILDREN),
    value: None,
};

static WORD_EXEC_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    None,
    None,
    Some(&WORD_EXECE_NODE),
    None,
    None,
    None,
    Some(&WORD_EXECI_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_EXECP_NODE),
    None,
    None,
    None,
    Some(&WORD_EXECT_NODE),
    Some(&WORD_EXECU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_EXECU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_EXECU_CHILDREN),
    value: None,
};

static WORD_EXECU_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_EXECUA_NODE),
    Some(&WORD_EXECUB_NODE),
    Some(&WORD_EXECUC_NODE),
    Some(&WORD_EXECUD_NODE),
    Some(&WORD_EXECUE_NODE),
    None,
    None,
    None,
    Some(&WORD_EXECUI_NODE),
    None,
    None,
    Some(&WORD_EXECUL_NODE),
    None,
    Some(&WORD_EXECUN_NODE),
    None,
    None,
    None,
    Some(&WORD_EXECUR_NODE),
    Some(&WORD_EXECUS_NODE),
    Some(&WORD_EXECUT_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_EXECUT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXECUT_CHILDREN),
    value: Some(&["execute"]),
};

pub static WORD_EXECUT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("abable"),
        dictgen::InsensitiveStr::Ascii("abables"),
        dictgen::InsensitiveStr::Ascii("abe"),
        dictgen::InsensitiveStr::Ascii("abel"),
        dictgen::InsensitiveStr::Ascii("abels"),
        dictgen::InsensitiveStr::Ascii("abes"),
        dictgen::InsensitiveStr::Ascii("abil"),
        dictgen::InsensitiveStr::Ascii("ablble"),
        dictgen::InsensitiveStr::Ascii("abnle"),
        dictgen::InsensitiveStr::Ascii("abnles"),
        dictgen::InsensitiveStr::Ascii("ation"),
        dictgen::InsensitiveStr::Ascii("ations"),
        dictgen::InsensitiveStr::Ascii("bale"),
        dictgen::InsensitiveStr::Ascii("bales"),
        dictgen::InsensitiveStr::Ascii("ble"),
        dictgen::InsensitiveStr::Ascii("bles"),
        dictgen::InsensitiveStr::Ascii("d"),
        dictgen::InsensitiveStr::Ascii("ding"),
        dictgen::InsensitiveStr::Ascii("eable"),
        dictgen::InsensitiveStr::Ascii("eables"),
        dictgen::InsensitiveStr::Ascii("ible"),
        dictgen::InsensitiveStr::Ascii("ie"),
        dictgen::InsensitiveStr::Ascii("ign"),
        dictgen::InsensitiveStr::Ascii("in"),
        dictgen::InsensitiveStr::Ascii("iner"),
        dictgen::InsensitiveStr::Ascii("ings"),
        dictgen::InsensitiveStr::Ascii("ionar"),
        dictgen::InsensitiveStr::Ascii("ioneer"),
        dictgen::InsensitiveStr::Ascii("ioneers"),
        dictgen::InsensitiveStr::Ascii("ionees"),
        dictgen::InsensitiveStr::Ascii("ioness"),
        dictgen::InsensitiveStr::Ascii("iong"),
        dictgen::InsensitiveStr::Ascii("ionier"),
        dictgen::InsensitiveStr::Ascii("ionner"),
        dictgen::InsensitiveStr::Ascii("ionor"),
        dictgen::InsensitiveStr::Ascii("ivas"),
        dictgen::InsensitiveStr::Ascii("ng"),
        dictgen::InsensitiveStr::Ascii("on"),
        dictgen::InsensitiveStr::Ascii("re"),
        dictgen::InsensitiveStr::Ascii("red"),
        dictgen::InsensitiveStr::Ascii("res"),
        dictgen::InsensitiveStr::Ascii("s"),
        dictgen::InsensitiveStr::Ascii("ting"),
        dictgen::InsensitiveStr::Ascii("tion"),
        dictgen::InsensitiveStr::Ascii("tions"),
        dictgen::InsensitiveStr::Ascii("uable"),
        dictgen::InsensitiveStr::Ascii("uables"),
        dictgen::InsensitiveStr::Ascii("uble"),
        dictgen::InsensitiveStr::Ascii("ubles"),
        dictgen::InsensitiveStr::Ascii("ue"),
        dictgen::InsensitiveStr::Ascii("ued"),
        dictgen::InsensitiveStr::Ascii("ues"),
        dictgen::InsensitiveStr::Ascii("uing"),
        dictgen::InsensitiveStr::Ascii("uion"),
        dictgen::InsensitiveStr::Ascii("uions"),
        dictgen::InsensitiveStr::Ascii("ung"),
        dictgen::InsensitiveStr::Ascii("uon"),
        dictgen::InsensitiveStr::Ascii("uons"),
        dictgen::InsensitiveStr::Ascii("ute"),
        dictgen::InsensitiveStr::Ascii("uted"),
        dictgen::InsensitiveStr::Ascii("utes"),
        dictgen::InsensitiveStr::Ascii("ution"),
        dictgen::InsensitiveStr::Ascii("utions"),
    ],
    values: &[
        &["executable"],
        &["executables"],
        &["executable"],
        &["executable"],
        &["executables"],
        &["executables"],
        &["executable"],
        &["executable"],
        &["executable"],
        &["executables"],
        &["execution"],
        &["executions"],
        &["executable"],
        &["executables"],
        &["executable"],
        &["executables"],
        &["executed"],
        &["executing"],
        &["executable"],
        &["executables"],
        &["executable"],
        &["executive"],
        &["executing"],
        &["execution"],
        &["executioner"],
        &["executions"],
        &["executioner"],
        &["executioner"],
        &["executioner"],
        &["executions"],
        &["executions"],
        &["execution", "executing"],
        &["executioner"],
        &["executioner"],
        &["executioner"],
        &["executives"],
        &["executing"],
        &["execution"],
        &["execute"],
        &["executed"],
        &["executes"],
        &["executes"],
        &["executing"],
        &["execution"],
        &["executions"],
        &["executable"],
        &["executables"],
        &["executable"],
        &["executables"],
        &["execute"],
        &["executed"],
        &["executes"],
        &["executing"],
        &["execution"],
        &["executions"],
        &["executing"],
        &["execution"],
        &["executions"],
        &["execute"],
        &["executed"],
        &["executes"],
        &["execution"],
        &["executions"],
    ],
    range: 1..=7,
};

static WORD_EXECUS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXECUS_CHILDREN),
    value: None,
};

pub static WORD_EXECUS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("ion"),
        dictgen::InsensitiveStr::Ascii("ions"),
        dictgen::InsensitiveStr::Ascii("ive"),
        dictgen::InsensitiveStr::Ascii("tion"),
        dictgen::InsensitiveStr::Ascii("tions"),
    ],
    values: &[
        &["excuse", "execute"],
        &["excused", "executed"],
        &["excuses", "executes"],
        &["execution"],
        &["executions"],
        &["exclusive"],
        &["execution"],
        &["executions"],
    ],
    range: 1..=5,
};

static WORD_EXECUR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXECUR_CHILDREN),
    value: None,
};

pub static WORD_EXECUR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("able"),
        dictgen::InsensitiveStr::Ascii("ables"),
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("es"),
    ],
    values: &[
        &["executable"],
        &["executables"],
        &["execute"],
        &["executed"],
        &["executes"],
    ],
    range: 1..=5,
};

static WORD_EXECUN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXECUN_CHILDREN),
    value: None,
};

pub static WORD_EXECUN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("ting"),
    ],
    values: &[&["execute"], &["executed"], &["executes"], &["executing"]],
    range: 1..=4,
};

static WORD_EXECUL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXECUL_CHILDREN),
    value: None,
};

pub static WORD_EXECUL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("atble"),
        dictgen::InsensitiveStr::Ascii("atbles"),
        dictgen::InsensitiveStr::Ascii("table"),
        dictgen::InsensitiveStr::Ascii("tables"),
        dictgen::InsensitiveStr::Ascii("usive"),
    ],
    values: &[
        &["executable"],
        &["executables"],
        &["executable"],
        &["executables"],
        &["exclusive"],
    ],
    range: 5..=6,
};

static WORD_EXECUI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXECUI_CHILDREN),
    value: None,
};

pub static WORD_EXECUI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ng"),
        dictgen::InsensitiveStr::Ascii("on"),
        dictgen::InsensitiveStr::Ascii("ons"),
        dictgen::InsensitiveStr::Ascii("table"),
        dictgen::InsensitiveStr::Ascii("tables"),
        dictgen::InsensitiveStr::Ascii("te"),
        dictgen::InsensitiveStr::Ascii("ted"),
        dictgen::InsensitiveStr::Ascii("tes"),
        dictgen::InsensitiveStr::Ascii("ting"),
        dictgen::InsensitiveStr::Ascii("tion"),
        dictgen::InsensitiveStr::Ascii("tions"),
    ],
    values: &[
        &["executing"],
        &["execution"],
        &["executions"],
        &["executable"],
        &["executables"],
        &["execute"],
        &["executed"],
        &["executes"],
        &["executing"],
        &["execution"],
        &["executions"],
    ],
    range: 2..=6,
};

static WORD_EXECUE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXECUE_CHILDREN),
    value: Some(&["execute"]),
};

pub static WORD_EXECUE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("d"),
        dictgen::InsensitiveStr::Ascii("s"),
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("table"),
        dictgen::InsensitiveStr::Ascii("td"),
        dictgen::InsensitiveStr::Ascii("te"),
        dictgen::InsensitiveStr::Ascii("ted"),
        dictgen::InsensitiveStr::Ascii("tes"),
        dictgen::InsensitiveStr::Ascii("ts"),
    ],
    values: &[
        &["executed"],
        &["executes"],
        &["execute"],
        &["executable"],
        &["executed"],
        &["execute"],
        &["executed"],
        &["executes"],
        &["executes"],
    ],
    range: 1..=5,
};

static WORD_EXECUD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXECUD_CHILDREN),
    value: None,
};

pub static WORD_EXECUD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("ing"),
    ],
    values: &[
        &["execute"],
        &["executed"],
        &["executes"],
        &["executing", "excluding"],
    ],
    range: 1..=3,
};

static WORD_EXECUC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXECUC_CHILDREN),
    value: None,
};

pub static WORD_EXECUC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("te"),
        dictgen::InsensitiveStr::Ascii("ted"),
        dictgen::InsensitiveStr::Ascii("tes"),
        dictgen::InsensitiveStr::Ascii("tion"),
        dictgen::InsensitiveStr::Ascii("tions"),
        dictgen::InsensitiveStr::Ascii("tor"),
        dictgen::InsensitiveStr::Ascii("tors"),
    ],
    values: &[
        &["execute"],
        &["executed"],
        &["executes"],
        &["execution"],
        &["executions"],
        &["executor"],
        &["executors"],
    ],
    range: 2..=5,
};

static WORD_EXECUB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXECUB_CHILDREN),
    value: None,
};

pub static WORD_EXECUB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ale"),
        dictgen::InsensitiveStr::Ascii("ales"),
    ],
    values: &[&["executable"], &["executables"]],
    range: 3..=4,
};

static WORD_EXECUA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXECUA_CHILDREN),
    value: None,
};

pub static WORD_EXECUA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ble"),
        dictgen::InsensitiveStr::Ascii("bles"),
        dictgen::InsensitiveStr::Ascii("table"),
        dictgen::InsensitiveStr::Ascii("tables"),
        dictgen::InsensitiveStr::Ascii("tble"),
        dictgen::InsensitiveStr::Ascii("tbles"),
        dictgen::InsensitiveStr::Ascii("te"),
        dictgen::InsensitiveStr::Ascii("ted"),
        dictgen::InsensitiveStr::Ascii("tes"),
        dictgen::InsensitiveStr::Ascii("tion"),
        dictgen::InsensitiveStr::Ascii("tions"),
    ],
    values: &[
        &["executable"],
        &["executables"],
        &["executable"],
        &["executables"],
        &["executable"],
        &["executables"],
        &["execute"],
        &["executed"],
        &["executes"],
        &["execution"],
        &["executions"],
    ],
    range: 2..=6,
};

static WORD_EXECT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXECT_CHILDREN),
    value: None,
};

pub static WORD_EXECT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("able"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("ion"),
        dictgen::InsensitiveStr::Ascii("ions"),
        dictgen::InsensitiveStr::Ascii("uable"),
        dictgen::InsensitiveStr::Ascii("uableness"),
        dictgen::InsensitiveStr::Ascii("uables"),
        dictgen::InsensitiveStr::Ascii("ued"),
        dictgen::InsensitiveStr::Ascii("uing"),
        dictgen::InsensitiveStr::Ascii("uion"),
        dictgen::InsensitiveStr::Ascii("uioner"),
        dictgen::InsensitiveStr::Ascii("uioners"),
        dictgen::InsensitiveStr::Ascii("uions"),
        dictgen::InsensitiveStr::Ascii("uive"),
        dictgen::InsensitiveStr::Ascii("uives"),
        dictgen::InsensitiveStr::Ascii("ure"),
        dictgen::InsensitiveStr::Ascii("ured"),
        dictgen::InsensitiveStr::Ascii("ures"),
        dictgen::InsensitiveStr::Ascii("uring"),
        dictgen::InsensitiveStr::Ascii("ute"),
        dictgen::InsensitiveStr::Ascii("uted"),
        dictgen::InsensitiveStr::Ascii("utes"),
        dictgen::InsensitiveStr::Ascii("ution"),
        dictgen::InsensitiveStr::Ascii("utions"),
    ],
    values: &[
        &["executable"],
        &["executed", "expected"],
        &["executing", "expecting"],
        &["execution"],
        &["executions"],
        &["executable"],
        &["executableness"],
        &["executable", "executables"],
        &["executed"],
        &["executing"],
        &["execution"],
        &["executioner"],
        &["executioner"],
        &["executions"],
        &["executive"],
        &["executives"],
        &["execute"],
        &["executed"],
        &["executes"],
        &["executing"],
        &["execute"],
        &["executed"],
        &["executes"],
        &["execution"],
        &["executions"],
    ],
    range: 2..=9,
};

static WORD_EXECP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXECP_CHILDREN),
    value: None,
};

pub static WORD_EXECP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("tion"),
        dictgen::InsensitiveStr::Ascii("tional"),
        dictgen::InsensitiveStr::Ascii("tions"),
    ],
    values: &[&["exception"], &["exceptional"], &["exceptions"]],
    range: 4..=6,
};

static WORD_EXECI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXECI_CHILDREN),
    value: None,
};

pub static WORD_EXECI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("on"),
        dictgen::InsensitiveStr::Ascii("se"),
        dictgen::InsensitiveStr::Ascii("sed"),
        dictgen::InsensitiveStr::Ascii("ses"),
        dictgen::InsensitiveStr::Ascii("sing"),
        dictgen::InsensitiveStr::Ascii("tioner"),
    ],
    values: &[
        &["execution"],
        &["excise", "exercise"],
        &["excised", "exercised"],
        &["excises", "exercises"],
        &["exercising"],
        &["executioner"],
    ],
    range: 2..=6,
};

static WORD_EXECE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXECE_CHILDREN),
    value: None,
};

pub static WORD_EXECE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cutable"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("eded"),
        dictgen::InsensitiveStr::Ascii("eds"),
        dictgen::InsensitiveStr::Ascii("pt"),
        dictgen::InsensitiveStr::Ascii("ption"),
        dictgen::InsensitiveStr::Ascii("ptions"),
    ],
    values: &[
        &["executable"],
        &["exceed"],
        &["exceeded"],
        &["exceeds"],
        &["except"],
        &["exception"],
        &["exceptions"],
    ],
    range: 2..=7,
};

static WORD_EXC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_EXC_CHILDREN),
    value: None,
};

static WORD_EXC_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_EXCA_NODE),
    None,
    Some(&WORD_EXCC_NODE),
    None,
    Some(&WORD_EXCE_NODE),
    None,
    None,
    Some(&WORD_EXCH_NODE),
    Some(&WORD_EXCI_NODE),
    None,
    None,
    Some(&WORD_EXCL_NODE),
    None,
    None,
    Some(&WORD_EXCO_NODE),
    Some(&WORD_EXCP_NODE),
    None,
    Some(&WORD_EXCR_NODE),
    None,
    Some(&WORD_EXCT_NODE),
    Some(&WORD_EXCU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_EXCU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXCU_CHILDREN),
    value: None,
};

pub static WORD_EXCU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("lde"),
        dictgen::InsensitiveStr::Ascii("lded"),
        dictgen::InsensitiveStr::Ascii("ldes"),
        dictgen::InsensitiveStr::Ascii("lding"),
        dictgen::InsensitiveStr::Ascii("lsion"),
        dictgen::InsensitiveStr::Ascii("lsive"),
        dictgen::InsensitiveStr::Ascii("lsively"),
        dictgen::InsensitiveStr::Ascii("lsives"),
        dictgen::InsensitiveStr::Ascii("lsivity"),
        dictgen::InsensitiveStr::Ascii("lsivly"),
        dictgen::InsensitiveStr::Ascii("rciating"),
        dictgen::InsensitiveStr::Ascii("table"),
        dictgen::InsensitiveStr::Ascii("tables"),
        dictgen::InsensitiveStr::Ascii("te"),
        dictgen::InsensitiveStr::Ascii("ted"),
        dictgen::InsensitiveStr::Ascii("tes"),
        dictgen::InsensitiveStr::Ascii("ting"),
        dictgen::InsensitiveStr::Ascii("tion"),
    ],
    values: &[
        &["exclude"],
        &["excluded"],
        &["excludes"],
        &["excluding"],
        &["exclusion"],
        &["exclusive"],
        &["exclusively"],
        &["exclusives"],
        &["exclusivity"],
        &["exclusively"],
        &["excruciating"],
        &["executable"],
        &["executables"],
        &["execute"],
        &["executed"],
        &["executes"],
        &["executing"],
        &["execution"],
    ],
    range: 2..=8,
};

static WORD_EXCT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXCT_CHILDREN),
    value: None,
};

pub static WORD_EXCT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("acted"),
        dictgen::InsensitiveStr::Ascii("ract"),
        dictgen::InsensitiveStr::Ascii("racted"),
        dictgen::InsensitiveStr::Ascii("raction"),
        dictgen::InsensitiveStr::Ascii("ractions"),
        dictgen::InsensitiveStr::Ascii("ractor"),
        dictgen::InsensitiveStr::Ascii("ractors"),
        dictgen::InsensitiveStr::Ascii("racts"),
    ],
    values: &[
        &["extracted"],
        &["extract"],
        &["extracted"],
        &["extraction"],
        &["extractions"],
        &["extractor"],
        &["extractors"],
        &["extracts"],
    ],
    range: 4..=8,
};

static WORD_EXCR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXCR_CHILDREN),
    value: None,
};

pub static WORD_EXCR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("act"),
        dictgen::InsensitiveStr::Ascii("ept"),
        dictgen::InsensitiveStr::Ascii("usiating"),
    ],
    values: &[&["extract"], &["excerpt"], &["excruciating"]],
    range: 3..=8,
};

static WORD_EXCP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXCP_CHILDREN),
    value: None,
};

pub static WORD_EXCP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ect"),
        dictgen::InsensitiveStr::Ascii("ected"),
        dictgen::InsensitiveStr::Ascii("ecting"),
        dictgen::InsensitiveStr::Ascii("ects"),
        dictgen::InsensitiveStr::Ascii("eption"),
        dictgen::InsensitiveStr::Ascii("et"),
        dictgen::InsensitiveStr::Ascii("etion"),
        dictgen::InsensitiveStr::Ascii("etional"),
        dictgen::InsensitiveStr::Ascii("etionally"),
        dictgen::InsensitiveStr::Ascii("etions"),
        dictgen::InsensitiveStr::Ascii("licit"),
        dictgen::InsensitiveStr::Ascii("licitly"),
        dictgen::InsensitiveStr::Ascii("lict"),
        dictgen::InsensitiveStr::Ascii("lictly"),
    ],
    values: &[
        &["expect"],
        &["expected"],
        &["expecting"],
        &["expects"],
        &["exception"],
        &["except"],
        &["exception"],
        &["exceptional"],
        &["exceptionally"],
        &["exceptions"],
        &["explicit"],
        &["explicitly"],
        &["explicit"],
        &["explicitly"],
    ],
    range: 2..=9,
};

static WORD_EXCO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXCO_CHILDREN),
    value: None,
};

pub static WORD_EXCO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("rciating")],
    values: &[&["excruciating"]],
    range: 8..=8,
};

static WORD_EXCL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXCL_CHILDREN),
    value: None,
};

pub static WORD_EXCL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("amacion"),
        dictgen::InsensitiveStr::Ascii("amantion"),
        dictgen::InsensitiveStr::Ascii("amating"),
        dictgen::InsensitiveStr::Ascii("amativo"),
        dictgen::InsensitiveStr::Ascii("emation"),
        dictgen::InsensitiveStr::Ascii("imation"),
        dictgen::InsensitiveStr::Ascii("iude"),
        dictgen::InsensitiveStr::Ascii("iuded"),
        dictgen::InsensitiveStr::Ascii("iudes"),
        dictgen::InsensitiveStr::Ascii("iuding"),
        dictgen::InsensitiveStr::Ascii("suive"),
        dictgen::InsensitiveStr::Ascii("suives"),
        dictgen::InsensitiveStr::Ascii("ucivity"),
        dictgen::InsensitiveStr::Ascii("udde"),
        dictgen::InsensitiveStr::Ascii("udeds"),
        dictgen::InsensitiveStr::Ascii("udind"),
        dictgen::InsensitiveStr::Ascii("udle"),
        dictgen::InsensitiveStr::Ascii("udled"),
        dictgen::InsensitiveStr::Ascii("udles"),
        dictgen::InsensitiveStr::Ascii("udling"),
        dictgen::InsensitiveStr::Ascii("ue"),
        dictgen::InsensitiveStr::Ascii("use"),
        dictgen::InsensitiveStr::Ascii("usie"),
        dictgen::InsensitiveStr::Ascii("usiev"),
        dictgen::InsensitiveStr::Ascii("usiv"),
        dictgen::InsensitiveStr::Ascii("usivas"),
        dictgen::InsensitiveStr::Ascii("usiveity"),
        dictgen::InsensitiveStr::Ascii("usivelly"),
        dictgen::InsensitiveStr::Ascii("usivety"),
        dictgen::InsensitiveStr::Ascii("usivily"),
        dictgen::InsensitiveStr::Ascii("usivitiy"),
        dictgen::InsensitiveStr::Ascii("usivley"),
        dictgen::InsensitiveStr::Ascii("usivly"),
        dictgen::InsensitiveStr::Ascii("usivos"),
        dictgen::InsensitiveStr::Ascii("usivs"),
        dictgen::InsensitiveStr::Ascii("usivty"),
        dictgen::InsensitiveStr::Ascii("usivy"),
        dictgen::InsensitiveStr::Ascii("uslvely"),
        dictgen::InsensitiveStr::Ascii("ussive"),
        dictgen::InsensitiveStr::Ascii("usuive"),
        dictgen::InsensitiveStr::Ascii("usuively"),
        dictgen::InsensitiveStr::Ascii("usuives"),
        dictgen::InsensitiveStr::Ascii("usvies"),
    ],
    values: &[
        &["exclamation"],
        &["exclamation"],
        &["exclamation"],
        &["exclamation"],
        &["exclamation"],
        &["exclamation"],
        &["exclude"],
        &["excluded"],
        &["excludes"],
        &["excluding"],
        &["exclusive"],
        &["exclusives"],
        &["exclusivity"],
        &["exclude"],
        &["excludes"],
        &["excluding"],
        &["exclude"],
        &["excluded"],
        &["excludes"],
        &["excluding"],
        &["exclude"],
        &["excludes", "exclude", "excuse", "exclusive"],
        &["exclusives"],
        &["exclusive"],
        &["exclusive"],
        &["exclusives"],
        &["exclusivity"],
        &["exclusively"],
        &["exclusivity"],
        &["exclusivity"],
        &["exclusivity"],
        &["exclusively"],
        &["exclusively"],
        &["exclusives"],
        &["exclusives"],
        &["exclusivity"],
        &["exclusivity"],
        &["exclusively"],
        &["exclusives"],
        &["exclusive"],
        &["exclusively"],
        &["exclusives"],
        &["exclusives"],
    ],
    range: 2..=8,
};

static WORD_EXCI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXCI_CHILDREN),
    value: None,
};

pub static WORD_EXCI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ation"),
        dictgen::InsensitiveStr::Ascii("pt"),
        dictgen::InsensitiveStr::Ascii("ption"),
        dictgen::InsensitiveStr::Ascii("ptions"),
        dictgen::InsensitiveStr::Ascii("st"),
        dictgen::InsensitiveStr::Ascii("sted"),
        dictgen::InsensitiveStr::Ascii("sting"),
        dictgen::InsensitiveStr::Ascii("timent"),
        dictgen::InsensitiveStr::Ascii("tment"),
    ],
    values: &[
        &["excitation"],
        &["except"],
        &["exception"],
        &["exceptions"],
        &["exist"],
        &["existed"],
        &["existing"],
        &["excitement"],
        &["excitement"],
    ],
    range: 2..=6,
};

static WORD_EXCH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXCH_CHILDREN),
    value: None,
};

pub static WORD_EXCH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("age"),
        dictgen::InsensitiveStr::Ascii("aged"),
        dictgen::InsensitiveStr::Ascii("ages"),
        dictgen::InsensitiveStr::Ascii("aging"),
        dictgen::InsensitiveStr::Ascii("agne"),
        dictgen::InsensitiveStr::Ascii("agned"),
        dictgen::InsensitiveStr::Ascii("agnes"),
        dictgen::InsensitiveStr::Ascii("agnge"),
        dictgen::InsensitiveStr::Ascii("agnged"),
        dictgen::InsensitiveStr::Ascii("agnges"),
        dictgen::InsensitiveStr::Ascii("agnging"),
        dictgen::InsensitiveStr::Ascii("agning"),
        dictgen::InsensitiveStr::Ascii("anage"),
        dictgen::InsensitiveStr::Ascii("anaged"),
        dictgen::InsensitiveStr::Ascii("anages"),
        dictgen::InsensitiveStr::Ascii("anaging"),
        dictgen::InsensitiveStr::Ascii("ance"),
        dictgen::InsensitiveStr::Ascii("anced"),
        dictgen::InsensitiveStr::Ascii("ances"),
        dictgen::InsensitiveStr::Ascii("anche"),
        dictgen::InsensitiveStr::Ascii("anched"),
        dictgen::InsensitiveStr::Ascii("anches"),
        dictgen::InsensitiveStr::Ascii("anching"),
        dictgen::InsensitiveStr::Ascii("ancing"),
        dictgen::InsensitiveStr::Ascii("ane"),
        dictgen::InsensitiveStr::Ascii("aned"),
        dictgen::InsensitiveStr::Ascii("anes"),
        dictgen::InsensitiveStr::Ascii("angable"),
        dictgen::InsensitiveStr::Ascii("angees"),
        dictgen::InsensitiveStr::Ascii("aning"),
        dictgen::InsensitiveStr::Ascii("aust"),
        dictgen::InsensitiveStr::Ascii("austed"),
        dictgen::InsensitiveStr::Ascii("austing"),
        dictgen::InsensitiveStr::Ascii("austive"),
        dictgen::InsensitiveStr::Ascii("austs"),
        dictgen::InsensitiveStr::Ascii("enge"),
        dictgen::InsensitiveStr::Ascii("enged"),
        dictgen::InsensitiveStr::Ascii("enges"),
        dictgen::InsensitiveStr::Ascii("enging"),
        dictgen::InsensitiveStr::Ascii("nage"),
        dictgen::InsensitiveStr::Ascii("naged"),
        dictgen::InsensitiveStr::Ascii("nages"),
        dictgen::InsensitiveStr::Ascii("naging"),
        dictgen::InsensitiveStr::Ascii("ng"),
        dictgen::InsensitiveStr::Ascii("ngd"),
        dictgen::InsensitiveStr::Ascii("nge"),
        dictgen::InsensitiveStr::Ascii("nged"),
        dictgen::InsensitiveStr::Ascii("nges"),
        dictgen::InsensitiveStr::Ascii("nging"),
        dictgen::InsensitiveStr::Ascii("ngng"),
        dictgen::InsensitiveStr::Ascii("ngs"),
    ],
    values: &[
        &["exchange"],
        &["exchanged"],
        &["exchanges"],
        &["exchanging"],
        &["exchange"],
        &["exchanged"],
        &["exchanges"],
        &["exchange"],
        &["exchanged"],
        &["exchanges"],
        &["exchanging"],
        &["exchanging"],
        &["exchange"],
        &["exchanged"],
        &["exchanges"],
        &["exchanging"],
        &["exchange"],
        &["exchanged"],
        &["exchanges"],
        &["exchange"],
        &["exchanged"],
        &["exchanges"],
        &["exchanging"],
        &["exchanging"],
        &["exchange"],
        &["exchanged"],
        &["exchanges"],
        &["exchangeable"],
        &["exchanges"],
        &["exchanging"],
        &["exhaust"],
        &["exhausted"],
        &["exhausting"],
        &["exhaustive"],
        &["exhausts"],
        &["exchange"],
        &["exchanged"],
        &["exchanges"],
        &["exchanging"],
        &["exchange"],
        &["exchanged"],
        &["exchanges"],
        &["exchanging"],
        &["exchange"],
        &["exchanged"],
        &["exchange"],
        &["exchanged"],
        &["exchanges"],
        &["exchanging"],
        &["exchanging"],
        &["exchanges"],
    ],
    range: 2..=7,
};

static WORD_EXCE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_EXCE_CHILDREN),
    value: None,
};

static WORD_EXCE_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    Some(&WORD_EXCEC_NODE),
    Some(&WORD_EXCED_NODE),
    Some(&WORD_EXCEE_NODE),
    None,
    None,
    None,
    Some(&WORD_EXCEI_NODE),
    None,
    None,
    Some(&WORD_EXCEL_NODE),
    Some(&WORD_EXCEM_NODE),
    Some(&WORD_EXCEN_NODE),
    Some(&WORD_EXCEO_NODE),
    Some(&WORD_EXCEP_NODE),
    None,
    Some(&WORD_EXCER_NODE),
    Some(&WORD_EXCES_NODE),
    Some(&WORD_EXCET_NODE),
    Some(&WORD_EXCEU_NODE),
    None,
    Some(&WORD_EXCEW_NODE),
    None,
    None,
    None,
];

static WORD_EXCEW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXCEW_CHILDREN),
    value: None,
};

pub static WORD_EXCEW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ption"),
        dictgen::InsensitiveStr::Ascii("ptional"),
        dictgen::InsensitiveStr::Ascii("ptions"),
    ],
    values: &[&["exception"], &["exceptional"], &["exceptions"]],
    range: 5..=7,
};

static WORD_EXCEU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXCEU_CHILDREN),
    value: None,
};

pub static WORD_EXCEU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ctable"),
        dictgen::InsensitiveStr::Ascii("ctables"),
        dictgen::InsensitiveStr::Ascii("cte"),
        dictgen::InsensitiveStr::Ascii("cted"),
        dictgen::InsensitiveStr::Ascii("ctes"),
        dictgen::InsensitiveStr::Ascii("cting"),
        dictgen::InsensitiveStr::Ascii("ction"),
        dictgen::InsensitiveStr::Ascii("ctions"),
        dictgen::InsensitiveStr::Ascii("ctive"),
        dictgen::InsensitiveStr::Ascii("ctives"),
        dictgen::InsensitiveStr::Ascii("ctor"),
        dictgen::InsensitiveStr::Ascii("ctors"),
        dictgen::InsensitiveStr::Ascii("table"),
        dictgen::InsensitiveStr::Ascii("tables"),
        dictgen::InsensitiveStr::Ascii("te"),
        dictgen::InsensitiveStr::Ascii("ted"),
        dictgen::InsensitiveStr::Ascii("tes"),
        dictgen::InsensitiveStr::Ascii("ting"),
        dictgen::InsensitiveStr::Ascii("tion"),
        dictgen::InsensitiveStr::Ascii("tioner"),
        dictgen::InsensitiveStr::Ascii("tions"),
        dictgen::InsensitiveStr::Ascii("tive"),
        dictgen::InsensitiveStr::Ascii("tives"),
        dictgen::InsensitiveStr::Ascii("tor"),
        dictgen::InsensitiveStr::Ascii("tors"),
    ],
    values: &[
        &["executable"],
        &["executables"],
        &["execute"],
        &["executed"],
        &["executes"],
        &["executing"],
        &["execution"],
        &["executions"],
        &["executive"],
        &["executives"],
        &["executor"],
        &["executors"],
        &["executable"],
        &["executables"],
        &["execute"],
        &["executed"],
        &["executes"],
        &["executing"],
        &["execution"],
        &["executioner"],
        &["executions"],
        &["executive"],
        &["executives"],
        &["executor"],
        &["executors"],
    ],
    range: 2..=7,
};

static WORD_EXCET_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXCET_CHILDREN),
    value: None,
};

pub static WORD_EXCET_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ion"),
        dictgen::InsensitiveStr::Ascii("ional"),
        dictgen::InsensitiveStr::Ascii("ions"),
        dictgen::InsensitiveStr::Ascii("pion"),
        dictgen::InsensitiveStr::Ascii("pional"),
        dictgen::InsensitiveStr::Ascii("pions"),
        dictgen::InsensitiveStr::Ascii("ption"),
        dictgen::InsensitiveStr::Ascii("ptional"),
        dictgen::InsensitiveStr::Ascii("ptions"),
        dictgen::InsensitiveStr::Ascii("ra"),
        dictgen::InsensitiveStr::Ascii("utable"),
        dictgen::InsensitiveStr::Ascii("utables"),
        dictgen::InsensitiveStr::Ascii("ute"),
        dictgen::InsensitiveStr::Ascii("uted"),
        dictgen::InsensitiveStr::Ascii("utes"),
        dictgen::InsensitiveStr::Ascii("uting"),
        dictgen::InsensitiveStr::Ascii("ution"),
        dictgen::InsensitiveStr::Ascii("utions"),
        dictgen::InsensitiveStr::Ascii("utive"),
        dictgen::InsensitiveStr::Ascii("utives"),
        dictgen::InsensitiveStr::Ascii("utor"),
        dictgen::InsensitiveStr::Ascii("utors"),
    ],
    values: &[
        &["exception"],
        &["exceptional"],
        &["exceptions"],
        &["exception"],
        &["exceptional"],
        &["exceptions"],
        &["exception"],
        &["exceptional"],
        &["exceptions"],
        &["etcetera"],
        &["executable"],
        &["executables"],
        &["execute"],
        &["executed"],
        &["executes"],
        &["executing"],
        &["execution"],
        &["executions"],
        &["executive"],
        &["executives"],
        &["executor"],
        &["executors"],
    ],
    range: 2..=7,
};

static WORD_EXCES_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXCES_CHILDREN),
    value: Some(&["excess"]),
};

pub static WORD_EXCES_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("ive"),
        dictgen::InsensitiveStr::Ascii("ively"),
        dictgen::InsensitiveStr::Ascii("sivley"),
        dictgen::InsensitiveStr::Ascii("sivly"),
        dictgen::InsensitiveStr::Ascii("ss"),
        dictgen::InsensitiveStr::Ascii("v"),
        dictgen::InsensitiveStr::Ascii("vly"),
    ],
    values: &[
        &["exceeded"],
        &["excessive"],
        &["excessively"],
        &["excessively"],
        &["excessively"],
        &["excess"],
        &["excessive"],
        &["excessively"],
    ],
    range: 1..=6,
};

static WORD_EXCER_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXCER_CHILDREN),
    value: None,
};

pub static WORD_EXCER_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cise"),
        dictgen::InsensitiveStr::Ascii("cised"),
        dictgen::InsensitiveStr::Ascii("ciser"),
        dictgen::InsensitiveStr::Ascii("cises"),
        dictgen::InsensitiveStr::Ascii("cising"),
        dictgen::InsensitiveStr::Ascii("ise"),
        dictgen::InsensitiveStr::Ascii("ised"),
        dictgen::InsensitiveStr::Ascii("ises"),
        dictgen::InsensitiveStr::Ascii("ising"),
        dictgen::InsensitiveStr::Ascii("size"),
        dictgen::InsensitiveStr::Ascii("sized"),
        dictgen::InsensitiveStr::Ascii("sizes"),
        dictgen::InsensitiveStr::Ascii("sizing"),
    ],
    values: &[
        &["exercise"],
        &["exercised"],
        &["exerciser"],
        &["exercises"],
        &["exercising"],
        &["exercise"],
        &["exercised"],
        &["exercises"],
        &["exercising"],
        &["exercise"],
        &["exercised"],
        &["exercises"],
        &["exercising"],
    ],
    range: 3..=6,
};

static WORD_EXCEP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXCEP_CHILDREN),
    value: None,
};

pub static WORD_EXCEP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cional"),
        dictgen::InsensitiveStr::Ascii("etion"),
        dictgen::InsensitiveStr::Ascii("ion"),
        dictgen::InsensitiveStr::Ascii("ional"),
        dictgen::InsensitiveStr::Ascii("ionally"),
        dictgen::InsensitiveStr::Ascii("ions"),
        dictgen::InsensitiveStr::Ascii("rt"),
        dictgen::InsensitiveStr::Ascii("rts"),
        dictgen::InsensitiveStr::Ascii("tation"),
        dictgen::InsensitiveStr::Ascii("tin"),
        dictgen::InsensitiveStr::Ascii("tins"),
        dictgen::InsensitiveStr::Ascii("tionaly"),
        dictgen::InsensitiveStr::Ascii("tionel"),
        dictgen::InsensitiveStr::Ascii("tionnal"),
        dictgen::InsensitiveStr::Ascii("tionss"),
        dictgen::InsensitiveStr::Ascii("tionts"),
    ],
    values: &[
        &["exceptional"],
        &["exception"],
        &["exception"],
        &["exceptional"],
        &["exceptionally"],
        &["exceptions"],
        &["excerpt"],
        &["excerpts"],
        &["expectation"],
        &[
            "exceptions",
            "excepting",
            "exception",
            "expecting",
            "accepting",
        ],
        &["exceptions", "excepting"],
        &["exceptionally"],
        &["exceptional"],
        &["exceptional"],
        &["exceptions"],
        &["exceptions"],
    ],
    range: 2..=7,
};

static WORD_EXCEO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXCEO_CHILDREN),
    value: None,
};

pub static WORD_EXCEO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("pt"),
        dictgen::InsensitiveStr::Ascii("pted"),
        dictgen::InsensitiveStr::Ascii("pts"),
        dictgen::InsensitiveStr::Ascii("tion"),
        dictgen::InsensitiveStr::Ascii("tions"),
    ],
    values: &[
        &["exempt"],
        &["exempted"],
        &["exempts"],
        &["exemption"],
        &["exemptions"],
    ],
    range: 2..=5,
};

static WORD_EXCEN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXCEN_CHILDREN),
    value: None,
};

pub static WORD_EXCEN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("tric"),
        dictgen::InsensitiveStr::Ascii("tricity"),
        dictgen::InsensitiveStr::Ascii("tuating"),
    ],
    values: &[&["eccentric"], &["eccentricity"], &["accentuating"]],
    range: 4..=7,
};

static WORD_EXCEM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXCEM_CHILDREN),
    value: None,
};

pub static WORD_EXCEM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("pt"),
        dictgen::InsensitiveStr::Ascii("pted"),
        dictgen::InsensitiveStr::Ascii("ption"),
        dictgen::InsensitiveStr::Ascii("ptions"),
        dictgen::InsensitiveStr::Ascii("pts"),
    ],
    values: &[
        &["exempt"],
        &["exempted"],
        &["exemption"],
        &["exemptions"],
        &["exempts"],
    ],
    range: 2..=6,
};

static WORD_EXCEL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXCEL_CHILDREN),
    value: None,
};

pub static WORD_EXCEL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ent"),
        dictgen::InsensitiveStr::Ascii("l"),
        dictgen::InsensitiveStr::Ascii("lance"),
        dictgen::InsensitiveStr::Ascii("lant"),
        dictgen::InsensitiveStr::Ascii("lenet"),
        dictgen::InsensitiveStr::Ascii("lenze"),
        dictgen::InsensitiveStr::Ascii("ls"),
    ],
    values: &[
        &["excellent"],
        &["excel"],
        &["excellence"],
        &["excellent"],
        &["excellence"],
        &["excellence"],
        &["excels"],
    ],
    range: 1..=5,
};

static WORD_EXCEI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXCEI_CHILDREN),
    value: None,
};

pub static WORD_EXCEI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("rpt"),
        dictgen::InsensitiveStr::Ascii("rpts"),
    ],
    values: &[&["excerpt"], &["excerpts"]],
    range: 3..=4,
};

static WORD_EXCEE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXCEE_CHILDREN),
    value: None,
};

pub static WORD_EXCEE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("digly"),
        dictgen::InsensitiveStr::Ascii("dinly"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("eds"),
    ],
    values: &[
        &["exceedingly"],
        &["exceedingly"],
        &["exceed"],
        &["exceeds"],
    ],
    range: 2..=5,
};

static WORD_EXCED_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXCED_CHILDREN),
    value: Some(&["exceed"]),
};

pub static WORD_EXCED_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ded"),
        dictgen::InsensitiveStr::Ascii("ding"),
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("eed"),
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("s"),
    ],
    values: &[
        &["exceeded"],
        &["exceeding"],
        &["exceed"],
        &["exceeded"],
        &["exceeded"],
        &["exceeds"],
        &["exceeding"],
        &["exceeds"],
    ],
    range: 1..=4,
};

static WORD_EXCEC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXCEC_CHILDREN),
    value: None,
};

pub static WORD_EXCEC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ise"),
        dictgen::InsensitiveStr::Ascii("ised"),
        dictgen::InsensitiveStr::Ascii("ises"),
        dictgen::InsensitiveStr::Ascii("pt"),
        dictgen::InsensitiveStr::Ascii("ption"),
        dictgen::InsensitiveStr::Ascii("ptional"),
        dictgen::InsensitiveStr::Ascii("ptions"),
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("table"),
        dictgen::InsensitiveStr::Ascii("tables"),
        dictgen::InsensitiveStr::Ascii("te"),
        dictgen::InsensitiveStr::Ascii("ted"),
        dictgen::InsensitiveStr::Ascii("tedly"),
        dictgen::InsensitiveStr::Ascii("tes"),
        dictgen::InsensitiveStr::Ascii("ting"),
        dictgen::InsensitiveStr::Ascii("tion"),
        dictgen::InsensitiveStr::Ascii("tional"),
        dictgen::InsensitiveStr::Ascii("tions"),
        dictgen::InsensitiveStr::Ascii("tive"),
        dictgen::InsensitiveStr::Ascii("tives"),
        dictgen::InsensitiveStr::Ascii("tor"),
        dictgen::InsensitiveStr::Ascii("tors"),
        dictgen::InsensitiveStr::Ascii("ts"),
        dictgen::InsensitiveStr::Ascii("utable"),
        dictgen::InsensitiveStr::Ascii("utables"),
        dictgen::InsensitiveStr::Ascii("ute"),
        dictgen::InsensitiveStr::Ascii("uted"),
        dictgen::InsensitiveStr::Ascii("utes"),
        dictgen::InsensitiveStr::Ascii("uting"),
        dictgen::InsensitiveStr::Ascii("ution"),
        dictgen::InsensitiveStr::Ascii("utions"),
        dictgen::InsensitiveStr::Ascii("utive"),
        dictgen::InsensitiveStr::Ascii("utives"),
        dictgen::InsensitiveStr::Ascii("utor"),
        dictgen::InsensitiveStr::Ascii("utors"),
        dictgen::InsensitiveStr::Ascii("uts"),
    ],
    values: &[
        &["exercise"],
        &["excised", "exercised"],
        &["exercises"],
        &["except"],
        &["exception"],
        &["exceptional"],
        &["exceptions"],
        &["except", "expect"],
        &["executable"],
        &["executables"],
        &["execute"],
        &["executed", "expected"],
        &["expectedly"],
        &["executes"],
        &["executing"],
        &["exception", "execution"],
        &["exceptional"],
        &["exceptions", "executions"],
        &["executive"],
        &["executives"],
        &["executor"],
        &["executors"],
        &["expects"],
        &["executable"],
        &["executables"],
        &["execute"],
        &["executed"],
        &["executes"],
        &["executing"],
        &["execution"],
        &["executions"],
        &["executive"],
        &["executives"],
        &["executor"],
        &["executors"],
        &["executes"],
    ],
    range: 1..=7,
};

static WORD_EXCC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXCC_CHILDREN),
    value: None,
};

pub static WORD_EXCC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ute")],
    values: &[&["execute"]],
    range: 3..=3,
};

static WORD_EXCA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXCA_CHILDREN),
    value: None,
};

pub static WORD_EXCA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ct"),
        dictgen::InsensitiveStr::Ascii("ctly"),
        dictgen::InsensitiveStr::Ascii("hcnge"),
        dictgen::InsensitiveStr::Ascii("hnge"),
        dictgen::InsensitiveStr::Ascii("hnges"),
        dictgen::InsensitiveStr::Ascii("lmation"),
        dictgen::InsensitiveStr::Ascii("nge"),
        dictgen::InsensitiveStr::Ascii("pe"),
        dictgen::InsensitiveStr::Ascii("ped"),
        dictgen::InsensitiveStr::Ascii("pes"),
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("ting"),
        dictgen::InsensitiveStr::Ascii("tly"),
    ],
    values: &[
        &["exact"],
        &["exactly"],
        &["exchange"],
        &["exchange"],
        &["exchanges"],
        &["exclamation"],
        &["exchange"],
        &["escape"],
        &["escaped"],
        &["escapes"],
        &["exact"],
        &["exacting"],
        &["exactly"],
    ],
    range: 1..=7,
};

static WORD_EXA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_EXA_CHILDREN),
    value: None,
};

static WORD_EXA_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    Some(&WORD_EXAC_NODE),
    None,
    None,
    None,
    Some(&WORD_EXAG_NODE),
    Some(&WORD_EXAH_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_EXAM_NODE),
    Some(&WORD_EXAN_NODE),
    None,
    Some(&WORD_EXAP_NODE),
    None,
    Some(&WORD_EXAR_NODE),
    None,
    Some(&WORD_EXAT_NODE),
    Some(&WORD_EXAU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_EXAU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXAU_CHILDREN),
    value: None,
};

pub static WORD_EXAU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("hsted"),
        dictgen::InsensitiveStr::Ascii("hsting"),
        dictgen::InsensitiveStr::Ascii("hstion"),
        dictgen::InsensitiveStr::Ascii("sted"),
        dictgen::InsensitiveStr::Ascii("stive"),
    ],
    values: &[
        &["exhausted"],
        &["exhausting"],
        &["exhaustion"],
        &["exhausted"],
        &["exhaustive"],
    ],
    range: 4..=6,
};

static WORD_EXAT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXAT_CHILDREN),
    value: Some(&["exact"]),
};

pub static WORD_EXAT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cly"),
        dictgen::InsensitiveStr::Ascii("ctly"),
        dictgen::InsensitiveStr::Ascii("led"),
        dictgen::InsensitiveStr::Ascii("ly"),
    ],
    values: &[&["exactly"], &["exactly"], &["exalted"], &["exactly"]],
    range: 2..=4,
};

static WORD_EXAR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXAR_CHILDREN),
    value: None,
};

pub static WORD_EXAR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("cebated")],
    values: &[&["exacerbated"]],
    range: 7..=7,
};

static WORD_EXAP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXAP_CHILDREN),
    value: None,
};

pub static WORD_EXAP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ansion"),
        dictgen::InsensitiveStr::Ascii("end"),
        dictgen::InsensitiveStr::Ascii("lain"),
        dictgen::InsensitiveStr::Ascii("laination"),
        dictgen::InsensitiveStr::Ascii("lained"),
        dictgen::InsensitiveStr::Ascii("laining"),
        dictgen::InsensitiveStr::Ascii("lains"),
        dictgen::InsensitiveStr::Ascii("lanation"),
        dictgen::InsensitiveStr::Ascii("lanations"),
        dictgen::InsensitiveStr::Ascii("le"),
        dictgen::InsensitiveStr::Ascii("les"),
        dictgen::InsensitiveStr::Ascii("mle"),
        dictgen::InsensitiveStr::Ascii("mles"),
        dictgen::InsensitiveStr::Ascii("nds"),
        dictgen::InsensitiveStr::Ascii("nsion"),
        dictgen::InsensitiveStr::Ascii("nsions"),
        dictgen::InsensitiveStr::Ascii("nsive"),
    ],
    values: &[
        &["expansion"],
        &["expand"],
        &["explain"],
        &["explanation"],
        &["explained"],
        &["explaining"],
        &["explains"],
        &["explanation"],
        &["explanations"],
        &["example"],
        &["examples"],
        &["example"],
        &["examples"],
        &["expands"],
        &["expansion"],
        &["expansions"],
        &["expansive"],
    ],
    range: 2..=9,
};

static WORD_EXAN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXAN_CHILDREN),
    value: None,
};

pub static WORD_EXAN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("d"),
        dictgen::InsensitiveStr::Ascii("sive"),
    ],
    values: &[&["expand"], &["expansive"]],
    range: 1..=4,
};

static WORD_EXAM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXAM_CHILDREN),
    value: None,
};

pub static WORD_EXAM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eple"),
        dictgen::InsensitiveStr::Ascii("eples"),
        dictgen::InsensitiveStr::Ascii("ied"),
        dictgen::InsensitiveStr::Ascii("in"),
        dictgen::InsensitiveStr::Ascii("inated"),
        dictgen::InsensitiveStr::Ascii("ind"),
        dictgen::InsensitiveStr::Ascii("inerad"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("ininig"),
        dictgen::InsensitiveStr::Ascii("inining"),
        dictgen::InsensitiveStr::Ascii("le"),
        dictgen::InsensitiveStr::Ascii("les"),
        dictgen::InsensitiveStr::Ascii("lpe"),
        dictgen::InsensitiveStr::Ascii("lpes"),
        dictgen::InsensitiveStr::Ascii("nple"),
        dictgen::InsensitiveStr::Ascii("nples"),
        dictgen::InsensitiveStr::Ascii("pel"),
        dictgen::InsensitiveStr::Ascii("peles"),
        dictgen::InsensitiveStr::Ascii("pels"),
        dictgen::InsensitiveStr::Ascii("plee"),
        dictgen::InsensitiveStr::Ascii("plees"),
        dictgen::InsensitiveStr::Ascii("pleo"),
        dictgen::InsensitiveStr::Ascii("plifies"),
        dictgen::InsensitiveStr::Ascii("pple"),
        dictgen::InsensitiveStr::Ascii("pples"),
        dictgen::InsensitiveStr::Ascii("pt"),
    ],
    values: &[
        &["example"],
        &["examples"],
        &["examined"],
        &["examine", "examining"],
        &["examined"],
        &["examined"],
        &["examined"],
        &["examining"],
        &["examining"],
        &["examining"],
        &["example"],
        &["examples"],
        &["example"],
        &["examples"],
        &["example"],
        &["examples"],
        &["example"],
        &["examples"],
        &["examples"],
        &["example", "examples"],
        &["examples"],
        &["example"],
        &["exemplifies"],
        &["example"],
        &["examples"],
        &["exempt"],
    ],
    range: 2..=7,
};

static WORD_EXAH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXAH_CHILDREN),
    value: None,
};

pub static WORD_EXAH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ust"),
        dictgen::InsensitiveStr::Ascii("usted"),
        dictgen::InsensitiveStr::Ascii("usting"),
        dictgen::InsensitiveStr::Ascii("ustion"),
    ],
    values: &[
        &["exhaust"],
        &["exhausted"],
        &["exhausting"],
        &["exhaustion"],
    ],
    range: 3..=6,
};

static WORD_EXAG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXAG_CHILDREN),
    value: None,
};

pub static WORD_EXAG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("erate"),
        dictgen::InsensitiveStr::Ascii("erated"),
        dictgen::InsensitiveStr::Ascii("erates"),
        dictgen::InsensitiveStr::Ascii("erating"),
        dictgen::InsensitiveStr::Ascii("eration"),
        dictgen::InsensitiveStr::Ascii("erations"),
        dictgen::InsensitiveStr::Ascii("errate"),
        dictgen::InsensitiveStr::Ascii("errated"),
        dictgen::InsensitiveStr::Ascii("errates"),
        dictgen::InsensitiveStr::Ascii("errating"),
        dictgen::InsensitiveStr::Ascii("garate"),
        dictgen::InsensitiveStr::Ascii("garated"),
        dictgen::InsensitiveStr::Ascii("garating"),
        dictgen::InsensitiveStr::Ascii("garation"),
        dictgen::InsensitiveStr::Ascii("gareted"),
        dictgen::InsensitiveStr::Ascii("geratin"),
        dictgen::InsensitiveStr::Ascii("geratted"),
        dictgen::InsensitiveStr::Ascii("geratting"),
        dictgen::InsensitiveStr::Ascii("gerrate"),
        dictgen::InsensitiveStr::Ascii("gurate"),
        dictgen::InsensitiveStr::Ascii("gurated"),
        dictgen::InsensitiveStr::Ascii("gurating"),
        dictgen::InsensitiveStr::Ascii("guration"),
    ],
    values: &[
        &["exaggerate"],
        &["exaggerated"],
        &["exaggerates"],
        &["exaggerating"],
        &["exaggeration"],
        &["exaggerations"],
        &["exaggerate"],
        &["exaggerated"],
        &["exaggerates"],
        &["exaggerating"],
        &["exaggerate"],
        &["exaggerated"],
        &["exaggerating"],
        &["exaggeration"],
        &["exaggerate"],
        &["exaggeration"],
        &["exaggerated"],
        &["exaggerating"],
        &["exaggerate"],
        &["exaggerate"],
        &["exaggerated"],
        &["exaggerating"],
        &["exaggeration"],
    ],
    range: 5..=9,
};

static WORD_EXAC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EXAC_CHILDREN),
    value: None,
};

pub static WORD_EXAC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("arbated"),
        dictgen::InsensitiveStr::Ascii("berate"),
        dictgen::InsensitiveStr::Ascii("berated"),
        dictgen::InsensitiveStr::Ascii("lty"),
        dictgen::InsensitiveStr::Ascii("ly"),
        dictgen::InsensitiveStr::Ascii("tely"),
        dictgen::InsensitiveStr::Ascii("ty"),
        dictgen::InsensitiveStr::Ascii("utable"),
    ],
    values: &[
        &["exacerbated"],
        &["exacerbated"],
        &["exacerbated"],
        &["exactly"],
        &["exactly"],
        &["exactly"],
        &["exactly"],
        &["executable"],
    ],
    range: 2..=7,
};

static WORD_EW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EW_CHILDREN),
    value: None,
};

pub static WORD_EW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("hwer")],
    values: &[&["where"]],
    range: 4..=4,
};

static WORD_EV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_EV_CHILDREN),
    value: None,
};

static WORD_EV_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_EVA_NODE),
    None,
    None,
    None,
    Some(&WORD_EVE_NODE),
    None,
    None,
    None,
    Some(&WORD_EVI_NODE),
    None,
    None,
    Some(&WORD_EVL_NODE),
    None,
    Some(&WORD_EVN_NODE),
    Some(&WORD_EVO_NODE),
    None,
    None,
    Some(&WORD_EVR_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_EVY_NODE),
    None,
];

static WORD_EVY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EVY_CHILDREN),
    value: None,
};

pub static WORD_EVY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("rthing")],
    values: &[&["everything"]],
    range: 6..=6,
};

static WORD_EVR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EVR_CHILDREN),
    value: None,
};

pub static WORD_EVR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eyones"),
        dictgen::InsensitiveStr::Ascii("eytime"),
        dictgen::InsensitiveStr::Ascii("ithing"),
        dictgen::InsensitiveStr::Ascii("y"),
        dictgen::InsensitiveStr::Ascii("ythign"),
        dictgen::InsensitiveStr::Ascii("ything"),
        dictgen::InsensitiveStr::Ascii("ywhere"),
    ],
    values: &[
        &["everyones"],
        &["everytime"],
        &["everything"],
        &["every"],
        &["everything"],
        &["everything"],
        &["everywhere"],
    ],
    range: 1..=6,
};

static WORD_EVO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EVO_CHILDREN),
    value: None,
};

pub static WORD_EVO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("luate"),
        dictgen::InsensitiveStr::Ascii("luated"),
        dictgen::InsensitiveStr::Ascii("luates"),
        dictgen::InsensitiveStr::Ascii("luation"),
        dictgen::InsensitiveStr::Ascii("lutionairy"),
        dictgen::InsensitiveStr::Ascii("lutionarilly"),
        dictgen::InsensitiveStr::Ascii("lutionarly"),
        dictgen::InsensitiveStr::Ascii("lutionnary"),
        dictgen::InsensitiveStr::Ascii("luton"),
        dictgen::InsensitiveStr::Ascii("lveds"),
        dictgen::InsensitiveStr::Ascii("lveos"),
        dictgen::InsensitiveStr::Ascii("vled"),
        dictgen::InsensitiveStr::Ascii("vler"),
        dictgen::InsensitiveStr::Ascii("vles"),
        dictgen::InsensitiveStr::Ascii("vling"),
    ],
    values: &[
        &["evaluate"],
        &["evaluated"],
        &["evaluates"],
        &["evaluations"],
        &["evolutionary"],
        &["evolutionary"],
        &["evolutionary"],
        &["evolutionary"],
        &["evolution"],
        &["evolves"],
        &["evolves"],
        &["evolved"],
        &["evolver"],
        &["evolves"],
        &["evolving"],
    ],
    range: 4..=12,
};

static WORD_EVN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EVN_CHILDREN),
    value: None,
};

pub static WORD_EVN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("et"),
        dictgen::InsensitiveStr::Ascii("ts"),
    ],
    values: &[&["event"], &["events"]],
    range: 2..=2,
};

static WORD_EVL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EVL_CHILDREN),
    value: None,
};

pub static WORD_EVL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("oved"),
        dictgen::InsensitiveStr::Ascii("oves"),
        dictgen::InsensitiveStr::Ascii("oving"),
        dictgen::InsensitiveStr::Ascii("uate"),
        dictgen::InsensitiveStr::Ascii("uated"),
        dictgen::InsensitiveStr::Ascii("uates"),
        dictgen::InsensitiveStr::Ascii("uating"),
        dictgen::InsensitiveStr::Ascii("uation"),
        dictgen::InsensitiveStr::Ascii("uations"),
        dictgen::InsensitiveStr::Ascii("uative"),
        dictgen::InsensitiveStr::Ascii("uator"),
        dictgen::InsensitiveStr::Ascii("uators"),
    ],
    values: &[
        &["evolved"],
        &["evolves"],
        &["evolving"],
        &["evaluate"],
        &["evaluated"],
        &["evaluates"],
        &["evaluating"],
        &["evaluation"],
        &["evaluations"],
        &["evaluative"],
        &["evaluator"],
        &["evaluators"],
    ],
    range: 4..=7,
};

static WORD_EVI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EVI_CHILDREN),
    value: None,
};

pub static WORD_EVI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("dencd"),
        dictgen::InsensitiveStr::Ascii("dende"),
        dictgen::InsensitiveStr::Ascii("dentally"),
        dictgen::InsensitiveStr::Ascii("ronment"),
        dictgen::InsensitiveStr::Ascii("ronments"),
        dictgen::InsensitiveStr::Ascii("serate"),
        dictgen::InsensitiveStr::Ascii("serated"),
        dictgen::InsensitiveStr::Ascii("serates"),
        dictgen::InsensitiveStr::Ascii("serating"),
        dictgen::InsensitiveStr::Ascii("tion"),
    ],
    values: &[
        &["evidenced"],
        &["evidenced"],
        &["evidently"],
        &["environment"],
        &["environments"],
        &["eviscerate"],
        &["eviscerated"],
        &["eviscerates"],
        &["eviscerating"],
        &["eviction"],
    ],
    range: 4..=8,
};

static WORD_EVE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_EVE_CHILDREN),
    value: None,
};

static WORD_EVE_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_EVEL_NODE),
    Some(&WORD_EVEM_NODE),
    Some(&WORD_EVEN_NODE),
    Some(&WORD_EVEO_NODE),
    None,
    None,
    Some(&WORD_EVER_NODE),
    Some(&WORD_EVES_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_EVEY_NODE),
    None,
];

static WORD_EVEY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EVEY_CHILDREN),
    value: Some(&["every"]),
};

pub static WORD_EVEY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("one"),
        dictgen::InsensitiveStr::Ascii("r"),
        dictgen::InsensitiveStr::Ascii("rones"),
        dictgen::InsensitiveStr::Ascii("thing"),
    ],
    values: &[&["everyone"], &["every"], &["everyones"], &["everything"]],
    range: 1..=5,
};

static WORD_EVES_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EVES_CHILDREN),
    value: None,
};

pub static WORD_EVES_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("drop"),
        dictgen::InsensitiveStr::Ascii("dropped"),
        dictgen::InsensitiveStr::Ascii("dropper"),
        dictgen::InsensitiveStr::Ascii("dropping"),
        dictgen::InsensitiveStr::Ascii("drops"),
    ],
    values: &[
        &["eavesdrop"],
        &["eavesdropped"],
        &["eavesdropper"],
        &["eavesdropping"],
        &["eavesdrops"],
    ],
    range: 4..=8,
};

static WORD_EVER_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EVER_CHILDREN),
    value: None,
};

pub static WORD_EVER_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("age"),
        dictgen::InsensitiveStr::Ascii("aged"),
        dictgen::InsensitiveStr::Ascii("body"),
        dictgen::InsensitiveStr::Ascii("ets"),
        dictgen::InsensitiveStr::Ascii("ithing"),
        dictgen::InsensitiveStr::Ascii("one"),
        dictgen::InsensitiveStr::Ascii("set"),
        dictgen::InsensitiveStr::Ascii("thing"),
        dictgen::InsensitiveStr::Ascii("tyhign"),
        dictgen::InsensitiveStr::Ascii("tyhing"),
        dictgen::InsensitiveStr::Ascii("tyime"),
        dictgen::InsensitiveStr::Ascii("tything"),
        dictgen::InsensitiveStr::Ascii("where"),
        dictgen::InsensitiveStr::Ascii("ybodies"),
        dictgen::InsensitiveStr::Ascii("yhing"),
        dictgen::InsensitiveStr::Ascii("yhting"),
        dictgen::InsensitiveStr::Ascii("yoens"),
        dictgen::InsensitiveStr::Ascii("yonehas"),
        dictgen::InsensitiveStr::Ascii("yoneis"),
        dictgen::InsensitiveStr::Ascii("yonelse"),
        dictgen::InsensitiveStr::Ascii("yons"),
        dictgen::InsensitiveStr::Ascii("yteim"),
        dictgen::InsensitiveStr::Ascii("ythig"),
        dictgen::InsensitiveStr::Ascii("ythign"),
        dictgen::InsensitiveStr::Ascii("ythin"),
        dictgen::InsensitiveStr::Ascii("ythings"),
        dictgen::InsensitiveStr::Ascii("ytiem"),
        dictgen::InsensitiveStr::Ascii("yting"),
        dictgen::InsensitiveStr::Ascii("ytone"),
        dictgen::InsensitiveStr::Ascii("ywher"),
    ],
    values: &[
        &["average"],
        &["averaged"],
        &["everybody"],
        &["everest"],
        &["everything"],
        &["everyone"],
        &["everest"],
        &["everything"],
        &["everything"],
        &["everything"],
        &["everytime"],
        &["everything"],
        &["everywhere"],
        &["everybody"],
        &["everything"],
        &["everything"],
        &["everyones"],
        &["everyones"],
        &["everyones"],
        &["everyones"],
        &["everyones"],
        &["everytime"],
        &["everything"],
        &["everything"],
        &["everything"],
        &["everything"],
        &["everytime"],
        &["everything"],
        &["everyone"],
        &["everywhere"],
    ],
    range: 3..=7,
};

static WORD_EVEO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EVEO_CHILDREN),
    value: None,
};

pub static WORD_EVEO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("lution"),
        dictgen::InsensitiveStr::Ascii("lutionary"),
        dictgen::InsensitiveStr::Ascii("lve"),
        dictgen::InsensitiveStr::Ascii("lved"),
        dictgen::InsensitiveStr::Ascii("lves"),
        dictgen::InsensitiveStr::Ascii("lving"),
    ],
    values: &[
        &["evolution"],
        &["evolutionary"],
        &["evolve"],
        &["evolved"],
        &["evolves"],
        &["evolving"],
    ],
    range: 3..=9,
};

static WORD_EVEN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EVEN_CHILDREN),
    value: None,
};

pub static WORD_EVEN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("galical"),
        dictgen::InsensitiveStr::Ascii("htually"),
        dictgen::InsensitiveStr::Ascii("lopes"),
        dictgen::InsensitiveStr::Ascii("tally"),
        dictgen::InsensitiveStr::Ascii("taully"),
        dictgen::InsensitiveStr::Ascii("tially"),
        dictgen::InsensitiveStr::Ascii("tuall"),
        dictgen::InsensitiveStr::Ascii("tualy"),
        dictgen::InsensitiveStr::Ascii("ually"),
    ],
    values: &[
        &["evangelical"],
        &["eventually"],
        &["envelopes"],
        &["eventually"],
        &["eventually"],
        &["eventually"],
        &["eventually"],
        &["eventually"],
        &["eventually"],
    ],
    range: 5..=7,
};

static WORD_EVEM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EVEM_CHILDREN),
    value: Some(&["even", "ever"]),
};

pub static WORD_EVEM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[],
    values: &[],
    range: 0..=0,
};

static WORD_EVEL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EVEL_CHILDREN),
    value: None,
};

pub static WORD_EVEL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ation"),
        dictgen::InsensitiveStr::Ascii("ope"),
        dictgen::InsensitiveStr::Ascii("uate"),
        dictgen::InsensitiveStr::Ascii("uated"),
        dictgen::InsensitiveStr::Ascii("uates"),
        dictgen::InsensitiveStr::Ascii("uating"),
        dictgen::InsensitiveStr::Ascii("uation"),
        dictgen::InsensitiveStr::Ascii("uations"),
        dictgen::InsensitiveStr::Ascii("uator"),
        dictgen::InsensitiveStr::Ascii("uators"),
        dictgen::InsensitiveStr::Ascii("utionary"),
    ],
    values: &[
        &["elevation"],
        &["envelope", "envelop"],
        &["evaluate"],
        &["evaluated"],
        &["evaluates"],
        &["evaluating"],
        &["evaluation"],
        &["evaluations"],
        &["evaluator"],
        &["evaluators"],
        &["evolutionary"],
    ],
    range: 3..=8,
};

static WORD_EVA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EVA_CHILDREN),
    value: None,
};

pub static WORD_EVA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ilable"),
        dictgen::InsensitiveStr::Ascii("lation"),
        dictgen::InsensitiveStr::Ascii("lite"),
        dictgen::InsensitiveStr::Ascii("lited"),
        dictgen::InsensitiveStr::Ascii("lites"),
        dictgen::InsensitiveStr::Ascii("luacion"),
        dictgen::InsensitiveStr::Ascii("luataion"),
        dictgen::InsensitiveStr::Ascii("luataions"),
        dictgen::InsensitiveStr::Ascii("luatate"),
        dictgen::InsensitiveStr::Ascii("luatated"),
        dictgen::InsensitiveStr::Ascii("luatates"),
        dictgen::InsensitiveStr::Ascii("luatating"),
        dictgen::InsensitiveStr::Ascii("luatiing"),
        dictgen::InsensitiveStr::Ascii("luationg"),
        dictgen::InsensitiveStr::Ascii("ludate"),
        dictgen::InsensitiveStr::Ascii("lueate"),
        dictgen::InsensitiveStr::Ascii("lueated"),
        dictgen::InsensitiveStr::Ascii("luete"),
        dictgen::InsensitiveStr::Ascii("lueted"),
        dictgen::InsensitiveStr::Ascii("lulates"),
        dictgen::InsensitiveStr::Ascii("lutae"),
        dictgen::InsensitiveStr::Ascii("lutaed"),
        dictgen::InsensitiveStr::Ascii("lutaeing"),
        dictgen::InsensitiveStr::Ascii("lutaes"),
        dictgen::InsensitiveStr::Ascii("lutaing"),
        dictgen::InsensitiveStr::Ascii("lutaion"),
        dictgen::InsensitiveStr::Ascii("lutaions"),
        dictgen::InsensitiveStr::Ascii("lutaor"),
        dictgen::InsensitiveStr::Ascii("lutate"),
        dictgen::InsensitiveStr::Ascii("lutated"),
        dictgen::InsensitiveStr::Ascii("lutates"),
        dictgen::InsensitiveStr::Ascii("lutating"),
        dictgen::InsensitiveStr::Ascii("lutation"),
        dictgen::InsensitiveStr::Ascii("lutations"),
        dictgen::InsensitiveStr::Ascii("lute"),
        dictgen::InsensitiveStr::Ascii("luted"),
        dictgen::InsensitiveStr::Ascii("lutes"),
        dictgen::InsensitiveStr::Ascii("luting"),
        dictgen::InsensitiveStr::Ascii("lution"),
        dictgen::InsensitiveStr::Ascii("lutions"),
        dictgen::InsensitiveStr::Ascii("lutive"),
        dictgen::InsensitiveStr::Ascii("lutor"),
        dictgen::InsensitiveStr::Ascii("lutors"),
        dictgen::InsensitiveStr::Ascii("ngalical"),
        dictgen::InsensitiveStr::Ascii("ngelia"),
        dictgen::InsensitiveStr::Ascii("ngelikal"),
        dictgen::InsensitiveStr::Ascii("ngers"),
        dictgen::InsensitiveStr::Ascii("ulate"),
        dictgen::InsensitiveStr::Ascii("ulated"),
        dictgen::InsensitiveStr::Ascii("ulates"),
        dictgen::InsensitiveStr::Ascii("ulating"),
        dictgen::InsensitiveStr::Ascii("ulation"),
        dictgen::InsensitiveStr::Ascii("ulator"),
        dictgen::InsensitiveStr::Ascii("ulted"),
        dictgen::InsensitiveStr::Ascii("uluate"),
        dictgen::InsensitiveStr::Ascii("uluated"),
        dictgen::InsensitiveStr::Ascii("uluates"),
        dictgen::InsensitiveStr::Ascii("uluation"),
    ],
    values: &[
        &["available"],
        &["evaluation"],
        &["evaluate"],
        &["evaluated"],
        &["evaluates"],
        &["evaluation"],
        &["evaluation"],
        &["evaluations"],
        &["evaluate"],
        &["evaluated"],
        &["evaluates"],
        &["evaluating"],
        &["evaluating"],
        &["evaluating"],
        &["evaluate"],
        &["evaluate"],
        &["evaluated"],
        &["evaluate"],
        &["evaluated"],
        &["evaluates"],
        &["evaluate"],
        &["evaluated"],
        &["evaluating"],
        &["evaluates"],
        &["evaluating"],
        &["evaluation"],
        &["evaluations"],
        &["evaluator"],
        &["evaluate"],
        &["evaluated"],
        &["evaluates"],
        &["evaluating"],
        &["evaluation"],
        &["evaluations"],
        &["evaluate"],
        &["evaluated"],
        &["evaluates"],
        &["evaluating"],
        &["evaluation", "evolution"],
        &["evaluations"],
        &["evaluative"],
        &["evaluator"],
        &["evaluators"],
        &["evangelical"],
        &["evangelical"],
        &["evangelical"],
        &["avengers"],
        &["evaluate"],
        &["evaluated"],
        &["evaluates"],
        &["evaluating"],
        &["evaluation"],
        &["evaluator"],
        &["evaluated"],
        &["evaluate"],
        &["evaluated"],
        &["evaluates"],
        &["evaluation"],
    ],
    range: 4..=9,
};

static WORD_EU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EU_CHILDREN),
    value: None,
};

pub static WORD_EU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("clidian"),
        dictgen::InsensitiveStr::Ascii("gencis"),
        dictgen::InsensitiveStr::Ascii("gneics"),
        dictgen::InsensitiveStr::Ascii("hporia"),
        dictgen::InsensitiveStr::Ascii("hporic"),
        dictgen::InsensitiveStr::Ascii("ivalent"),
        dictgen::InsensitiveStr::Ascii("ivalents"),
        dictgen::InsensitiveStr::Ascii("orpean"),
        dictgen::InsensitiveStr::Ascii("orpeans"),
        dictgen::InsensitiveStr::Ascii("phoira"),
        dictgen::InsensitiveStr::Ascii("phora"),
        dictgen::InsensitiveStr::Ascii("phoriac"),
        dictgen::InsensitiveStr::Ascii("phorica"),
        dictgen::InsensitiveStr::Ascii("phorical"),
        dictgen::InsensitiveStr::Ascii("phorisch"),
        dictgen::InsensitiveStr::Ascii("phroia"),
        dictgen::InsensitiveStr::Ascii("phroic"),
        dictgen::InsensitiveStr::Ascii("qivalent"),
        dictgen::InsensitiveStr::Ascii("qivalents"),
        dictgen::InsensitiveStr::Ascii("ristic"),
        dictgen::InsensitiveStr::Ascii("ristics"),
        dictgen::InsensitiveStr::Ascii("ropeaners"),
        dictgen::InsensitiveStr::Ascii("ropeaness"),
        dictgen::InsensitiveStr::Ascii("ropen"),
        dictgen::InsensitiveStr::Ascii("ropenas"),
        dictgen::InsensitiveStr::Ascii("ropian"),
        dictgen::InsensitiveStr::Ascii("ropians"),
        dictgen::InsensitiveStr::Ascii("rpean"),
        dictgen::InsensitiveStr::Ascii("rpoean"),
        dictgen::InsensitiveStr::Ascii("rpoeans"),
        dictgen::InsensitiveStr::Ascii("thanaisa"),
        dictgen::InsensitiveStr::Ascii("thanazia"),
        dictgen::InsensitiveStr::Ascii("thanesia"),
    ],
    values: &[
        &["euclidean"],
        &["eugenics"],
        &["eugenics"],
        &["euphoria"],
        &["euphoric"],
        &["equivalent"],
        &["equivalents"],
        &["european"],
        &["europeans"],
        &["euphoria"],
        &["euphoria"],
        &["euphoric"],
        &["euphoria"],
        &["euphoria"],
        &["euphoric"],
        &["euphoria"],
        &["euphoric"],
        &["equivalent"],
        &["equivalents"],
        &["heuristic"],
        &["heuristics"],
        &["europeans"],
        &["europeans"],
        &["european"],
        &["europeans"],
        &["european"],
        &["europeans"],
        &["european"],
        &["european"],
        &["europeans"],
        &["euthanasia"],
        &["euthanasia"],
        &["euthanasia"],
    ],
    range: 5..=9,
};

static WORD_ET_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ET_CHILDREN),
    value: None,
};

pub static WORD_ET_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ablish"),
        dictgen::InsensitiveStr::Ascii("ablishd"),
        dictgen::InsensitiveStr::Ascii("ablished"),
        dictgen::InsensitiveStr::Ascii("ablishing"),
        dictgen::InsensitiveStr::Ascii("amologies"),
        dictgen::InsensitiveStr::Ascii("amology"),
        dictgen::InsensitiveStr::Ascii("cc"),
        dictgen::InsensitiveStr::Ascii("cp"),
        dictgen::InsensitiveStr::Ascii("end"),
        dictgen::InsensitiveStr::Ascii("ended"),
        dictgen::InsensitiveStr::Ascii("ender"),
        dictgen::InsensitiveStr::Ascii("enders"),
        dictgen::InsensitiveStr::Ascii("ends"),
        dictgen::InsensitiveStr::Ascii("ensible"),
        dictgen::InsensitiveStr::Ascii("ension"),
        dictgen::InsensitiveStr::Ascii("ensions"),
        dictgen::InsensitiveStr::Ascii("hcially"),
        dictgen::InsensitiveStr::Ascii("he"),
        dictgen::InsensitiveStr::Ascii("herael"),
        dictgen::InsensitiveStr::Ascii("herel"),
        dictgen::InsensitiveStr::Ascii("herenet"),
        dictgen::InsensitiveStr::Ascii("herent"),
        dictgen::InsensitiveStr::Ascii("hernal"),
        dictgen::InsensitiveStr::Ascii("hicallity"),
        dictgen::InsensitiveStr::Ascii("hicallly"),
        dictgen::InsensitiveStr::Ascii("hicaly"),
        dictgen::InsensitiveStr::Ascii("hincally"),
        dictgen::InsensitiveStr::Ascii("hincities"),
        dictgen::InsensitiveStr::Ascii("hincity"),
        dictgen::InsensitiveStr::Ascii("hnaol"),
        dictgen::InsensitiveStr::Ascii("hnicaly"),
        dictgen::InsensitiveStr::Ascii("hnicites"),
        dictgen::InsensitiveStr::Ascii("hnicitiy"),
        dictgen::InsensitiveStr::Ascii("hniticies"),
        dictgen::InsensitiveStr::Ascii("hniticy"),
        dictgen::InsensitiveStr::Ascii("hnocentricm"),
        dictgen::InsensitiveStr::Ascii("hose"),
        dictgen::InsensitiveStr::Ascii("iher"),
        dictgen::InsensitiveStr::Ascii("iquete"),
        dictgen::InsensitiveStr::Ascii("myology"),
        dictgen::InsensitiveStr::Ascii("railer"),
        dictgen::InsensitiveStr::Ascii("roneous"),
        dictgen::InsensitiveStr::Ascii("roneously"),
        dictgen::InsensitiveStr::Ascii("ropy"),
        dictgen::InsensitiveStr::Ascii("ror"),
        dictgen::InsensitiveStr::Ascii("rors"),
        dictgen::InsensitiveStr::Ascii("sablishment"),
        dictgen::InsensitiveStr::Ascii("sbalishment"),
        dictgen::InsensitiveStr::Ascii("st"),
        dictgen::InsensitiveStr::Ascii("sts"),
        dictgen::InsensitiveStr::Ascii("xt"),
    ],
    values: &[
        &["establish"],
        &["established"],
        &["established"],
        &["establishing"],
        &["etymologies"],
        &["etymology"],
        &["etc"],
        &["etc"],
        &["extend", "attend"],
        &["extended", "attended"],
        &["extender", "attender"],
        &["extenders", "attenders"],
        &["extends", "attends"],
        &["extensible"],
        &["extension"],
        &["extensions"],
        &["ethically"],
        &["the"],
        &["ethereal"],
        &["ethereal"],
        &["ethernet"],
        &["ethernet"],
        &["eternal"],
        &["ethically"],
        &["ethically"],
        &["ethically"],
        &["ethnically"],
        &["ethnicities"],
        &["ethnicity"],
        &["ethanol"],
        &["ethnically"],
        &["ethnicities"],
        &["ethnicity"],
        &["ethnicities"],
        &["ethnicity"],
        &["ethnocentrism"],
        &["those", "ethos"],
        &["either"],
        &["etiquette"],
        &["etymology"],
        &["retailer"],
        &["erroneous"],
        &["erroneously"],
        &["entropy"],
        &["error", "terror"],
        &["errors", "terrors"],
        &["establishment"],
        &["establishment"],
        &["test"],
        &["tests"],
        &["text"],
    ],
    range: 2..=11,
};

static WORD_ES_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_ES_CHILDREN),
    value: None,
};

static WORD_ES_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_ESA_NODE),
    None,
    Some(&WORD_ESC_NODE),
    None,
    Some(&WORD_ESE_NODE),
    None,
    Some(&WORD_ESG_NODE),
    None,
    Some(&WORD_ESI_NODE),
    None,
    None,
    Some(&WORD_ESL_NODE),
    None,
    Some(&WORD_ESN_NODE),
    Some(&WORD_ESO_NODE),
    Some(&WORD_ESP_NODE),
    None,
    None,
    Some(&WORD_ESS_NODE),
    Some(&WORD_EST_NODE),
    Some(&WORD_ESU_NODE),
    None,
    None,
    None,
    Some(&WORD_ESY_NODE),
    None,
];

static WORD_ESY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ESY_CHILDREN),
    value: Some(&["easy"]),
};

pub static WORD_ESY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[],
    values: &[],
    range: 0..=0,
};

static WORD_ESU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ESU_CHILDREN),
    value: None,
};

pub static WORD_ESU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("do")],
    values: &[&["sudo"]],
    range: 2..=2,
};

static WORD_EST_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EST_CHILDREN),
    value: None,
};

pub static WORD_EST_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("abilish"),
        dictgen::InsensitiveStr::Ascii("abilshment"),
        dictgen::InsensitiveStr::Ascii("abish"),
        dictgen::InsensitiveStr::Ascii("abishd"),
        dictgen::InsensitiveStr::Ascii("abished"),
        dictgen::InsensitiveStr::Ascii("abishes"),
        dictgen::InsensitiveStr::Ascii("abishing"),
        dictgen::InsensitiveStr::Ascii("ablised"),
        dictgen::InsensitiveStr::Ascii("ablishemnt"),
        dictgen::InsensitiveStr::Ascii("ablishmet"),
        dictgen::InsensitiveStr::Ascii("ablishmnet"),
        dictgen::InsensitiveStr::Ascii("ablishs"),
        dictgen::InsensitiveStr::Ascii("ablising"),
        dictgen::InsensitiveStr::Ascii("ablsihed"),
        dictgen::InsensitiveStr::Ascii("ablsihment"),
        dictgen::InsensitiveStr::Ascii("balishment"),
        dictgen::InsensitiveStr::Ascii("iamte"),
        dictgen::InsensitiveStr::Ascii("iamted"),
        dictgen::InsensitiveStr::Ascii("iamtes"),
        dictgen::InsensitiveStr::Ascii("imacion"),
        dictgen::InsensitiveStr::Ascii("image"),
        dictgen::InsensitiveStr::Ascii("images"),
        dictgen::InsensitiveStr::Ascii("imatin"),
        dictgen::InsensitiveStr::Ascii("imativo"),
        dictgen::InsensitiveStr::Ascii("ination"),
        dictgen::InsensitiveStr::Ascii("iomator"),
        dictgen::InsensitiveStr::Ascii("iomators"),
        dictgen::InsensitiveStr::Ascii("oeric"),
        dictgen::InsensitiveStr::Ascii("onija"),
        dictgen::InsensitiveStr::Ascii("oniya"),
        dictgen::InsensitiveStr::Ascii("uwarries"),
        dictgen::InsensitiveStr::Ascii("uwarry"),
    ],
    values: &[
        &["establish"],
        &["establishments"],
        &["establish"],
        &["established"],
        &["established"],
        &["establishes"],
        &["establishing"],
        &["established"],
        &["establishments"],
        &["establishments"],
        &["establishments"],
        &["establishes"],
        &["establishing"],
        &["established"],
        &["establishments"],
        &["establishments", "establishment"],
        &["estimate"],
        &["estimated"],
        &["estimates"],
        &["estimation"],
        &["estimate"],
        &["estimates"],
        &["estimation"],
        &["estimation"],
        &["estimation"],
        &["estimator"],
        &["estimators"],
        &["esoteric"],
        &["estonia"],
        &["estonia"],
        &["estuaries"],
        &["estuary"],
    ],
    range: 5..=10,
};

static WORD_ESS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ESS_CHILDREN),
    value: None,
};

pub static WORD_ESS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eintially"),
        dictgen::InsensitiveStr::Ascii("encial"),
        dictgen::InsensitiveStr::Ascii("encially"),
        dictgen::InsensitiveStr::Ascii("encials"),
        dictgen::InsensitiveStr::Ascii("ense"),
        dictgen::InsensitiveStr::Ascii("ensials"),
        dictgen::InsensitiveStr::Ascii("entail"),
        dictgen::InsensitiveStr::Ascii("entailly"),
        dictgen::InsensitiveStr::Ascii("entails"),
        dictgen::InsensitiveStr::Ascii("entaily"),
        dictgen::InsensitiveStr::Ascii("ental"),
        dictgen::InsensitiveStr::Ascii("entally"),
        dictgen::InsensitiveStr::Ascii("entals"),
        dictgen::InsensitiveStr::Ascii("entiall"),
        dictgen::InsensitiveStr::Ascii("entialls"),
        dictgen::InsensitiveStr::Ascii("entialy"),
        dictgen::InsensitiveStr::Ascii("entias"),
        dictgen::InsensitiveStr::Ascii("entiels"),
        dictgen::InsensitiveStr::Ascii("entual"),
        dictgen::InsensitiveStr::Ascii("entually"),
        dictgen::InsensitiveStr::Ascii("entuals"),
        dictgen::InsensitiveStr::Ascii("entualy"),
        dictgen::InsensitiveStr::Ascii("esital"),
        dictgen::InsensitiveStr::Ascii("esitally"),
        dictgen::InsensitiveStr::Ascii("esitaly"),
        dictgen::InsensitiveStr::Ascii("iential"),
        dictgen::InsensitiveStr::Ascii("sential"),
    ],
    values: &[
        &["essentially"],
        &["essential"],
        &["essentially"],
        &["essentials"],
        &["essence"],
        &["essentials"],
        &["essential"],
        &["essentially"],
        &["essentials"],
        &["essentially"],
        &["essential"],
        &["essentially"],
        &["essentials"],
        &["essential", "essentially"],
        &["essentials"],
        &["essentially"],
        &["essentials"],
        &["essentials"],
        &["essential"],
        &["essentially"],
        &["essentials"],
        &["essentially"],
        &["essential"],
        &["essentially"],
        &["essentially"],
        &["essential"],
        &["essential"],
    ],
    range: 4..=9,
};

static WORD_ESP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ESP_CHILDREN),
    value: None,
};

pub static WORD_ESP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("acally"),
        dictgen::InsensitiveStr::Ascii("ace"),
        dictgen::InsensitiveStr::Ascii("aced"),
        dictgen::InsensitiveStr::Ascii("aces"),
        dictgen::InsensitiveStr::Ascii("acially"),
        dictgen::InsensitiveStr::Ascii("acing"),
        dictgen::InsensitiveStr::Ascii("cially"),
        dictgen::InsensitiveStr::Ascii("ecailly"),
        dictgen::InsensitiveStr::Ascii("ecally"),
        dictgen::InsensitiveStr::Ascii("ecialy"),
        dictgen::InsensitiveStr::Ascii("ecialyl"),
        dictgen::InsensitiveStr::Ascii("ecifically"),
        dictgen::InsensitiveStr::Ascii("eciially"),
        dictgen::InsensitiveStr::Ascii("ect"),
        dictgen::InsensitiveStr::Ascii("eically"),
        dictgen::InsensitiveStr::Ascii("erate"),
        dictgen::InsensitiveStr::Ascii("escially"),
        dictgen::InsensitiveStr::Ascii("ianoge"),
        dictgen::InsensitiveStr::Ascii("inoage"),
        dictgen::InsensitiveStr::Ascii("isode"),
        dictgen::InsensitiveStr::Ascii("isodes"),
        dictgen::InsensitiveStr::Ascii("isodic"),
        dictgen::InsensitiveStr::Ascii("isodical"),
        dictgen::InsensitiveStr::Ascii("isodically"),
        dictgen::InsensitiveStr::Ascii("oinage"),
        dictgen::InsensitiveStr::Ascii("onding"),
        dictgen::InsensitiveStr::Ascii("oniage"),
        dictgen::InsensitiveStr::Ascii("orst"),
        dictgen::InsensitiveStr::Ascii("ortes"),
        dictgen::InsensitiveStr::Ascii("reso"),
        dictgen::InsensitiveStr::Ascii("ressino"),
        dictgen::InsensitiveStr::Ascii("ression"),
        dictgen::InsensitiveStr::Ascii("ressso"),
        dictgen::InsensitiveStr::Ascii("rots"),
    ],
    values: &[
        &["especially"],
        &["escape"],
        &["escaped"],
        &["escapes"],
        &["especially"],
        &["escaping"],
        &["especially"],
        &["especially"],
        &["especially"],
        &["especially"],
        &["especially"],
        &["specifically", "especially"],
        &["especially"],
        &["expect"],
        &["especially"],
        &["separate"],
        &["especially"],
        &["espionage"],
        &["espionage"],
        &["episode"],
        &["episodes"],
        &["episodic"],
        &["episodical"],
        &["episodically"],
        &["espionage"],
        &["desponding", "responding"],
        &["espionage"],
        &["esports"],
        &["esports"],
        &["espresso"],
        &["espresso"],
        &["espresso"],
        &["espresso"],
        &["esports"],
    ],
    range: 3..=10,
};

static WORD_ESO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ESO_CHILDREN),
    value: None,
};

pub static WORD_ESO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("terisch")],
    values: &[&["esoteric"]],
    range: 7..=7,
};

static WORD_ESN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ESN_CHILDREN),
    value: None,
};

pub static WORD_ESN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ure"),
        dictgen::InsensitiveStr::Ascii("ured"),
        dictgen::InsensitiveStr::Ascii("ures"),
    ],
    values: &[&["ensure"], &["ensured"], &["ensures"]],
    range: 3..=4,
};

static WORD_ESL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ESL_CHILDREN),
    value: None,
};

pub static WORD_ESL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("ewhere"),
    ],
    values: &[&["else"], &["elsewhere"]],
    range: 1..=6,
};

static WORD_ESI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ESI_CHILDREN),
    value: None,
};

pub static WORD_ESI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("est"),
        dictgen::InsensitiveStr::Ascii("ly"),
        dictgen::InsensitiveStr::Ascii("mate"),
        dictgen::InsensitiveStr::Ascii("mated"),
        dictgen::InsensitiveStr::Ascii("mates"),
        dictgen::InsensitiveStr::Ascii("mating"),
        dictgen::InsensitiveStr::Ascii("mation"),
        dictgen::InsensitiveStr::Ascii("mations"),
        dictgen::InsensitiveStr::Ascii("mator"),
        dictgen::InsensitiveStr::Ascii("mators"),
        dictgen::InsensitiveStr::Ascii("sts"),
        dictgen::InsensitiveStr::Ascii("tmate"),
        dictgen::InsensitiveStr::Ascii("tmated"),
        dictgen::InsensitiveStr::Ascii("tmates"),
        dictgen::InsensitiveStr::Ascii("tmating"),
        dictgen::InsensitiveStr::Ascii("tmation"),
        dictgen::InsensitiveStr::Ascii("tmations"),
        dictgen::InsensitiveStr::Ascii("tmator"),
        dictgen::InsensitiveStr::Ascii("tmators"),
    ],
    values: &[
        &["easiest"],
        &["easily"],
        &["estimate"],
        &["estimated"],
        &["estimates"],
        &["estimating"],
        &["estimation"],
        &["estimations"],
        &["estimator"],
        &["estimators"],
        &["exists"],
        &["estimate"],
        &["estimated"],
        &["estimates"],
        &["estimating"],
        &["estimation"],
        &["estimations"],
        &["estimator"],
        &["estimators"],
    ],
    range: 2..=8,
};

static WORD_ESG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ESG_CHILDREN),
    value: None,
};

pub static WORD_ESG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("er"),
        dictgen::InsensitiveStr::Ascii("ers"),
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("ing"),
    ],
    values: &[&["edge"], &["edger"], &["edgers"], &["edges"], &["edging"]],
    range: 1..=3,
};

static WORD_ESE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ESE_CHILDREN),
    value: None,
};

pub static WORD_ESE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cute"),
        dictgen::InsensitiveStr::Ascii("ntial"),
        dictgen::InsensitiveStr::Ascii("ntially"),
    ],
    values: &[&["execute"], &["essential"], &["essentially"]],
    range: 4..=7,
};

static WORD_ESC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ESC_CHILDREN),
    value: None,
};

pub static WORD_ESC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("alatie"),
        dictgen::InsensitiveStr::Ascii("alatin"),
        dictgen::InsensitiveStr::Ascii("alative"),
        dictgen::InsensitiveStr::Ascii("alato"),
        dictgen::InsensitiveStr::Ascii("alte"),
        dictgen::InsensitiveStr::Ascii("alted"),
        dictgen::InsensitiveStr::Ascii("altes"),
        dictgen::InsensitiveStr::Ascii("alting"),
        dictgen::InsensitiveStr::Ascii("altion"),
        dictgen::InsensitiveStr::Ascii("apeable"),
        dictgen::InsensitiveStr::Ascii("apemant"),
        dictgen::InsensitiveStr::Ascii("apse"),
        dictgen::InsensitiveStr::Ascii("artment"),
        dictgen::InsensitiveStr::Ascii("artments"),
        dictgen::InsensitiveStr::Ascii("ased"),
        dictgen::InsensitiveStr::Ascii("ate"),
        dictgen::InsensitiveStr::Ascii("ated"),
        dictgen::InsensitiveStr::Ascii("ates"),
        dictgen::InsensitiveStr::Ascii("ating"),
        dictgen::InsensitiveStr::Ascii("ation"),
        dictgen::InsensitiveStr::Ascii("avation"),
        dictgen::InsensitiveStr::Ascii("cape"),
        dictgen::InsensitiveStr::Ascii("caped"),
        dictgen::InsensitiveStr::Ascii("lude"),
        dictgen::InsensitiveStr::Ascii("luded"),
        dictgen::InsensitiveStr::Ascii("ludes"),
        dictgen::InsensitiveStr::Ascii("luding"),
        dictgen::InsensitiveStr::Ascii("lusion"),
        dictgen::InsensitiveStr::Ascii("lusions"),
        dictgen::InsensitiveStr::Ascii("pae"),
        dictgen::InsensitiveStr::Ascii("paed"),
        dictgen::InsensitiveStr::Ascii("paes"),
        dictgen::InsensitiveStr::Ascii("tasy"),
        dictgen::InsensitiveStr::Ascii("tatic"),
    ],
    values: &[
        &["escalate"],
        &["escalation"],
        &["escalate"],
        &["escalation"],
        &["escalate"],
        &["escalated"],
        &["escalates"],
        &["escalating"],
        &["escalation"],
        &["escapable"],
        &["escapement"],
        &["escapes"],
        &["escarpment"],
        &["escarpments"],
        &["escaped"],
        &["escalate", "escape"],
        &["escalated", "escaped"],
        &["escalates", "escapes"],
        &["escalating", "escaping"],
        &["escalation"],
        &["escalation"],
        &["escape"],
        &["escaped"],
        &["exclude"],
        &["excluded"],
        &["excludes"],
        &["excluding"],
        &["exclusion"],
        &["exclusions"],
        &["escape"],
        &["escaped"],
        &["escapes"],
        &["ecstasy"],
        &["ecstatic"],
    ],
    range: 3..=8,
};

static WORD_ESA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ESA_CHILDREN),
    value: None,
};

pub static WORD_ESA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cpe"),
        dictgen::InsensitiveStr::Ascii("cped"),
        dictgen::InsensitiveStr::Ascii("cpes"),
    ],
    values: &[&["escape"], &["escaped"], &["escapes"]],
    range: 3..=4,
};

static WORD_ER_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ER_CHILDREN),
    value: None,
};

pub static WORD_ER_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("alier"),
        dictgen::InsensitiveStr::Ascii("ally"),
        dictgen::InsensitiveStr::Ascii("asablocks"),
        dictgen::InsensitiveStr::Ascii("asuer"),
        dictgen::InsensitiveStr::Ascii("atic"),
        dictgen::InsensitiveStr::Ascii("atically"),
        dictgen::InsensitiveStr::Ascii("aticly"),
        dictgen::InsensitiveStr::Ascii("ested"),
        dictgen::InsensitiveStr::Ascii("formance"),
        dictgen::InsensitiveStr::Ascii("liear"),
        dictgen::InsensitiveStr::Ascii("lier"),
        dictgen::InsensitiveStr::Ascii("ly"),
        dictgen::InsensitiveStr::Ascii("mergency"),
        dictgen::InsensitiveStr::Ascii("mington"),
        dictgen::InsensitiveStr::Ascii("oneous"),
        dictgen::InsensitiveStr::Ascii("or"),
        dictgen::InsensitiveStr::Ascii("orneus"),
        dictgen::InsensitiveStr::Ascii("orneusly"),
        dictgen::InsensitiveStr::Ascii("orr"),
        dictgen::InsensitiveStr::Ascii("orrs"),
        dictgen::InsensitiveStr::Ascii("ors"),
        dictgen::InsensitiveStr::Ascii("raneously"),
        dictgen::InsensitiveStr::Ascii("ro"),
        dictgen::InsensitiveStr::Ascii("roenous"),
        dictgen::InsensitiveStr::Ascii("roneos"),
        dictgen::InsensitiveStr::Ascii("ronerous"),
        dictgen::InsensitiveStr::Ascii("roneus"),
        dictgen::InsensitiveStr::Ascii("roneusly"),
        dictgen::InsensitiveStr::Ascii("ronoeus"),
        dictgen::InsensitiveStr::Ascii("ronous"),
        dictgen::InsensitiveStr::Ascii("ronously"),
        dictgen::InsensitiveStr::Ascii("rorneous"),
        dictgen::InsensitiveStr::Ascii("rorneously"),
        dictgen::InsensitiveStr::Ascii("rorneus"),
        dictgen::InsensitiveStr::Ascii("rornoeus"),
        dictgen::InsensitiveStr::Ascii("rornous"),
        dictgen::InsensitiveStr::Ascii("rornously"),
        dictgen::InsensitiveStr::Ascii("rorr"),
        dictgen::InsensitiveStr::Ascii("rorrs"),
        dictgen::InsensitiveStr::Ascii("ros"),
        dictgen::InsensitiveStr::Ascii("rot"),
        dictgen::InsensitiveStr::Ascii("rots"),
        dictgen::InsensitiveStr::Ascii("rro"),
        dictgen::InsensitiveStr::Ascii("rror"),
        dictgen::InsensitiveStr::Ascii("rrors"),
        dictgen::InsensitiveStr::Ascii("rros"),
        dictgen::InsensitiveStr::Ascii("rupted"),
        dictgen::InsensitiveStr::Ascii("toneous"),
        dictgen::InsensitiveStr::Ascii("toneously"),
        dictgen::InsensitiveStr::Ascii("tor"),
        dictgen::InsensitiveStr::Ascii("tors"),
        dictgen::InsensitiveStr::Ascii("very"),
        dictgen::InsensitiveStr::Ascii("verything"),
        dictgen::InsensitiveStr::Ascii("vices"),
    ],
    values: &[
        &["earlier"],
        &["orally", "really"],
        &["eraseblocks"],
        &["erasure", "eraser"],
        &["erratic"],
        &["erratically"],
        &["erratically"],
        &["arrested", "erected"],
        &["performance"],
        &["earlier"],
        &["earlier"],
        &["early"],
        &["emergency"],
        &["remington"],
        &["erroneous"],
        &["error"],
        &["erroneous"],
        &["erroneously"],
        &["error"],
        &["errors"],
        &["errors"],
        &["erroneously"],
        &["error"],
        &["erroneous"],
        &["erroneous"],
        &["erroneous"],
        &["erroneous"],
        &["erroneously"],
        &["erroneous"],
        &["erroneous"],
        &["erroneously"],
        &["erroneous"],
        &["erroneously"],
        &["erroneous"],
        &["erroneous"],
        &["erroneous"],
        &["erroneously"],
        &["error"],
        &["errors"],
        &["errors"],
        &["error"],
        &["errors"],
        &["error"],
        &["error"],
        &["errors"],
        &["errors"],
        &["erupted"],
        &["erroneous"],
        &["erroneously"],
        &["error", "terror"],
        &["errors", "terrors"],
        &["every"],
        &["everything"],
        &["services"],
    ],
    range: 2..=10,
};

static WORD_EQ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_EQ_CHILDREN),
    value: None,
};

static WORD_EQ_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_EQA_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_EQI_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_EQU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_EQU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_EQU_CHILDREN),
    value: None,
};

static WORD_EQU_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_EQUA_NODE),
    None,
    None,
    None,
    Some(&WORD_EQUE_NODE),
    None,
    None,
    None,
    Some(&WORD_EQUI_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_EQUT_NODE),
    None,
    Some(&WORD_EQUV_NODE),
    None,
    None,
    None,
    None,
];

static WORD_EQUV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EQUV_CHILDREN),
    value: None,
};

pub static WORD_EQUV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("alent"),
        dictgen::InsensitiveStr::Ascii("ivalent"),
    ],
    values: &[&["equivalent"], &["equivalent"]],
    range: 5..=7,
};

static WORD_EQUT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EQUT_CHILDREN),
    value: None,
};

pub static WORD_EQUT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ion"),
        dictgen::InsensitiveStr::Ascii("ions"),
    ],
    values: &[&["equation"], &["equations"]],
    range: 3..=4,
};

static WORD_EQUI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EQUI_CHILDREN),
    value: None,
};

pub static WORD_EQUI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("alent"),
        dictgen::InsensitiveStr::Ascii("avlent"),
        dictgen::InsensitiveStr::Ascii("l"),
        dictgen::InsensitiveStr::Ascii("lavalent"),
        dictgen::InsensitiveStr::Ascii("lavent"),
        dictgen::InsensitiveStr::Ascii("lavents"),
        dictgen::InsensitiveStr::Ascii("lbirium"),
        dictgen::InsensitiveStr::Ascii("levants"),
        dictgen::InsensitiveStr::Ascii("libirum"),
        dictgen::InsensitiveStr::Ascii("libium"),
        dictgen::InsensitiveStr::Ascii("libriam"),
        dictgen::InsensitiveStr::Ascii("librim"),
        dictgen::InsensitiveStr::Ascii("libruim"),
        dictgen::InsensitiveStr::Ascii("librum"),
        dictgen::InsensitiveStr::Ascii("lvalent"),
        dictgen::InsensitiveStr::Ascii("lvalently"),
        dictgen::InsensitiveStr::Ascii("lvalents"),
        dictgen::InsensitiveStr::Ascii("ped"),
        dictgen::InsensitiveStr::Ascii("pmentd"),
        dictgen::InsensitiveStr::Ascii("pments"),
        dictgen::InsensitiveStr::Ascii("ppment"),
        dictgen::InsensitiveStr::Ascii("ptment"),
        dictgen::InsensitiveStr::Ascii("re"),
        dictgen::InsensitiveStr::Ascii("torial"),
        dictgen::InsensitiveStr::Ascii("valance"),
        dictgen::InsensitiveStr::Ascii("valant"),
        dictgen::InsensitiveStr::Ascii("valants"),
        dictgen::InsensitiveStr::Ascii("valenet"),
        dictgen::InsensitiveStr::Ascii("valentsly"),
        dictgen::InsensitiveStr::Ascii("valet"),
        dictgen::InsensitiveStr::Ascii("vallent"),
        dictgen::InsensitiveStr::Ascii("vallently"),
        dictgen::InsensitiveStr::Ascii("vallents"),
        dictgen::InsensitiveStr::Ascii("valnce"),
        dictgen::InsensitiveStr::Ascii("valnet"),
        dictgen::InsensitiveStr::Ascii("velance"),
        dictgen::InsensitiveStr::Ascii("velant"),
        dictgen::InsensitiveStr::Ascii("velants"),
        dictgen::InsensitiveStr::Ascii("velent"),
        dictgen::InsensitiveStr::Ascii("velents"),
        dictgen::InsensitiveStr::Ascii("vilant"),
        dictgen::InsensitiveStr::Ascii("vilants"),
        dictgen::InsensitiveStr::Ascii("vilence"),
        dictgen::InsensitiveStr::Ascii("vilent"),
        dictgen::InsensitiveStr::Ascii("vilents"),
        dictgen::InsensitiveStr::Ascii("vivalent"),
        dictgen::InsensitiveStr::Ascii("vlaent"),
        dictgen::InsensitiveStr::Ascii("vlalent"),
        dictgen::InsensitiveStr::Ascii("vlanets"),
        dictgen::InsensitiveStr::Ascii("vlantly"),
        dictgen::InsensitiveStr::Ascii("vlent"),
        dictgen::InsensitiveStr::Ascii("vlently"),
        dictgen::InsensitiveStr::Ascii("vlents"),
        dictgen::InsensitiveStr::Ascii("volence"),
        dictgen::InsensitiveStr::Ascii("volent"),
        dictgen::InsensitiveStr::Ascii("volents"),
        dictgen::InsensitiveStr::Ascii("vqlent"),
    ],
    values: &[
        &["equivalent"],
        &["equivalents"],
        &["equal"],
        &["equivalent"],
        &["equivalent"],
        &["equivalents"],
        &["equilibrium"],
        &["equivalents"],
        &["equilibrium"],
        &["equilibrium"],
        &["equilibrium"],
        &["equilibrium"],
        &["equilibrium"],
        &["equilibrium"],
        &["equivalent"],
        &["equivalently"],
        &["equivalents"],
        &["equipped"],
        &["equipment"],
        &["equipment"],
        &["equipment"],
        &["equipment"],
        &["require", "enquire", "equine", "esquire"],
        &["equatorial"],
        &["equivalence"],
        &["equivalent"],
        &["equivalents"],
        &["equivalents", "equivalent"],
        &["equivalently", "equivalency"],
        &["equivalents"],
        &["equivalent"],
        &["equivalently"],
        &["equivalents"],
        &["equivalence"],
        &["equivalents"],
        &["equivalence"],
        &["equivalent"],
        &["equivalents"],
        &["equivalent"],
        &["equivalents"],
        &["equivalent"],
        &["equivalents"],
        &["equivalence"],
        &["equivalent"],
        &["equivalents"],
        &["equivalent"],
        &["equivalents"],
        &["equivalent"],
        &["equivalents"],
        &["equivalently"],
        &["equivalent"],
        &["equivalently"],
        &["equivalents"],
        &["equivalence"],
        &["equivalent"],
        &["equivalents"],
        &["equivalent"],
    ],
    range: 1..=9,
};

static WORD_EQUE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EQUE_CHILDREN),
    value: None,
};

pub static WORD_EQUE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ation"),
        dictgen::InsensitiveStr::Ascii("ations"),
        dictgen::InsensitiveStr::Ascii("l"),
        dictgen::InsensitiveStr::Ascii("librium"),
    ],
    values: &[&["equation"], &["equations"], &["equal"], &["equilibrium"]],
    range: 1..=7,
};

static WORD_EQUA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EQUA_CHILDREN),
    value: None,
};

pub static WORD_EQUA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ilateral"),
        dictgen::InsensitiveStr::Ascii("ilty"),
        dictgen::InsensitiveStr::Ascii("librium"),
        dictgen::InsensitiveStr::Ascii("ll"),
        dictgen::InsensitiveStr::Ascii("llity"),
        dictgen::InsensitiveStr::Ascii("lls"),
        dictgen::InsensitiveStr::Ascii("ly"),
    ],
    values: &[
        &["equilateral"],
        &["equality"],
        &["equilibrium"],
        &["equal", "equally"],
        &["equality"],
        &["equals"],
        &["equally"],
    ],
    range: 2..=8,
};

static WORD_EQI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EQI_CHILDREN),
    value: None,
};

pub static WORD_EQI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("valent"),
        dictgen::InsensitiveStr::Ascii("valents"),
    ],
    values: &[&["equivalent"], &["equivalents"]],
    range: 6..=7,
};

static WORD_EQA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EQA_CHILDREN),
    value: None,
};

pub static WORD_EQA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ul"),
        dictgen::InsensitiveStr::Ascii("ulity"),
        dictgen::InsensitiveStr::Ascii("ulizer"),
        dictgen::InsensitiveStr::Ascii("ution"),
        dictgen::InsensitiveStr::Ascii("utions"),
    ],
    values: &[
        &["equal"],
        &["equality"],
        &["equalizer"],
        &["equation"],
        &["equations"],
    ],
    range: 2..=6,
};

static WORD_EP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EP_CHILDREN),
    value: None,
};

pub static WORD_EP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ecifica"),
        dictgen::InsensitiveStr::Ascii("ect"),
        dictgen::InsensitiveStr::Ascii("ected"),
        dictgen::InsensitiveStr::Ascii("ectedly"),
        dictgen::InsensitiveStr::Ascii("ecting"),
        dictgen::InsensitiveStr::Ascii("ects"),
        dictgen::InsensitiveStr::Ascii("hememeral"),
        dictgen::InsensitiveStr::Ascii("hememeris"),
        dictgen::InsensitiveStr::Ascii("hemereal"),
        dictgen::InsensitiveStr::Ascii("hemereally"),
        dictgen::InsensitiveStr::Ascii("hermeral"),
        dictgen::InsensitiveStr::Ascii("himeral"),
        dictgen::InsensitiveStr::Ascii("hipany"),
        dictgen::InsensitiveStr::Ascii("idsodes"),
        dictgen::InsensitiveStr::Ascii("igramic"),
        dictgen::InsensitiveStr::Ascii("ihpany"),
        dictgen::InsensitiveStr::Ascii("ilepsey"),
        dictgen::InsensitiveStr::Ascii("ilespy"),
        dictgen::InsensitiveStr::Ascii("ilgoue"),
        dictgen::InsensitiveStr::Ascii("iloge"),
        dictgen::InsensitiveStr::Ascii("iphanny"),
        dictgen::InsensitiveStr::Ascii("isdoe"),
        dictgen::InsensitiveStr::Ascii("isdoes"),
        dictgen::InsensitiveStr::Ascii("isonage"),
        dictgen::InsensitiveStr::Ascii("itamy"),
        dictgen::InsensitiveStr::Ascii("itomie"),
        dictgen::InsensitiveStr::Ascii("liepsy"),
        dictgen::InsensitiveStr::Ascii("liogue"),
        dictgen::InsensitiveStr::Ascii("loit"),
        dictgen::InsensitiveStr::Ascii("loits"),
        dictgen::InsensitiveStr::Ascii("mty"),
        dictgen::InsensitiveStr::Ascii("ressions"),
        dictgen::InsensitiveStr::Ascii("scially"),
        dictgen::InsensitiveStr::Ascii("siode"),
        dictgen::InsensitiveStr::Ascii("siodes"),
        dictgen::InsensitiveStr::Ascii("sionage"),
        dictgen::InsensitiveStr::Ascii("slion"),
        dictgen::InsensitiveStr::Ascii("sorts"),
        dictgen::InsensitiveStr::Ascii("sresso"),
        dictgen::InsensitiveStr::Ascii("tied"),
        dictgen::InsensitiveStr::Ascii("tier"),
        dictgen::InsensitiveStr::Ascii("ties"),
        dictgen::InsensitiveStr::Ascii("tiome"),
        dictgen::InsensitiveStr::Ascii("trapolate"),
        dictgen::InsensitiveStr::Ascii("trapolated"),
        dictgen::InsensitiveStr::Ascii("trapolates"),
        dictgen::InsensitiveStr::Ascii("ty"),
        dictgen::InsensitiveStr::Ascii("xand"),
        dictgen::InsensitiveStr::Ascii("xanded"),
        dictgen::InsensitiveStr::Ascii("xected"),
        dictgen::InsensitiveStr::Ascii("xiressions"),
        dictgen::InsensitiveStr::Ascii("xlicit"),
    ],
    values: &[
        &["especifica"],
        &["expect"],
        &["expected"],
        &["expectedly"],
        &["expecting"],
        &["expects"],
        &["ephemeral"],
        &["ephemeris"],
        &["ephemeral"],
        &["ephemerally"],
        &["ephemeral"],
        &["ephemeral"],
        &["epiphany"],
        &["episodes"],
        &["epigrammatic"],
        &["epiphany"],
        &["epilepsy"],
        &["epilepsy"],
        &["epilogue"],
        &["epilogue"],
        &["epiphany"],
        &["episode"],
        &["episodes"],
        &["espionage"],
        &["epitome"],
        &["epitome"],
        &["epilepsy"],
        &["epilogue"],
        &["exploit"],
        &["exploits"],
        &["empty"],
        &["expressions"],
        &["specially"],
        &["episode"],
        &["episodes"],
        &["espionage"],
        &["epsilon"],
        &["esports"],
        &["espresso"],
        &["emptied"],
        &["emptier"],
        &["empties"],
        &["epitome"],
        &["extrapolate"],
        &["extrapolated"],
        &["extrapolates"],
        &["empty"],
        &["expand"],
        &["expanded"],
        &["expected"],
        &["expressions"],
        &["explicit"],
    ],
    range: 2..=10,
};

static WORD_EN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_EN_CHILDREN),
    value: None,
};

static WORD_EN_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_ENA_NODE),
    Some(&WORD_ENB_NODE),
    Some(&WORD_ENC_NODE),
    Some(&WORD_END_NODE),
    Some(&WORD_ENE_NODE),
    Some(&WORD_ENF_NODE),
    Some(&WORD_ENG_NODE),
    Some(&WORD_ENH_NODE),
    Some(&WORD_ENI_NODE),
    None,
    None,
    Some(&WORD_ENL_NODE),
    Some(&WORD_ENM_NODE),
    Some(&WORD_ENN_NODE),
    Some(&WORD_ENO_NODE),
    Some(&WORD_ENP_NODE),
    Some(&WORD_ENQ_NODE),
    Some(&WORD_ENR_NODE),
    Some(&WORD_ENS_NODE),
    Some(&WORD_ENT_NODE),
    Some(&WORD_ENU_NODE),
    Some(&WORD_ENV_NODE),
    None,
    Some(&WORD_ENX_NODE),
    Some(&WORD_ENY_NODE),
    None,
];

static WORD_ENY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ENY_CHILDREN),
    value: None,
};

pub static WORD_ENY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("thing"),
        dictgen::InsensitiveStr::Ascii("way"),
    ],
    values: &[&["anything"], &["anyway"]],
    range: 3..=5,
};

static WORD_ENX_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ENX_CHILDREN),
    value: None,
};

pub static WORD_ENX_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("t")],
    values: &[&["next"]],
    range: 1..=1,
};

static WORD_ENV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_ENV_CHILDREN),
    value: None,
};

static WORD_ENV_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_ENVA_NODE),
    None,
    None,
    None,
    Some(&WORD_ENVE_NODE),
    None,
    None,
    None,
    Some(&WORD_ENVI_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_ENVO_NODE),
    None,
    None,
    Some(&WORD_ENVR_NODE),
    None,
    None,
    None,
    Some(&WORD_ENVV_NODE),
    None,
    None,
    None,
    None,
];

static WORD_ENVV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ENVV_CHILDREN),
    value: None,
};

pub static WORD_ENVV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ironment")],
    values: &[&["environment"]],
    range: 8..=8,
};

static WORD_ENVR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ENVR_CHILDREN),
    value: None,
};

pub static WORD_ENVR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ion"),
        dictgen::InsensitiveStr::Ascii("ionment"),
        dictgen::InsensitiveStr::Ascii("ionmental"),
        dictgen::InsensitiveStr::Ascii("ionmentally"),
        dictgen::InsensitiveStr::Ascii("ionments"),
        dictgen::InsensitiveStr::Ascii("ions"),
        dictgen::InsensitiveStr::Ascii("iron"),
        dictgen::InsensitiveStr::Ascii("ironment"),
        dictgen::InsensitiveStr::Ascii("ironmental"),
        dictgen::InsensitiveStr::Ascii("ironments"),
        dictgen::InsensitiveStr::Ascii("irons"),
        dictgen::InsensitiveStr::Ascii("yption"),
    ],
    values: &[
        &["environ"],
        &["environment"],
        &["environmental"],
        &["environmentally"],
        &["environments"],
        &["environs"],
        &["environ"],
        &["environment"],
        &["environmental"],
        &["environments"],
        &["environs"],
        &["encryption"],
    ],
    range: 3..=11,
};

static WORD_ENVO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ENVO_CHILDREN),
    value: None,
};

pub static WORD_ENVO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ke"),
        dictgen::InsensitiveStr::Ascii("ked"),
        dictgen::InsensitiveStr::Ascii("ker"),
        dictgen::InsensitiveStr::Ascii("kes"),
        dictgen::InsensitiveStr::Ascii("king"),
        dictgen::InsensitiveStr::Ascii("lutionary"),
        dictgen::InsensitiveStr::Ascii("lved"),
        dictgen::InsensitiveStr::Ascii("rce"),
    ],
    values: &[
        &["evoke", "invoke"],
        &["evoked", "invoked"],
        &["evoker", "invoker"],
        &["evokes", "invokes"],
        &["invoking", "evoking"],
        &["evolutionary"],
        &["involved"],
        &["enforce"],
    ],
    range: 2..=9,
};

static WORD_ENVI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_ENVI_CHILDREN),
    value: None,
};

static WORD_ENVI_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_ENVIN_NODE),
    Some(&WORD_ENVIO_NODE),
    None,
    None,
    Some(&WORD_ENVIR_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_ENVIR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ENVIR_CHILDREN),
    value: None,
};

pub static WORD_ENVIR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eonment"),
        dictgen::InsensitiveStr::Ascii("ionment"),
        dictgen::InsensitiveStr::Ascii("nment"),
        dictgen::InsensitiveStr::Ascii("nmental"),
        dictgen::InsensitiveStr::Ascii("nments"),
        dictgen::InsensitiveStr::Ascii("noment"),
        dictgen::InsensitiveStr::Ascii("noments"),
        dictgen::InsensitiveStr::Ascii("oiment"),
        dictgen::InsensitiveStr::Ascii("oment"),
        dictgen::InsensitiveStr::Ascii("omental"),
        dictgen::InsensitiveStr::Ascii("omentalist"),
        dictgen::InsensitiveStr::Ascii("omentally"),
        dictgen::InsensitiveStr::Ascii("oments"),
        dictgen::InsensitiveStr::Ascii("omnent"),
        dictgen::InsensitiveStr::Ascii("omnental"),
        dictgen::InsensitiveStr::Ascii("omnentally"),
        dictgen::InsensitiveStr::Ascii("omnents"),
        dictgen::InsensitiveStr::Ascii("onement"),
        dictgen::InsensitiveStr::Ascii("onemnt"),
        dictgen::InsensitiveStr::Ascii("onemntal"),
        dictgen::InsensitiveStr::Ascii("onemntally"),
        dictgen::InsensitiveStr::Ascii("onemnts"),
        dictgen::InsensitiveStr::Ascii("onemt"),
        dictgen::InsensitiveStr::Ascii("onemtal"),
        dictgen::InsensitiveStr::Ascii("onemts"),
        dictgen::InsensitiveStr::Ascii("onent"),
        dictgen::InsensitiveStr::Ascii("onmane"),
        dictgen::InsensitiveStr::Ascii("onmen"),
        dictgen::InsensitiveStr::Ascii("onmenet"),
        dictgen::InsensitiveStr::Ascii("onmenets"),
        dictgen::InsensitiveStr::Ascii("onmentality"),
        dictgen::InsensitiveStr::Ascii("onmentals"),
        dictgen::InsensitiveStr::Ascii("onmentaly"),
        dictgen::InsensitiveStr::Ascii("onmentl"),
        dictgen::InsensitiveStr::Ascii("onmently"),
        dictgen::InsensitiveStr::Ascii("onmet"),
        dictgen::InsensitiveStr::Ascii("onmetal"),
        dictgen::InsensitiveStr::Ascii("onmets"),
        dictgen::InsensitiveStr::Ascii("onmnet"),
        dictgen::InsensitiveStr::Ascii("onmont"),
        dictgen::InsensitiveStr::Ascii("onnement"),
        dictgen::InsensitiveStr::Ascii("ontment"),
    ],
    values: &[
        &["environment"],
        &["environment"],
        &["environment"],
        &["environmental"],
        &["environments"],
        &["environment"],
        &["environments"],
        &["environment"],
        &["environment"],
        &["environmental"],
        &["environmentalist"],
        &["environmentally"],
        &["environments"],
        &["environments", "environment"],
        &["environmental"],
        &["environmentally"],
        &["environments"],
        &["environment"],
        &["environment"],
        &["environmental"],
        &["environmentally"],
        &["environments"],
        &["environment"],
        &["environmental"],
        &["environments"],
        &["environment"],
        &["environment"],
        &["environment"],
        &["environment"],
        &["environments"],
        &["environmentally"],
        &["environments"],
        &["environmentally"],
        &["environmentally"],
        &["environmental"],
        &["environments", "environment"],
        &["environmental"],
        &["environments"],
        &["environments", "environment"],
        &["environment"],
        &["environment"],
        &["environment"],
    ],
    range: 5..=11,
};

static WORD_ENVIO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ENVIO_CHILDREN),
    value: None,
};

pub static WORD_ENVIO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ment"),
        dictgen::InsensitiveStr::Ascii("mental"),
        dictgen::InsensitiveStr::Ascii("ments"),
        dictgen::InsensitiveStr::Ascii("nment"),
        dictgen::InsensitiveStr::Ascii("nmental"),
        dictgen::InsensitiveStr::Ascii("nments"),
        dictgen::InsensitiveStr::Ascii("nrment"),
        dictgen::InsensitiveStr::Ascii("rement"),
        dictgen::InsensitiveStr::Ascii("remental"),
        dictgen::InsensitiveStr::Ascii("rements"),
        dictgen::InsensitiveStr::Ascii("renment"),
        dictgen::InsensitiveStr::Ascii("renmental"),
        dictgen::InsensitiveStr::Ascii("renments"),
        dictgen::InsensitiveStr::Ascii("rment"),
        dictgen::InsensitiveStr::Ascii("rmental"),
        dictgen::InsensitiveStr::Ascii("rmentally"),
        dictgen::InsensitiveStr::Ascii("rments"),
        dictgen::InsensitiveStr::Ascii("rnemnt"),
        dictgen::InsensitiveStr::Ascii("rnemntal"),
        dictgen::InsensitiveStr::Ascii("rnemnts"),
        dictgen::InsensitiveStr::Ascii("rnment"),
        dictgen::InsensitiveStr::Ascii("rnmental"),
        dictgen::InsensitiveStr::Ascii("rnmentalist"),
        dictgen::InsensitiveStr::Ascii("rnmentally"),
        dictgen::InsensitiveStr::Ascii("rnments"),
        dictgen::InsensitiveStr::Ascii("ronment"),
        dictgen::InsensitiveStr::Ascii("ronmental"),
        dictgen::InsensitiveStr::Ascii("ronments"),
    ],
    values: &[
        &["environment"],
        &["environmental"],
        &["environments"],
        &["environment"],
        &["environmental"],
        &["environments"],
        &["environment"],
        &["environment"],
        &["environmental"],
        &["environments"],
        &["environment"],
        &["environmental"],
        &["environments"],
        &["environment"],
        &["environmental"],
        &["environmentally"],
        &["environments"],
        &["environment"],
        &["environmental"],
        &["environments"],
        &["environment"],
        &["environmental"],
        &["environmentalist"],
        &["environmentally"],
        &["environments"],
        &["environment"],
        &["environmental"],
        &["environments"],
    ],
    range: 4..=11,
};

static WORD_ENVIN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ENVIN_CHILDREN),
    value: None,
};

pub static WORD_ENVIN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("roment"),
        dictgen::InsensitiveStr::Ascii("ronment"),
        dictgen::InsensitiveStr::Ascii("ronments"),
    ],
    values: &[&["environments"], &["environment"], &["environments"]],
    range: 6..=8,
};

static WORD_ENVE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ENVE_CHILDREN),
    value: None,
};

pub static WORD_ENVE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("loppe"),
        dictgen::InsensitiveStr::Ascii("lopped"),
        dictgen::InsensitiveStr::Ascii("loppen"),
        dictgen::InsensitiveStr::Ascii("loppes"),
        dictgen::InsensitiveStr::Ascii("lopping"),
        dictgen::InsensitiveStr::Ascii("r"),
    ],
    values: &[
        &["envelope"],
        &["envelope", "enveloped"],
        &["envelope"],
        &["envelope", "envelopes"],
        &["enveloping"],
        &["never"],
    ],
    range: 1..=7,
};

static WORD_ENVA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ENVA_CHILDREN),
    value: None,
};

pub static WORD_ENVA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("luation")],
    values: &[&["evaluation"]],
    range: 7..=7,
};

static WORD_ENU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ENU_CHILDREN),
    value: None,
};

pub static WORD_ENU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("f"),
        dictgen::InsensitiveStr::Ascii("lation"),
        dictgen::InsensitiveStr::Ascii("marate"),
        dictgen::InsensitiveStr::Ascii("marated"),
        dictgen::InsensitiveStr::Ascii("marates"),
        dictgen::InsensitiveStr::Ascii("marating"),
        dictgen::InsensitiveStr::Ascii("mation"),
        dictgen::InsensitiveStr::Ascii("mearate"),
        dictgen::InsensitiveStr::Ascii("mearation"),
        dictgen::InsensitiveStr::Ascii("meratior"),
        dictgen::InsensitiveStr::Ascii("meratiors"),
        dictgen::InsensitiveStr::Ascii("merble"),
        dictgen::InsensitiveStr::Ascii("mertaion"),
        dictgen::InsensitiveStr::Ascii("mrate"),
        dictgen::InsensitiveStr::Ascii("mrates"),
        dictgen::InsensitiveStr::Ascii("sre"),
    ],
    values: &[
        &["enough"],
        &["emulation"],
        &["enumerate"],
        &["enumerated"],
        &["enumerates"],
        &["enumerating"],
        &["enumeration"],
        &["enumerate"],
        &["enumeration"],
        &["enumerator"],
        &["enumerators"],
        &["enumerable"],
        &["enumeration"],
        &["enumerate"],
        &["enumerates"],
        &["ensure"],
    ],
    range: 1..=9,
};

static WORD_ENT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_ENT_CHILDREN),
    value: None,
};

static WORD_ENT_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_ENTA_NODE),
    Some(&WORD_ENTB_NODE),
    None,
    None,
    Some(&WORD_ENTE_NODE),
    None,
    None,
    Some(&WORD_ENTH_NODE),
    Some(&WORD_ENTI_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_ENTO_NODE),
    None,
    Some(&WORD_ENTQ_NODE),
    Some(&WORD_ENTR_NODE),
    None,
    Some(&WORD_ENTT_NODE),
    Some(&WORD_ENTU_NODE),
    None,
    None,
    None,
    Some(&WORD_ENTY_NODE),
    None,
];

static WORD_ENTY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ENTY_CHILDREN),
    value: Some(&["entry", "entity"]),
};

pub static WORD_ENTY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[],
    values: &[],
    range: 0..=0,
};

static WORD_ENTU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ENTU_CHILDREN),
    value: None,
};

pub static WORD_ENTU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("siastic"),
        dictgen::InsensitiveStr::Ascii("siastically"),
    ],
    values: &[&["enthusiastic"], &["enthusiastically"]],
    range: 7..=11,
};

static WORD_ENTT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ENTT_CHILDREN),
    value: None,
};

pub static WORD_ENTT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ries"),
        dictgen::InsensitiveStr::Ascii("ry"),
    ],
    values: &[&["entries"], &["entry"]],
    range: 2..=4,
};

static WORD_ENTR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ENTR_CHILDREN),
    value: None,
};

pub static WORD_ENTR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ace"),
        dictgen::InsensitiveStr::Ascii("aced"),
        dictgen::InsensitiveStr::Ascii("aces"),
        dictgen::InsensitiveStr::Ascii("apeneur"),
        dictgen::InsensitiveStr::Ascii("apeneurs"),
        dictgen::InsensitiveStr::Ascii("eis"),
        dictgen::InsensitiveStr::Ascii("epeneur"),
        dictgen::InsensitiveStr::Ascii("epeneurs"),
        dictgen::InsensitiveStr::Ascii("eperneur"),
        dictgen::InsensitiveStr::Ascii("eperure"),
        dictgen::InsensitiveStr::Ascii("epeuner"),
        dictgen::InsensitiveStr::Ascii("epraneurs"),
        dictgen::InsensitiveStr::Ascii("eprenaur"),
        dictgen::InsensitiveStr::Ascii("eprenaurs"),
        dictgen::InsensitiveStr::Ascii("eprener"),
        dictgen::InsensitiveStr::Ascii("epreners"),
        dictgen::InsensitiveStr::Ascii("epreneuer"),
        dictgen::InsensitiveStr::Ascii("epreneuers"),
        dictgen::InsensitiveStr::Ascii("epreneurers"),
        dictgen::InsensitiveStr::Ascii("epreneures"),
        dictgen::InsensitiveStr::Ascii("epreneus"),
        dictgen::InsensitiveStr::Ascii("eprenour"),
        dictgen::InsensitiveStr::Ascii("eprenours"),
        dictgen::InsensitiveStr::Ascii("eprenuers"),
        dictgen::InsensitiveStr::Ascii("eprenur"),
        dictgen::InsensitiveStr::Ascii("eprenure"),
        dictgen::InsensitiveStr::Ascii("eprenures"),
        dictgen::InsensitiveStr::Ascii("eprenurs"),
        dictgen::InsensitiveStr::Ascii("epreuner"),
        dictgen::InsensitiveStr::Ascii("epreuners"),
        dictgen::InsensitiveStr::Ascii("eprise"),
        dictgen::InsensitiveStr::Ascii("etained"),
        dictgen::InsensitiveStr::Ascii("etaining"),
        dictgen::InsensitiveStr::Ascii("etainment"),
        dictgen::InsensitiveStr::Ascii("ie"),
        dictgen::InsensitiveStr::Ascii("iess"),
        dictgen::InsensitiveStr::Ascii("iy"),
        dictgen::InsensitiveStr::Ascii("opay"),
        dictgen::InsensitiveStr::Ascii("ophy"),
        dictgen::InsensitiveStr::Ascii("ys"),
    ],
    values: &[
        &["entrance"],
        &["entranced"],
        &["entrances"],
        &["entrepreneur"],
        &["entrepreneur"],
        &["entries"],
        &["entrepreneur"],
        &["entrepreneurs"],
        &["entrepreneurs"],
        &["entrepreneur"],
        &["entrepreneur"],
        &["entrepreneurs"],
        &["entrepreneur"],
        &["entrepreneurs"],
        &["entrepreneurs"],
        &["entrepreneurs"],
        &["entrepreneurs"],
        &["entrepreneurs"],
        &["entrepreneurs"],
        &["entrepreneurs"],
        &["entrepreneurs"],
        &["entrepreneur"],
        &["entrepreneurs"],
        &["entrepreneurs"],
        &["entrepreneur"],
        &["entrepreneurs"],
        &["entrepreneurs"],
        &["entrepreneurs"],
        &["entrepreneurs"],
        &["entrepreneurs"],
        &["enterprise"],
        &["entertained"],
        &["entertaining"],
        &["entertainment"],
        &["entry", "entries"],
        &["entries"],
        &["entry", "entries"],
        &["entropy"],
        &["entropy"],
        &["entries", "entry"],
    ],
    range: 2..=11,
};

static WORD_ENTQ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ENTQ_CHILDREN),
    value: None,
};

pub static WORD_ENTQ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("uire"),
        dictgen::InsensitiveStr::Ascii("uired"),
        dictgen::InsensitiveStr::Ascii("uires"),
        dictgen::InsensitiveStr::Ascii("uiries"),
        dictgen::InsensitiveStr::Ascii("uiry"),
    ],
    values: &[
        &["enquire"],
        &["enquired"],
        &["enquires"],
        &["enquiries"],
        &["enquiry"],
    ],
    range: 4..=6,
};

static WORD_ENTO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ENTO_CHILDREN),
    value: None,
};

pub static WORD_ENTO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("rpy"),
        dictgen::InsensitiveStr::Ascii("ties"),
        dictgen::InsensitiveStr::Ascii("ty"),
        dictgen::InsensitiveStr::Ascii("xication"),
    ],
    values: &[&["entropy"], &["entities"], &["entity"], &["intoxication"]],
    range: 2..=8,
};

static WORD_ENTI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ENTI_CHILDREN),
    value: None,
};

pub static WORD_ENTI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("erly"),
        dictgen::InsensitiveStr::Ascii("erty"),
        dictgen::InsensitiveStr::Ascii("lted"),
        dictgen::InsensitiveStr::Ascii("red"),
        dictgen::InsensitiveStr::Ascii("reity"),
        dictgen::InsensitiveStr::Ascii("relly"),
        dictgen::InsensitiveStr::Ascii("res"),
        dictgen::InsensitiveStr::Ascii("rey"),
        dictgen::InsensitiveStr::Ascii("rity"),
        dictgen::InsensitiveStr::Ascii("rley"),
        dictgen::InsensitiveStr::Ascii("rly"),
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("te"),
        dictgen::InsensitiveStr::Ascii("tee"),
        dictgen::InsensitiveStr::Ascii("tees"),
        dictgen::InsensitiveStr::Ascii("teld"),
        dictgen::InsensitiveStr::Ascii("tes"),
        dictgen::InsensitiveStr::Ascii("ti"),
        dictgen::InsensitiveStr::Ascii("tie"),
        dictgen::InsensitiveStr::Ascii("tites"),
        dictgen::InsensitiveStr::Ascii("tities"),
        dictgen::InsensitiveStr::Ascii("tity"),
        dictgen::InsensitiveStr::Ascii("tiy"),
        dictgen::InsensitiveStr::Ascii("tiys"),
        dictgen::InsensitiveStr::Ascii("tlied"),
        dictgen::InsensitiveStr::Ascii("tys"),
        dictgen::InsensitiveStr::Ascii("y"),
    ],
    values: &[
        &["entirely"],
        &["entirety"],
        &["entitled"],
        &["entered", "entire"],
        &["entirety"],
        &["entirely"],
        &["entries"],
        &["entirety", "entirely"],
        &["entirety"],
        &["entirely"],
        &["entirely"],
        &["entity"],
        &["entire", "entity"],
        &["entity"],
        &["entities"],
        &["entitled"],
        &["entities"],
        &["entity"],
        &["entity"],
        &["entities"],
        &["entities"],
        &["entity"],
        &["entity"],
        &["entities"],
        &["entitled"],
        &["entities"],
        &["entity"],
    ],
    range: 1..=6,
};

static WORD_ENTH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ENTH_CHILDREN),
    value: None,
};

pub static WORD_ENTH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aplies"),
        dictgen::InsensitiveStr::Ascii("aply"),
        dictgen::InsensitiveStr::Ascii("ically"),
        dictgen::InsensitiveStr::Ascii("icities"),
        dictgen::InsensitiveStr::Ascii("icity"),
        dictgen::InsensitiveStr::Ascii("isiast"),
        dictgen::InsensitiveStr::Ascii("isiasts"),
        dictgen::InsensitiveStr::Ascii("ousiasm"),
        dictgen::InsensitiveStr::Ascii("uasists"),
        dictgen::InsensitiveStr::Ascii("uiasts"),
        dictgen::InsensitiveStr::Ascii("uisast"),
        dictgen::InsensitiveStr::Ascii("uisasts"),
        dictgen::InsensitiveStr::Ascii("usaists"),
        dictgen::InsensitiveStr::Ascii("useastic"),
        dictgen::InsensitiveStr::Ascii("useastically"),
        dictgen::InsensitiveStr::Ascii("useasticly"),
        dictgen::InsensitiveStr::Ascii("usiaists"),
        dictgen::InsensitiveStr::Ascii("usiam"),
        dictgen::InsensitiveStr::Ascii("usiams"),
        dictgen::InsensitiveStr::Ascii("usiant"),
        dictgen::InsensitiveStr::Ascii("usiants"),
        dictgen::InsensitiveStr::Ascii("usiasic"),
        dictgen::InsensitiveStr::Ascii("usiasim"),
        dictgen::InsensitiveStr::Ascii("usiasists"),
        dictgen::InsensitiveStr::Ascii("usiastics"),
        dictgen::InsensitiveStr::Ascii("usiastisch"),
        dictgen::InsensitiveStr::Ascii("usiasum"),
        dictgen::InsensitiveStr::Ascii("usiat"),
        dictgen::InsensitiveStr::Ascii("usiatic"),
        dictgen::InsensitiveStr::Ascii("usiats"),
        dictgen::InsensitiveStr::Ascii("usiest"),
        dictgen::InsensitiveStr::Ascii("usiests"),
        dictgen::InsensitiveStr::Ascii("usigasm"),
        dictgen::InsensitiveStr::Ascii("usisast"),
        dictgen::InsensitiveStr::Ascii("usists"),
        dictgen::InsensitiveStr::Ascii("usuastic"),
    ],
    values: &[
        &["enthalpies"],
        &["enthalpy"],
        &["ethnically"],
        &["ethnicities"],
        &["ethnicity"],
        &["enthusiast"],
        &["enthusiasts"],
        &["enthusiasm"],
        &["enthusiasts"],
        &["enthusiast"],
        &["enthusiasts"],
        &["enthusiasts"],
        &["enthusiasts"],
        &["enthusiastic"],
        &["enthusiastically"],
        &["enthusiastically"],
        &["enthusiasts"],
        &["enthusiasm"],
        &["enthusiasm"],
        &["enthusiast"],
        &["enthusiast"],
        &["enthusiastic"],
        &["enthusiasm"],
        &["enthusiasts"],
        &["enthusiasts"],
        &["enthusiastic"],
        &["enthusiasm"],
        &["enthusiast"],
        &["enthusiastic"],
        &["enthusiast"],
        &["enthusiast"],
        &["enthusiasts"],
        &["enthusiasm"],
        &["enthusiasts"],
        &["enthusiasts"],
        &["enthusiastic"],
    ],
    range: 4..=12,
};

static WORD_ENTE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ENTE_CHILDREN),
    value: None,
};

pub static WORD_ENTE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("nd"),
        dictgen::InsensitiveStr::Ascii("nded"),
        dictgen::InsensitiveStr::Ascii("nding"),
        dictgen::InsensitiveStr::Ascii("nds"),
        dictgen::InsensitiveStr::Ascii("nsion"),
        dictgen::InsensitiveStr::Ascii("nsions"),
        dictgen::InsensitiveStr::Ascii("nt"),
        dictgen::InsensitiveStr::Ascii("ntries"),
        dictgen::InsensitiveStr::Ascii("nts"),
        dictgen::InsensitiveStr::Ascii("rance"),
        dictgen::InsensitiveStr::Ascii("ratinment"),
        dictgen::InsensitiveStr::Ascii("reing"),
        dictgen::InsensitiveStr::Ascii("rie"),
        dictgen::InsensitiveStr::Ascii("ries"),
        dictgen::InsensitiveStr::Ascii("rily"),
        dictgen::InsensitiveStr::Ascii("rity"),
        dictgen::InsensitiveStr::Ascii("rpirse"),
        dictgen::InsensitiveStr::Ascii("rpirses"),
        dictgen::InsensitiveStr::Ascii("rpreneur"),
        dictgen::InsensitiveStr::Ascii("rpreneurs"),
        dictgen::InsensitiveStr::Ascii("rprenuer"),
        dictgen::InsensitiveStr::Ascii("rprenuers"),
        dictgen::InsensitiveStr::Ascii("rpreuners"),
        dictgen::InsensitiveStr::Ascii("rprice"),
        dictgen::InsensitiveStr::Ascii("rprices"),
        dictgen::InsensitiveStr::Ascii("rpries"),
        dictgen::InsensitiveStr::Ascii("rprishe"),
        dictgen::InsensitiveStr::Ascii("rprize"),
        dictgen::InsensitiveStr::Ascii("rprsie"),
        dictgen::InsensitiveStr::Ascii("rrpise"),
        dictgen::InsensitiveStr::Ascii("rtaing"),
        dictgen::InsensitiveStr::Ascii("rtainig"),
        dictgen::InsensitiveStr::Ascii("rtainted"),
        dictgen::InsensitiveStr::Ascii("rtianment"),
        dictgen::InsensitiveStr::Ascii("rtwined"),
        dictgen::InsensitiveStr::Ascii("ry"),
        dictgen::InsensitiveStr::Ascii("ties"),
        dictgen::InsensitiveStr::Ascii("ty"),
    ],
    values: &[
        &["intend"],
        &["intended"],
        &["intending"],
        &["intends"],
        &["extension"],
        &["extensions"],
        &["intent"],
        &["entries"],
        &["intents"],
        &["entrance"],
        &["entertainment"],
        &["entering"],
        &["entry"],
        &["entries"],
        &["entirely"],
        &["entirety"],
        &["enterprise"],
        &["enterprises"],
        &["entrepreneurs"],
        &["entrepreneurs"],
        &["entrepreneur"],
        &["entrepreneurs"],
        &["entrepreneurs"],
        &["enterprise"],
        &["enterprises"],
        &["enterprises"],
        &["enterprises"],
        &["enterprise"],
        &["enterprises"],
        &["enterprises"],
        &["entertaining"],
        &["entertaining"],
        &["entertained"],
        &["entertainment"],
        &["entertained"],
        &["entry"],
        &["entities"],
        &["entity"],
    ],
    range: 2..=9,
};

static WORD_ENTB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ENTB_CHILDREN),
    value: None,
};

pub static WORD_ENTB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ook")],
    values: &[&["netbook"]],
    range: 3..=3,
};

static WORD_ENTA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ENTA_CHILDREN),
    value: None,
};

pub static WORD_ENTA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("glements"),
        dictgen::InsensitiveStr::Ascii("rtaining"),
    ],
    values: &[&["entanglements"], &["entertaining"]],
    range: 8..=8,
};

static WORD_ENS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ENS_CHILDREN),
    value: None,
};

pub static WORD_ENS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("alve"),
        dictgen::InsensitiveStr::Ascii("alved"),
        dictgen::InsensitiveStr::Ascii("consed"),
    ],
    values: &[&["enslave"], &["enslaved"], &["ensconced"]],
    range: 4..=6,
};

static WORD_ENR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ENR_CHILDREN),
    value: None,
};

pub static WORD_ENR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ies"),
        dictgen::InsensitiveStr::Ascii("olement"),
        dictgen::InsensitiveStr::Ascii("ollemnt"),
        dictgen::InsensitiveStr::Ascii("ties"),
        dictgen::InsensitiveStr::Ascii("tries"),
        dictgen::InsensitiveStr::Ascii("try"),
        dictgen::InsensitiveStr::Ascii("ty"),
        dictgen::InsensitiveStr::Ascii("ypt"),
        dictgen::InsensitiveStr::Ascii("ypted"),
        dictgen::InsensitiveStr::Ascii("yption"),
    ],
    values: &[
        &["entries"],
        &["enrollment"],
        &["enrollment"],
        &["entries"],
        &["entries"],
        &["entry"],
        &["entry"],
        &["encrypt"],
        &["encrypted"],
        &["encryption"],
    ],
    range: 2..=7,
};

static WORD_ENQ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ENQ_CHILDREN),
    value: None,
};

pub static WORD_ENQ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ue"),
        dictgen::InsensitiveStr::Ascii("ueing"),
    ],
    values: &[&["enqueue"], &["enqueuing"]],
    range: 2..=5,
};

static WORD_ENP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ENP_CHILDREN),
    value: None,
};

pub static WORD_ENP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("oint"),
        dictgen::InsensitiveStr::Ascii("oints"),
    ],
    values: &[&["endpoint"], &["endpoints"]],
    range: 4..=5,
};

static WORD_ENO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ENO_CHILDREN),
    value: None,
};

pub static WORD_ENO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cde"),
        dictgen::InsensitiveStr::Ascii("cded"),
        dictgen::InsensitiveStr::Ascii("cder"),
        dictgen::InsensitiveStr::Ascii("cders"),
        dictgen::InsensitiveStr::Ascii("cdes"),
        dictgen::InsensitiveStr::Ascii("cding"),
        dictgen::InsensitiveStr::Ascii("cdings"),
        dictgen::InsensitiveStr::Ascii("gh"),
        dictgen::InsensitiveStr::Ascii("ght"),
        dictgen::InsensitiveStr::Ascii("guh"),
        dictgen::InsensitiveStr::Ascii("rmass"),
        dictgen::InsensitiveStr::Ascii("rmassly"),
        dictgen::InsensitiveStr::Ascii("uch"),
        dictgen::InsensitiveStr::Ascii("ucnter"),
        dictgen::InsensitiveStr::Ascii("ucntered"),
        dictgen::InsensitiveStr::Ascii("ucntering"),
        dictgen::InsensitiveStr::Ascii("ucnters"),
        dictgen::InsensitiveStr::Ascii("uf"),
        dictgen::InsensitiveStr::Ascii("ufh"),
        dictgen::InsensitiveStr::Ascii("ught"),
        dictgen::InsensitiveStr::Ascii("ughts"),
        dictgen::InsensitiveStr::Ascii("ugth"),
        dictgen::InsensitiveStr::Ascii("uh"),
        dictgen::InsensitiveStr::Ascii("uhg"),
        dictgen::InsensitiveStr::Ascii("uncter"),
        dictgen::InsensitiveStr::Ascii("unctered"),
        dictgen::InsensitiveStr::Ascii("unctering"),
        dictgen::InsensitiveStr::Ascii("uncters"),
        dictgen::InsensitiveStr::Ascii("ung"),
        dictgen::InsensitiveStr::Ascii("ungh"),
        dictgen::InsensitiveStr::Ascii("unter"),
        dictgen::InsensitiveStr::Ascii("untered"),
        dictgen::InsensitiveStr::Ascii("untering"),
        dictgen::InsensitiveStr::Ascii("unters"),
        dictgen::InsensitiveStr::Ascii("uph"),
        dictgen::InsensitiveStr::Ascii("urage"),
        dictgen::InsensitiveStr::Ascii("uraged"),
        dictgen::InsensitiveStr::Ascii("urages"),
        dictgen::InsensitiveStr::Ascii("uraging"),
        dictgen::InsensitiveStr::Ascii("urmous"),
        dictgen::InsensitiveStr::Ascii("urmously"),
        dictgen::InsensitiveStr::Ascii("uth"),
        dictgen::InsensitiveStr::Ascii("uugh"),
    ],
    values: &[
        &["encode"],
        &["encoded"],
        &["encoder"],
        &["encoders"],
        &["encodes"],
        &["encoding"],
        &["encodings"],
        &["enough"],
        &["enough"],
        &["enough"],
        &["enormous"],
        &["enormously"],
        &["enough"],
        &["encounter"],
        &["encountered"],
        &["encountering"],
        &["encounters"],
        &["enough"],
        &["enough"],
        &["enough"],
        &["enough"],
        &["enough"],
        &["enough"],
        &["enough"],
        &["encounter"],
        &["encountered"],
        &["encountering"],
        &["encounters"],
        &["enough"],
        &["enough"],
        &["encounter"],
        &["encountered"],
        &["encountering"],
        &["encounters"],
        &["enough"],
        &["encourage"],
        &["encouraged"],
        &["encourages"],
        &["encouraging"],
        &["enormous"],
        &["enormously"],
        &["enough"],
        &["enough"],
    ],
    range: 2..=9,
};

static WORD_ENN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ENN_CHILDREN),
    value: None,
};

pub static WORD_ENN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("point"),
        dictgen::InsensitiveStr::Ascii("tries"),
    ],
    values: &[&["endpoint"], &["entries"]],
    range: 5..=5,
};

static WORD_ENM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ENM_CHILDREN),
    value: None,
};

pub static WORD_ENM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("pty"),
        dictgen::InsensitiveStr::Ascii("um"),
        dictgen::InsensitiveStr::Ascii("vironment"),
        dictgen::InsensitiveStr::Ascii("vironmental"),
        dictgen::InsensitiveStr::Ascii("vironments"),
    ],
    values: &[
        &["empty"],
        &["enum"],
        &["environment"],
        &["environmental"],
        &["environments"],
    ],
    range: 2..=11,
};

static WORD_ENL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ENL_CHILDREN),
    value: None,
};

pub static WORD_ENL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("argment"),
        dictgen::InsensitiveStr::Ascii("argments"),
        dictgen::InsensitiveStr::Ascii("cave"),
        dictgen::InsensitiveStr::Ascii("cosed"),
        dictgen::InsensitiveStr::Ascii("gish"),
        dictgen::InsensitiveStr::Ascii("ighment"),
        dictgen::InsensitiveStr::Ascii("ightend"),
        dictgen::InsensitiveStr::Ascii("ightended"),
        dictgen::InsensitiveStr::Ascii("ightenend"),
        dictgen::InsensitiveStr::Ascii("ightented"),
        dictgen::InsensitiveStr::Ascii("ightenting"),
        dictgen::InsensitiveStr::Ascii("ightining"),
        dictgen::InsensitiveStr::Ascii("ightned"),
        dictgen::InsensitiveStr::Ascii("ightnement"),
        dictgen::InsensitiveStr::Ascii("ightnment"),
        dictgen::InsensitiveStr::Ascii("igthen"),
        dictgen::InsensitiveStr::Ascii("igthened"),
        dictgen::InsensitiveStr::Ascii("igthening"),
        dictgen::InsensitiveStr::Ascii("igthenment"),
        dictgen::InsensitiveStr::Ascii("ish"),
        dictgen::InsensitiveStr::Ascii("ose"),
        dictgen::InsensitiveStr::Ascii("save"),
        dictgen::InsensitiveStr::Ascii("saved"),
    ],
    values: &[
        &["enlargement"],
        &["enlargements"],
        &["enclave"],
        &["enclosed"],
        &["english"],
        &["enlighten"],
        &["enlightened"],
        &["enlightened"],
        &["enlightened"],
        &["enlightened"],
        &["enlightening"],
        &["enlightening"],
        &["enlightened"],
        &["enlightenment"],
        &["enlightenment"],
        &["enlighten"],
        &["enlightened"],
        &["enlightening"],
        &["enlightenment"],
        &["english", "enlist"],
        &["enclose"],
        &["enslave"],
        &["enslaved"],
    ],
    range: 3..=10,
};

static WORD_ENI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ENI_CHILDREN),
    value: None,
};

pub static WORD_ENI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("gneer"),
        dictgen::InsensitiveStr::Ascii("ronment"),
        dictgen::InsensitiveStr::Ascii("ronments"),
        dictgen::InsensitiveStr::Ascii("ties"),
        dictgen::InsensitiveStr::Ascii("tities"),
        dictgen::InsensitiveStr::Ascii("tity"),
        dictgen::InsensitiveStr::Ascii("tre"),
        dictgen::InsensitiveStr::Ascii("trely"),
        dictgen::InsensitiveStr::Ascii("ty"),
        dictgen::InsensitiveStr::Ascii("vitable"),
        dictgen::InsensitiveStr::Ascii("vornment"),
        dictgen::InsensitiveStr::Ascii("vornments"),
        dictgen::InsensitiveStr::Ascii("vronment"),
        dictgen::InsensitiveStr::Ascii("vronmentally"),
    ],
    values: &[
        &["engineer"],
        &["environment"],
        &["environments"],
        &["entities"],
        &["entities"],
        &["entity"],
        &["entire"],
        &["entirely"],
        &["entity", "enmity"],
        &["inevitable"],
        &["environment"],
        &["environments"],
        &["environment"],
        &["environmentally"],
    ],
    range: 2..=12,
};

static WORD_ENH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ENH_CHILDREN),
    value: None,
};

pub static WORD_ENH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("abce"),
        dictgen::InsensitiveStr::Ascii("abced"),
        dictgen::InsensitiveStr::Ascii("abces"),
        dictgen::InsensitiveStr::Ascii("abcing"),
        dictgen::InsensitiveStr::Ascii("ace"),
        dictgen::InsensitiveStr::Ascii("aced"),
        dictgen::InsensitiveStr::Ascii("acement"),
        dictgen::InsensitiveStr::Ascii("acements"),
        dictgen::InsensitiveStr::Ascii("aces"),
        dictgen::InsensitiveStr::Ascii("acing"),
        dictgen::InsensitiveStr::Ascii("acning"),
        dictgen::InsensitiveStr::Ascii("ancd"),
        dictgen::InsensitiveStr::Ascii("anceds"),
        dictgen::InsensitiveStr::Ascii("ancment"),
        dictgen::InsensitiveStr::Ascii("ancments"),
        dictgen::InsensitiveStr::Ascii("aned"),
        dictgen::InsensitiveStr::Ascii("anse"),
        dictgen::InsensitiveStr::Ascii("ence"),
        dictgen::InsensitiveStr::Ascii("enced"),
        dictgen::InsensitiveStr::Ascii("encement"),
        dictgen::InsensitiveStr::Ascii("encements"),
        dictgen::InsensitiveStr::Ascii("encment"),
        dictgen::InsensitiveStr::Ascii("encments"),
    ],
    values: &[
        &["enhance"],
        &["enhanced"],
        &["enhances"],
        &["enhancing"],
        &["enhance"],
        &["enhanced"],
        &["enhancement"],
        &["enhancements"],
        &["enhances"],
        &["enhancing"],
        &["enhancing"],
        &["enhanced"],
        &["enhances"],
        &["enhancement"],
        &["enhancements"],
        &["enhanced"],
        &["enhances"],
        &["enhance"],
        &["enhanced"],
        &["enhancement"],
        &["enhancements"],
        &["enhancement"],
        &["enhancements"],
    ],
    range: 3..=9,
};

static WORD_ENG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ENG_CHILDREN),
    value: None,
};

pub static WORD_ENG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("agaments"),
        dictgen::InsensitiveStr::Ascii("agemet"),
        dictgen::InsensitiveStr::Ascii("agemnet"),
        dictgen::InsensitiveStr::Ascii("agemnts"),
        dictgen::InsensitiveStr::Ascii("agment"),
        dictgen::InsensitiveStr::Ascii("eneer"),
        dictgen::InsensitiveStr::Ascii("eneering"),
        dictgen::InsensitiveStr::Ascii("eneers"),
        dictgen::InsensitiveStr::Ascii("eries"),
        dictgen::InsensitiveStr::Ascii("ery"),
        dictgen::InsensitiveStr::Ascii("ieer"),
        dictgen::InsensitiveStr::Ascii("ieering"),
        dictgen::InsensitiveStr::Ascii("ieers"),
        dictgen::InsensitiveStr::Ascii("ieneer"),
        dictgen::InsensitiveStr::Ascii("ieneers"),
        dictgen::InsensitiveStr::Ascii("inee"),
        dictgen::InsensitiveStr::Ascii("ineed"),
        dictgen::InsensitiveStr::Ascii("ineeer"),
        dictgen::InsensitiveStr::Ascii("ineerd"),
        dictgen::InsensitiveStr::Ascii("inees"),
        dictgen::InsensitiveStr::Ascii("iner"),
        dictgen::InsensitiveStr::Ascii("inereed"),
        dictgen::InsensitiveStr::Ascii("inerring"),
        dictgen::InsensitiveStr::Ascii("inge"),
        dictgen::InsensitiveStr::Ascii("ingeering"),
        dictgen::InsensitiveStr::Ascii("inges"),
        dictgen::InsensitiveStr::Ascii("inin"),
        dictgen::InsensitiveStr::Ascii("inineer"),
        dictgen::InsensitiveStr::Ascii("inineering"),
        dictgen::InsensitiveStr::Ascii("inineers"),
        dictgen::InsensitiveStr::Ascii("innering"),
        dictgen::InsensitiveStr::Ascii("lsih"),
        dictgen::InsensitiveStr::Ascii("oug"),
        dictgen::InsensitiveStr::Ascii("ouh"),
        dictgen::InsensitiveStr::Ascii("rames"),
        dictgen::InsensitiveStr::Ascii("ramms"),
    ],
    values: &[
        &["engagements"],
        &["engagements"],
        &["engagements"],
        &["engagements"],
        &["engagement"],
        &["engineer"],
        &["engineering"],
        &["engineers"],
        &["energies"],
        &["energy"],
        &["engineer"],
        &["engineering"],
        &["engineers"],
        &["engineer"],
        &["engineers"],
        &["engine", "engineer"],
        &["engineered"],
        &["engineer"],
        &["engineered"],
        &["engineers", "engines"],
        &["engineer"],
        &["engineered"],
        &["engineering"],
        &["engine"],
        &["engineering"],
        &["engines"],
        &["engine"],
        &["engineer"],
        &["engineering"],
        &["engineers"],
        &["engineering"],
        &["english"],
        &["enough"],
        &["enough"],
        &["engrams"],
        &["engrams"],
    ],
    range: 3..=10,
};

static WORD_ENF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ENF_CHILDREN),
    value: None,
};

pub static WORD_ENF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("lamed"),
        dictgen::InsensitiveStr::Ascii("orcable"),
        dictgen::InsensitiveStr::Ascii("orcees"),
        dictgen::InsensitiveStr::Ascii("orceing"),
        dictgen::InsensitiveStr::Ascii("orcmement"),
        dictgen::InsensitiveStr::Ascii("orcment"),
        dictgen::InsensitiveStr::Ascii("ore"),
        dictgen::InsensitiveStr::Ascii("ored"),
        dictgen::InsensitiveStr::Ascii("ores"),
        dictgen::InsensitiveStr::Ascii("oring"),
        dictgen::InsensitiveStr::Ascii("orncing"),
        dictgen::InsensitiveStr::Ascii("orse"),
        dictgen::InsensitiveStr::Ascii("ringement"),
    ],
    values: &[
        &["inflamed"],
        &["enforceable"],
        &["enforces"],
        &["enforcing"],
        &["enforcement"],
        &["enforcement"],
        &["enforce"],
        &["enforced"],
        &["enforces"],
        &["enforcing"],
        &["enforcing"],
        &["enforces"],
        &["infringement"],
    ],
    range: 3..=9,
};

static WORD_ENE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ENE_CHILDREN),
    value: None,
};

pub static WORD_ENE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("able"),
        dictgen::InsensitiveStr::Ascii("abled"),
        dictgen::InsensitiveStr::Ascii("ables"),
        dictgen::InsensitiveStr::Ascii("abling"),
        dictgen::InsensitiveStr::Ascii("bale"),
        dictgen::InsensitiveStr::Ascii("baled"),
        dictgen::InsensitiveStr::Ascii("bales"),
        dictgen::InsensitiveStr::Ascii("baling"),
        dictgen::InsensitiveStr::Ascii("ble"),
        dictgen::InsensitiveStr::Ascii("d"),
        dictgen::InsensitiveStr::Ascii("geries"),
        dictgen::InsensitiveStr::Ascii("gery"),
        dictgen::InsensitiveStr::Ascii("hanced"),
        dictgen::InsensitiveStr::Ascii("mployment"),
        dictgen::InsensitiveStr::Ascii("rator"),
        dictgen::InsensitiveStr::Ascii("rgis"),
        dictgen::InsensitiveStr::Ascii("ry"),
        dictgen::InsensitiveStr::Ascii("ter"),
        dictgen::InsensitiveStr::Ascii("tered"),
        dictgen::InsensitiveStr::Ascii("tering"),
        dictgen::InsensitiveStr::Ascii("ters"),
        dictgen::InsensitiveStr::Ascii("tities"),
        dictgen::InsensitiveStr::Ascii("tity"),
        dictgen::InsensitiveStr::Ascii("umeration"),
        dictgen::InsensitiveStr::Ascii("umerations"),
        dictgen::InsensitiveStr::Ascii("umretaion"),
        dictgen::InsensitiveStr::Ascii("umretaions"),
        dictgen::InsensitiveStr::Ascii("vlopes"),
        dictgen::InsensitiveStr::Ascii("w"),
    ],
    values: &[
        &["enable"],
        &["enabled"],
        &["enables"],
        &["enabling"],
        &["enable"],
        &["enabled"],
        &["enables"],
        &["enabling"],
        &["enable"],
        &["need"],
        &["energies"],
        &["energy"],
        &["enhanced"],
        &["unemployment"],
        &["generator"],
        &["energies"],
        &["energy"],
        &["enter"],
        &["entered"],
        &["entering"],
        &["enters"],
        &["entities"],
        &["entity"],
        &["enumeration"],
        &["enumerations"],
        &["enumeration"],
        &["enumerations"],
        &["envelopes"],
        &["new"],
    ],
    range: 1..=10,
};

static WORD_END_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_END_CHILDREN),
    value: None,
};

pub static WORD_END_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("agnering"),
        dictgen::InsensitiveStr::Ascii("andering"),
        dictgen::InsensitiveStr::Ascii("anged"),
        dictgen::InsensitiveStr::Ascii("angerd"),
        dictgen::InsensitiveStr::Ascii("coded"),
        dictgen::InsensitiveStr::Ascii("coder"),
        dictgen::InsensitiveStr::Ascii("coders"),
        dictgen::InsensitiveStr::Ascii("codes"),
        dictgen::InsensitiveStr::Ascii("coding"),
        dictgen::InsensitiveStr::Ascii("codings"),
        dictgen::InsensitiveStr::Ascii("ding"),
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("ever"),
        dictgen::InsensitiveStr::Ascii("evered"),
        dictgen::InsensitiveStr::Ascii("everes"),
        dictgen::InsensitiveStr::Ascii("evering"),
        dictgen::InsensitiveStr::Ascii("evers"),
        dictgen::InsensitiveStr::Ascii("evors"),
        dictgen::InsensitiveStr::Ascii("evour"),
        dictgen::InsensitiveStr::Ascii("fi"),
        dictgen::InsensitiveStr::Ascii("ge"),
        dictgen::InsensitiveStr::Ascii("ianes"),
        dictgen::InsensitiveStr::Ascii("ianess"),
        dictgen::InsensitiveStr::Ascii("ianity"),
        dictgen::InsensitiveStr::Ascii("iannes"),
        dictgen::InsensitiveStr::Ascii("ien"),
        dictgen::InsensitiveStr::Ascii("iens"),
        dictgen::InsensitiveStr::Ascii("ig"),
        dictgen::InsensitiveStr::Ascii("iif"),
        dictgen::InsensitiveStr::Ascii("iness"),
        dictgen::InsensitiveStr::Ascii("lessley"),
        dictgen::InsensitiveStr::Ascii("lessy"),
        dictgen::InsensitiveStr::Ascii("noden"),
        dictgen::InsensitiveStr::Ascii("octrinated"),
        dictgen::InsensitiveStr::Ascii("octrination"),
        dictgen::InsensitiveStr::Ascii("oint"),
        dictgen::InsensitiveStr::Ascii("oints"),
        dictgen::InsensitiveStr::Ascii("olithes"),
        dictgen::InsensitiveStr::Ascii("orcement"),
        dictgen::InsensitiveStr::Ascii("orces"),
        dictgen::InsensitiveStr::Ascii("ores"),
        dictgen::InsensitiveStr::Ascii("oresment"),
        dictgen::InsensitiveStr::Ascii("oresments"),
        dictgen::InsensitiveStr::Ascii("pdoint"),
        dictgen::InsensitiveStr::Ascii("pdoints"),
        dictgen::InsensitiveStr::Ascii("pint"),
        dictgen::InsensitiveStr::Ascii("pints"),
        dictgen::InsensitiveStr::Ascii("piont"),
        dictgen::InsensitiveStr::Ascii("pionts"),
        dictgen::InsensitiveStr::Ascii("pont"),
        dictgen::InsensitiveStr::Ascii("ponts"),
        dictgen::InsensitiveStr::Ascii("rose"),
        dictgen::InsensitiveStr::Ascii("uce"),
        dictgen::InsensitiveStr::Ascii("uced"),
        dictgen::InsensitiveStr::Ascii("uces"),
        dictgen::InsensitiveStr::Ascii("ucing"),
        dictgen::InsensitiveStr::Ascii("ur"),
    ],
    values: &[
        &["endangering"],
        &["endangering"],
        &["endangered"],
        &["endangered"],
        &["encoded"],
        &["encoder"],
        &["encoders"],
        &["encodes"],
        &["encoding"],
        &["encodings"],
        &["ending"],
        &["end"],
        &["endeavor"],
        &["endeavored"],
        &["endeavors"],
        &["endeavoring"],
        &["endeavors"],
        &["endeavors"],
        &["endeavour"],
        &["endif"],
        &["edge", "end"],
        &["endianness"],
        &["endianness"],
        &["endianness"],
        &["endianness"],
        &["endian", "indian"],
        &["endians", "indians"],
        &["ending"],
        &["endif"],
        &["endianness"],
        &["endlessly"],
        &["endlessly"],
        &["endnode"],
        &["indoctrinated"],
        &["indoctrination"],
        &["endpoint"],
        &["endpoints"],
        &["endoliths"],
        &["endorsement"],
        &["endorse"],
        &["endorse"],
        &["endorsement"],
        &["endorsement"],
        &["endpoint"],
        &["endpoints"],
        &["endpoint"],
        &["endpoints"],
        &["endpoint"],
        &["endpoints"],
        &["endpoint"],
        &["endpoints"],
        &["endorse"],
        &["induce"],
        &["induced"],
        &["induces"],
        &["inducing"],
        &["endure"],
    ],
    range: 1..=11,
};

static WORD_ENC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_ENC_CHILDREN),
    value: None,
};

static WORD_ENC_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_ENCA_NODE),
    None,
    None,
    None,
    Some(&WORD_ENCE_NODE),
    None,
    None,
    Some(&WORD_ENCH_NODE),
    Some(&WORD_ENCI_NODE),
    None,
    None,
    Some(&WORD_ENCL_NODE),
    None,
    None,
    Some(&WORD_ENCO_NODE),
    None,
    None,
    Some(&WORD_ENCR_NODE),
    None,
    None,
    Some(&WORD_ENCU_NODE),
    None,
    None,
    None,
    Some(&WORD_ENCY_NODE),
    None,
];

static WORD_ENCY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ENCY_CHILDREN),
    value: None,
};

pub static WORD_ENCY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("clapedia"),
        dictgen::InsensitiveStr::Ascii("clepedia"),
        dictgen::InsensitiveStr::Ascii("clopadia"),
        dictgen::InsensitiveStr::Ascii("clopdia"),
        dictgen::InsensitiveStr::Ascii("clopeadia"),
        dictgen::InsensitiveStr::Ascii("clopeadic"),
        dictgen::InsensitiveStr::Ascii("clopeedia"),
        dictgen::InsensitiveStr::Ascii("clopeida"),
        dictgen::InsensitiveStr::Ascii("clopidia"),
        dictgen::InsensitiveStr::Ascii("colpedia"),
        dictgen::InsensitiveStr::Ascii("colpedias"),
        dictgen::InsensitiveStr::Ascii("klopedia"),
        dictgen::InsensitiveStr::Ascii("lcopedia"),
        dictgen::InsensitiveStr::Ascii("lopedia"),
        dictgen::InsensitiveStr::Ascii("plopedia"),
        dictgen::InsensitiveStr::Ascii("pted"),
        dictgen::InsensitiveStr::Ascii("ption"),
        dictgen::InsensitiveStr::Ascii("rpt"),
        dictgen::InsensitiveStr::Ascii("rpted"),
        dictgen::InsensitiveStr::Ascii("rption"),
    ],
    values: &[
        &["encyclopedia"],
        &["encyclopedia"],
        &["encyclopedia"],
        &["encyclopedia"],
        &["encyclopedia"],
        &["encyclopedia"],
        &["encyclopedia"],
        &["encyclopedia"],
        &["encyclopedia"],
        &["encyclopedia"],
        &["encyclopedia"],
        &["encyclopedia"],
        &["encyclopedia"],
        &["encyclopedia"],
        &["encyclopedia"],
        &["encrypted"],
        &["encryption"],
        &["encrypt"],
        &["encrypted"],
        &["encryption"],
    ],
    range: 3..=9,
};

static WORD_ENCU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ENCU_CHILDREN),
    value: None,
};

pub static WORD_ENCU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("psulates")],
    values: &[&["encapsulates"]],
    range: 8..=8,
};

static WORD_ENCR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ENCR_CHILDREN),
    value: None,
};

pub static WORD_ENCR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cypt"),
        dictgen::InsensitiveStr::Ascii("cypted"),
        dictgen::InsensitiveStr::Ascii("cyption"),
        dictgen::InsensitiveStr::Ascii("cyptions"),
        dictgen::InsensitiveStr::Ascii("cypts"),
        dictgen::InsensitiveStr::Ascii("ipt"),
        dictgen::InsensitiveStr::Ascii("ipted"),
        dictgen::InsensitiveStr::Ascii("iption"),
        dictgen::InsensitiveStr::Ascii("iptions"),
        dictgen::InsensitiveStr::Ascii("ipts"),
        dictgen::InsensitiveStr::Ascii("pt"),
        dictgen::InsensitiveStr::Ascii("pted"),
        dictgen::InsensitiveStr::Ascii("ption"),
        dictgen::InsensitiveStr::Ascii("ptions"),
        dictgen::InsensitiveStr::Ascii("pts"),
        dictgen::InsensitiveStr::Ascii("pyt"),
        dictgen::InsensitiveStr::Ascii("pyted"),
        dictgen::InsensitiveStr::Ascii("pytion"),
        dictgen::InsensitiveStr::Ascii("upted"),
        dictgen::InsensitiveStr::Ascii("yp"),
        dictgen::InsensitiveStr::Ascii("yped"),
        dictgen::InsensitiveStr::Ascii("ypiton"),
        dictgen::InsensitiveStr::Ascii("yptation"),
        dictgen::InsensitiveStr::Ascii("ypte"),
        dictgen::InsensitiveStr::Ascii("ypter"),
        dictgen::InsensitiveStr::Ascii("yptiion"),
        dictgen::InsensitiveStr::Ascii("yptio"),
        dictgen::InsensitiveStr::Ascii("yptiong"),
        dictgen::InsensitiveStr::Ascii("ytion"),
        dictgen::InsensitiveStr::Ascii("ytped"),
        dictgen::InsensitiveStr::Ascii("ytption"),
    ],
    values: &[
        &["encrypt"],
        &["encrypted"],
        &["encryption"],
        &["encryptions"],
        &["encrypts"],
        &["encrypt"],
        &["encrypted"],
        &["encryption"],
        &["encryptions"],
        &["encrypts"],
        &["encrypt"],
        &["encrypted"],
        &["encryption"],
        &["encryptions"],
        &["encrypts"],
        &["encrypt"],
        &["encrypted"],
        &["encryption"],
        &["encrypted"],
        &["encrypt"],
        &["encrypted"],
        &["encryption"],
        &["encryption"],
        &["encrypted", "encrypt"],
        &["encryptor"],
        &["encryption"],
        &["encryption"],
        &["encryption"],
        &["encryption"],
        &["encrypted"],
        &["encryption"],
    ],
    range: 2..=8,
};

static WORD_ENCO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_ENCO_CHILDREN),
    value: None,
};

static WORD_ENCO_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    Some(&WORD_ENCOC_NODE),
    Some(&WORD_ENCOD_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_ENCOL_NODE),
    Some(&WORD_ENCOM_NODE),
    Some(&WORD_ENCON_NODE),
    None,
    None,
    None,
    Some(&WORD_ENCOR_NODE),
    Some(&WORD_ENCOS_NODE),
    None,
    Some(&WORD_ENCOU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_ENCOU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ENCOU_CHILDREN),
    value: None,
};

pub static WORD_ENCOU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("nted"),
        dictgen::InsensitiveStr::Ascii("nterd"),
        dictgen::InsensitiveStr::Ascii("nteres"),
        dictgen::InsensitiveStr::Ascii("ntre"),
        dictgen::InsensitiveStr::Ascii("ntred"),
        dictgen::InsensitiveStr::Ascii("ntres"),
        dictgen::InsensitiveStr::Ascii("rageing"),
        dictgen::InsensitiveStr::Ascii("raing"),
        dictgen::InsensitiveStr::Ascii("rge"),
        dictgen::InsensitiveStr::Ascii("rged"),
        dictgen::InsensitiveStr::Ascii("rges"),
        dictgen::InsensitiveStr::Ascii("rging"),
        dictgen::InsensitiveStr::Ascii("ter"),
        dictgen::InsensitiveStr::Ascii("tered"),
        dictgen::InsensitiveStr::Ascii("tering"),
        dictgen::InsensitiveStr::Ascii("ters"),
        dictgen::InsensitiveStr::Ascii("tner"),
        dictgen::InsensitiveStr::Ascii("tnered"),
        dictgen::InsensitiveStr::Ascii("tners"),
        dictgen::InsensitiveStr::Ascii("ttering"),
    ],
    values: &[
        &["encountered", "encounter"],
        &["encountered"],
        &["encounters"],
        &["encounter", "encountered"],
        &["encountered"],
        &["encounters"],
        &["encouraging"],
        &["encouraging"],
        &["encourage"],
        &["encouraged"],
        &["encourages"],
        &["encouraging"],
        &["encounter"],
        &["encountered"],
        &["encountering"],
        &["encounters"],
        &["encounter"],
        &["encountered"],
        &["encounters"],
        &["encountering"],
    ],
    range: 3..=7,
};

static WORD_ENCOS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ENCOS_CHILDREN),
    value: None,
};

pub static WORD_ENCOS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("er"),
        dictgen::InsensitiveStr::Ascii("ers"),
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("ings"),
        dictgen::InsensitiveStr::Ascii("ure"),
    ],
    values: &[
        &["enclose", "encode"],
        &["enclosed", "encoded"],
        &["encoder"],
        &["encoders"],
        &["encloses", "encodes"],
        &["enclosing", "encoding"],
        &["enclosings", "encodings"],
        &["enclosure"],
    ],
    range: 1..=4,
};

static WORD_ENCOR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ENCOR_CHILDREN),
    value: None,
};

pub static WORD_ENCOR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("de"),
        dictgen::InsensitiveStr::Ascii("ded"),
        dictgen::InsensitiveStr::Ascii("der"),
        dictgen::InsensitiveStr::Ascii("ders"),
        dictgen::InsensitiveStr::Ascii("des"),
        dictgen::InsensitiveStr::Ascii("ding"),
        dictgen::InsensitiveStr::Ascii("dings"),
        dictgen::InsensitiveStr::Ascii("porated"),
        dictgen::InsensitiveStr::Ascii("porating"),
    ],
    values: &[
        &["encode", "encore"],
        &["encoded"],
        &["encoder"],
        &["encoders"],
        &["encodes", "encores"],
        &["encoding"],
        &["encodings"],
        &["incorporated"],
        &["incorporating"],
    ],
    range: 2..=8,
};

static WORD_ENCON_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ENCON_CHILDREN),
    value: None,
};

pub static WORD_ENCON_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("de"),
        dictgen::InsensitiveStr::Ascii("ded"),
        dictgen::InsensitiveStr::Ascii("der"),
        dictgen::InsensitiveStr::Ascii("ders"),
        dictgen::InsensitiveStr::Ascii("des"),
        dictgen::InsensitiveStr::Ascii("ding"),
        dictgen::InsensitiveStr::Ascii("dings"),
    ],
    values: &[
        &["encode"],
        &["encoded"],
        &["encoder"],
        &["encoders"],
        &["encodes"],
        &["encoding"],
        &["encodings"],
    ],
    range: 2..=5,
};

static WORD_ENCOM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ENCOM_CHILDREN),
    value: None,
};

pub static WORD_ENCOM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("apsses"),
        dictgen::InsensitiveStr::Ascii("pas"),
        dictgen::InsensitiveStr::Ascii("pase"),
        dictgen::InsensitiveStr::Ascii("pased"),
        dictgen::InsensitiveStr::Ascii("pases"),
        dictgen::InsensitiveStr::Ascii("pasess"),
        dictgen::InsensitiveStr::Ascii("pasing"),
        dictgen::InsensitiveStr::Ascii("pesses"),
        dictgen::InsensitiveStr::Ascii("pus"),
        dictgen::InsensitiveStr::Ascii("pused"),
        dictgen::InsensitiveStr::Ascii("puses"),
        dictgen::InsensitiveStr::Ascii("pusing"),
    ],
    values: &[
        &["encompasses"],
        &["encompass"],
        &["encompass"],
        &["encompassed"],
        &["encompasses"],
        &["encompasses"],
        &["encompassing"],
        &["encompasses"],
        &["encompass"],
        &["encompassed"],
        &["encompasses"],
        &["encompassing"],
    ],
    range: 3..=6,
};

static WORD_ENCOL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ENCOL_CHILDREN),
    value: None,
};

pub static WORD_ENCOL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("sed"),
        dictgen::InsensitiveStr::Ascii("sure"),
    ],
    values: &[&["enclosed"], &["enclosure"]],
    range: 3..=4,
};

static WORD_ENCOD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ENCOD_CHILDREN),
    value: None,
};

pub static WORD_ENCOD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ingt"),
        dictgen::InsensitiveStr::Ascii("ning"),
        dictgen::InsensitiveStr::Ascii("nings"),
    ],
    values: &[&["encoding"], &["encoding"], &["encodings"]],
    range: 4..=5,
};

static WORD_ENCOC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ENCOC_CHILDREN),
    value: None,
};

pub static WORD_ENCOC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("de"),
        dictgen::InsensitiveStr::Ascii("ded"),
        dictgen::InsensitiveStr::Ascii("der"),
        dictgen::InsensitiveStr::Ascii("ders"),
        dictgen::InsensitiveStr::Ascii("des"),
        dictgen::InsensitiveStr::Ascii("ding"),
        dictgen::InsensitiveStr::Ascii("dings"),
    ],
    values: &[
        &["encode"],
        &["encoded"],
        &["encoder"],
        &["encoders"],
        &["encodes"],
        &["encoding"],
        &["encodings"],
    ],
    range: 2..=5,
};

static WORD_ENCL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ENCL_CHILDREN),
    value: None,
};

pub static WORD_ENCL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("osng"),
        dictgen::InsensitiveStr::Ascii("osue"),
        dictgen::InsensitiveStr::Ascii("osung"),
        dictgen::InsensitiveStr::Ascii("ousre"),
        dictgen::InsensitiveStr::Ascii("soure"),
        dictgen::InsensitiveStr::Ascii("ude"),
        dictgen::InsensitiveStr::Ascii("uding"),
        dictgen::InsensitiveStr::Ascii("ycopedia"),
    ],
    values: &[
        &["enclosing"],
        &["enclosure"],
        &["enclosing"],
        &["enclosure"],
        &["enclosure"],
        &["include"],
        &["including"],
        &["encyclopedia"],
    ],
    range: 3..=8,
};

static WORD_ENCI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ENCI_CHILDREN),
    value: None,
};

pub static WORD_ENCI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("clopedia")],
    values: &[&["encyclopedia"]],
    range: 8..=8,
};

static WORD_ENCH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ENCH_CHILDREN),
    value: None,
};

pub static WORD_ENCH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("amtment"),
        dictgen::InsensitiveStr::Ascii("anced"),
        dictgen::InsensitiveStr::Ascii("ancement"),
        dictgen::InsensitiveStr::Ascii("ancements"),
        dictgen::InsensitiveStr::Ascii("ancing"),
        dictgen::InsensitiveStr::Ascii("ancment"),
        dictgen::InsensitiveStr::Ascii("ancments"),
        dictgen::InsensitiveStr::Ascii("anct"),
        dictgen::InsensitiveStr::Ascii("anement"),
        dictgen::InsensitiveStr::Ascii("anging"),
        dictgen::InsensitiveStr::Ascii("antent"),
        dictgen::InsensitiveStr::Ascii("anthing"),
        dictgen::InsensitiveStr::Ascii("antig"),
        dictgen::InsensitiveStr::Ascii("antmant"),
        dictgen::InsensitiveStr::Ascii("antmants"),
        dictgen::InsensitiveStr::Ascii("antmens"),
        dictgen::InsensitiveStr::Ascii("antmet"),
        dictgen::InsensitiveStr::Ascii("antmets"),
        dictgen::InsensitiveStr::Ascii("entments"),
    ],
    values: &[
        &["enchantment"],
        &["enhanced"],
        &["enhancement", "enchantment"],
        &["enhancements", "enchantments"],
        &["enchanting"],
        &["enchantment"],
        &["enchantments"],
        &["enchant"],
        &["enchantment"],
        &["enchanting"],
        &["enchantment"],
        &["enchanting"],
        &["enchanting"],
        &["enchantment"],
        &["enchantments"],
        &["enchantments"],
        &["enchantments"],
        &["enchantments"],
        &["enchantments"],
    ],
    range: 4..=9,
};

static WORD_ENCE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ENCE_CHILDREN),
    value: None,
};

pub static WORD_ENCE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("clopedia")],
    values: &[&["encyclopedia"]],
    range: 8..=8,
};

static WORD_ENCA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ENCA_CHILDREN),
    value: None,
};

pub static WORD_ENCA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("hnt"),
        dictgen::InsensitiveStr::Ascii("hnting"),
        dictgen::InsensitiveStr::Ascii("lve"),
        dictgen::InsensitiveStr::Ascii("psualtes"),
        dictgen::InsensitiveStr::Ascii("psulatzion"),
        dictgen::InsensitiveStr::Ascii("psulte"),
        dictgen::InsensitiveStr::Ascii("psultion"),
        dictgen::InsensitiveStr::Ascii("rcerated"),
        dictgen::InsensitiveStr::Ascii("rceration"),
        dictgen::InsensitiveStr::Ascii("spulate"),
        dictgen::InsensitiveStr::Ascii("spulated"),
        dictgen::InsensitiveStr::Ascii("spulates"),
        dictgen::InsensitiveStr::Ascii("spulating"),
        dictgen::InsensitiveStr::Ascii("spulation"),
    ],
    values: &[
        &["enchant"],
        &["enchanting"],
        &["enclave"],
        &["encapsulates"],
        &["encapsulation"],
        &["encapsulate"],
        &["encapsulation"],
        &["incarcerated"],
        &["incarceration"],
        &["encapsulate"],
        &["encapsulated"],
        &["encapsulates"],
        &["encapsulating"],
        &["encapsulation"],
    ],
    range: 3..=10,
};

static WORD_ENB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ENB_CHILDREN),
    value: None,
};

pub static WORD_ENB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("able"),
        dictgen::InsensitiveStr::Ascii("abled"),
        dictgen::InsensitiveStr::Ascii("abling"),
        dictgen::InsensitiveStr::Ascii("ale"),
        dictgen::InsensitiveStr::Ascii("aled"),
        dictgen::InsensitiveStr::Ascii("ales"),
        dictgen::InsensitiveStr::Ascii("aling"),
        dictgen::InsensitiveStr::Ascii("edding"),
        dictgen::InsensitiveStr::Ascii("le"),
        dictgen::InsensitiveStr::Ascii("race"),
        dictgen::InsensitiveStr::Ascii("raced"),
        dictgen::InsensitiveStr::Ascii("racer"),
        dictgen::InsensitiveStr::Ascii("races"),
        dictgen::InsensitiveStr::Ascii("racing"),
    ],
    values: &[
        &["enable"],
        &["enabled"],
        &["enabling"],
        &["enable"],
        &["enabled"],
        &["enables"],
        &["enabling"],
        &["embedding"],
        &["enable"],
        &["embrace"],
        &["embraced"],
        &["embracer"],
        &["embraces"],
        &["embracing"],
    ],
    range: 2..=6,
};

static WORD_ENA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ENA_CHILDREN),
    value: None,
};

pub static WORD_ENA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("able"),
        dictgen::InsensitiveStr::Ascii("be"),
        dictgen::InsensitiveStr::Ascii("bel"),
        dictgen::InsensitiveStr::Ascii("beled"),
        dictgen::InsensitiveStr::Ascii("beling"),
        dictgen::InsensitiveStr::Ascii("bels"),
        dictgen::InsensitiveStr::Ascii("bing"),
        dictgen::InsensitiveStr::Ascii("bledi"),
        dictgen::InsensitiveStr::Ascii("bleing"),
        dictgen::InsensitiveStr::Ascii("blen"),
        dictgen::InsensitiveStr::Ascii("hnces"),
        dictgen::InsensitiveStr::Ascii("hncing"),
        dictgen::InsensitiveStr::Ascii("lbe"),
        dictgen::InsensitiveStr::Ascii("lbed"),
        dictgen::InsensitiveStr::Ascii("lbes"),
        dictgen::InsensitiveStr::Ascii("meld"),
        dictgen::InsensitiveStr::Ascii("ugh"),
    ],
    values: &[
        &["enable"],
        &["enable"],
        &["enable"],
        &["enabled"],
        &["enabling"],
        &["enables"],
        &["enabling"],
        &["enabled"],
        &["enabling"],
        &["enabled"],
        &["enhances"],
        &["enhancing"],
        &["enable"],
        &["enabled"],
        &["enables"],
        &["enameled"],
        &["enough"],
    ],
    range: 2..=6,
};

static WORD_EM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_EM_CHILDREN),
    value: None,
};

static WORD_EM_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_EMA_NODE),
    Some(&WORD_EMB_NODE),
    Some(&WORD_EMC_NODE),
    None,
    Some(&WORD_EME_NODE),
    None,
    None,
    None,
    Some(&WORD_EMI_NODE),
    None,
    None,
    Some(&WORD_EML_NODE),
    Some(&WORD_EMM_NODE),
    Some(&WORD_EMN_NODE),
    Some(&WORD_EMO_NODE),
    Some(&WORD_EMP_NODE),
    None,
    None,
    None,
    Some(&WORD_EMT_NODE),
    Some(&WORD_EMU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_EMU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EMU_CHILDREN),
    value: None,
};

pub static WORD_EMU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("altion"),
        dictgen::InsensitiveStr::Ascii("latin"),
        dictgen::InsensitiveStr::Ascii("ltor"),
        dictgen::InsensitiveStr::Ascii("ltors"),
    ],
    values: &[
        &["emulation"],
        &["emulation"],
        &["emulator"],
        &["emulators"],
    ],
    range: 4..=6,
};

static WORD_EMT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EMT_CHILDREN),
    value: None,
};

pub static WORD_EMT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ied"),
        dictgen::InsensitiveStr::Ascii("ies"),
        dictgen::InsensitiveStr::Ascii("pied"),
        dictgen::InsensitiveStr::Ascii("pies"),
        dictgen::InsensitiveStr::Ascii("piness"),
        dictgen::InsensitiveStr::Ascii("py"),
        dictgen::InsensitiveStr::Ascii("y"),
        dictgen::InsensitiveStr::Ascii("ying"),
    ],
    values: &[
        &["emptied"],
        &["empties"],
        &["emptied"],
        &["empties"],
        &["emptiness"],
        &["empty"],
        &["empty"],
        &["emptying"],
    ],
    range: 1..=6,
};

static WORD_EMP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_EMP_CHILDREN),
    value: None,
};

static WORD_EMP_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_EMPA_NODE),
    None,
    None,
    None,
    Some(&WORD_EMPE_NODE),
    None,
    None,
    Some(&WORD_EMPH_NODE),
    Some(&WORD_EMPI_NODE),
    None,
    None,
    Some(&WORD_EMPL_NODE),
    None,
    None,
    Some(&WORD_EMPO_NODE),
    None,
    None,
    Some(&WORD_EMPR_NODE),
    None,
    Some(&WORD_EMPT_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_EMPY_NODE),
    None,
];

static WORD_EMPY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EMPY_CHILDREN),
    value: Some(&["empty"]),
};

pub static WORD_EMPY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[],
    values: &[],
    range: 0..=0,
};

static WORD_EMPT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EMPT_CHILDREN),
    value: None,
};

pub static WORD_EMPT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("niess"),
        dictgen::InsensitiveStr::Ascii("ry"),
        dictgen::InsensitiveStr::Ascii("yed"),
        dictgen::InsensitiveStr::Ascii("yy"),
    ],
    values: &[
        &["emptied"],
        &["emptiness"],
        &["empty"],
        &["emptied"],
        &["empty"],
    ],
    range: 2..=5,
};

static WORD_EMPR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EMPR_CHILDREN),
    value: None,
};

pub static WORD_EMPR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("essed"),
        dictgen::InsensitiveStr::Ascii("essing"),
        dictgen::InsensitiveStr::Ascii("essive"),
        dictgen::InsensitiveStr::Ascii("essively"),
        dictgen::InsensitiveStr::Ascii("ically"),
        dictgen::InsensitiveStr::Ascii("ies"),
        dictgen::InsensitiveStr::Ascii("isoned"),
        dictgen::InsensitiveStr::Ascii("isonment"),
        dictgen::InsensitiveStr::Ascii("ove"),
        dictgen::InsensitiveStr::Ascii("oved"),
        dictgen::InsensitiveStr::Ascii("ovement"),
        dictgen::InsensitiveStr::Ascii("ovements"),
        dictgen::InsensitiveStr::Ascii("oves"),
        dictgen::InsensitiveStr::Ascii("oving"),
    ],
    values: &[
        &["impressed"],
        &["impressing"],
        &["impressive"],
        &["impressively"],
        &["empirically"],
        &["empires"],
        &["imprisoned"],
        &["imprisonment"],
        &["improve"],
        &["improved"],
        &["improvement"],
        &["improvements"],
        &["improves"],
        &["improving"],
    ],
    range: 3..=8,
};

static WORD_EMPO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EMPO_CHILDREN),
    value: None,
};

pub static WORD_EMPO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("lyees"),
        dictgen::InsensitiveStr::Ascii("rer"),
    ],
    values: &[&["employees"], &["emperor"]],
    range: 3..=5,
};

static WORD_EMPL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EMPL_CHILDREN),
    value: None,
};

pub static WORD_EMPL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ore"),
        dictgen::InsensitiveStr::Ascii("oyeer"),
        dictgen::InsensitiveStr::Ascii("oyeers"),
        dictgen::InsensitiveStr::Ascii("oyeur"),
        dictgen::InsensitiveStr::Ascii("oyeurs"),
        dictgen::InsensitiveStr::Ascii("y"),
        dictgen::InsensitiveStr::Ascii("yed"),
        dictgen::InsensitiveStr::Ascii("yee"),
        dictgen::InsensitiveStr::Ascii("yees"),
        dictgen::InsensitiveStr::Ascii("yer"),
        dictgen::InsensitiveStr::Ascii("yers"),
        dictgen::InsensitiveStr::Ascii("ying"),
        dictgen::InsensitiveStr::Ascii("yment"),
        dictgen::InsensitiveStr::Ascii("yments"),
    ],
    values: &[
        &["employer"],
        &["employer"],
        &["employees"],
        &["employer"],
        &["employer"],
        &["employ", "empty", "imply"],
        &["employed"],
        &["employee"],
        &["employees"],
        &["employer"],
        &["employers"],
        &["employing"],
        &["employment"],
        &["employments"],
    ],
    range: 1..=6,
};

static WORD_EMPI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EMPI_CHILDREN),
    value: None,
};

pub static WORD_EMPI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ers"),
        dictgen::InsensitiveStr::Ascii("racally"),
        dictgen::InsensitiveStr::Ascii("rial"),
        dictgen::InsensitiveStr::Ascii("rialism"),
        dictgen::InsensitiveStr::Ascii("rialist"),
        dictgen::InsensitiveStr::Ascii("ricaly"),
        dictgen::InsensitiveStr::Ascii("ted"),
        dictgen::InsensitiveStr::Ascii("tness"),
    ],
    values: &[
        &["empires"],
        &["empirically"],
        &["empirical", "imperial"],
        &["imperialism"],
        &["imperialist"],
        &["empirically"],
        &["emptied"],
        &["emptiness"],
    ],
    range: 3..=7,
};

static WORD_EMPH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EMPH_CHILDREN),
    value: None,
};

pub static WORD_EMPH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("acized"),
        dictgen::InsensitiveStr::Ascii("acizing"),
        dictgen::InsensitiveStr::Ascii("aised"),
        dictgen::InsensitiveStr::Ascii("atetic"),
        dictgen::InsensitiveStr::Ascii("atised"),
        dictgen::InsensitiveStr::Ascii("atising"),
        dictgen::InsensitiveStr::Ascii("atize"),
        dictgen::InsensitiveStr::Ascii("atized"),
        dictgen::InsensitiveStr::Ascii("atizes"),
        dictgen::InsensitiveStr::Ascii("atizing"),
        dictgen::InsensitiveStr::Ascii("azise"),
        dictgen::InsensitiveStr::Ascii("azised"),
        dictgen::InsensitiveStr::Ascii("azises"),
        dictgen::InsensitiveStr::Ascii("azising"),
        dictgen::InsensitiveStr::Ascii("eral"),
        dictgen::InsensitiveStr::Ascii("esized"),
        dictgen::InsensitiveStr::Ascii("esizes"),
        dictgen::InsensitiveStr::Ascii("esizing"),
        dictgen::InsensitiveStr::Ascii("etamines"),
        dictgen::InsensitiveStr::Ascii("isized"),
        dictgen::InsensitiveStr::Ascii("isizes"),
        dictgen::InsensitiveStr::Ascii("sis"),
        dictgen::InsensitiveStr::Ascii("ysyma"),
    ],
    values: &[
        &["emphasized"],
        &["emphasizing"],
        &["emphasised"],
        &["empathetic"],
        &["emphasised"],
        &["emphasising"],
        &["empathize"],
        &["emphasized"],
        &["emphasizes"],
        &["emphasizing"],
        &["emphasise"],
        &["emphasised"],
        &["emphasises"],
        &["emphasising"],
        &["ephemeral"],
        &["emphasized"],
        &["emphasizes"],
        &["emphasizing"],
        &["amphetamines"],
        &["emphasized"],
        &["emphasizes"],
        &["emphasis"],
        &["emphysema"],
    ],
    range: 3..=8,
};

static WORD_EMPE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EMPE_CHILDREN),
    value: None,
};

pub static WORD_EMPE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("rial"),
        dictgen::InsensitiveStr::Ascii("rially"),
        dictgen::InsensitiveStr::Ascii("rical"),
        dictgen::InsensitiveStr::Ascii("rically"),
    ],
    values: &[
        &["imperial"],
        &["imperially"],
        &["empirical"],
        &["empirically"],
    ],
    range: 4..=7,
};

static WORD_EMPA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EMPA_CHILDREN),
    value: None,
};

pub static WORD_EMPA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("hsize"),
        dictgen::InsensitiveStr::Ascii("hsized"),
        dictgen::InsensitiveStr::Ascii("hsizes"),
        dictgen::InsensitiveStr::Ascii("hsizing"),
        dictgen::InsensitiveStr::Ascii("hty"),
        dictgen::InsensitiveStr::Ascii("ss"),
        dictgen::InsensitiveStr::Ascii("sses"),
        dictgen::InsensitiveStr::Ascii("thatic"),
        dictgen::InsensitiveStr::Ascii("thethic"),
        dictgen::InsensitiveStr::Ascii("thie"),
    ],
    values: &[
        &["emphasize"],
        &["emphasized"],
        &["emphasizes"],
        &["emphasizing"],
        &["empathy"],
        &["impasse"],
        &["impasses"],
        &["empathetic"],
        &["empathetic"],
        &["empathize"],
    ],
    range: 2..=7,
};

static WORD_EMO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EMO_CHILDREN),
    value: None,
};

pub static WORD_EMO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("bdiment"),
        dictgen::InsensitiveStr::Ascii("iji"),
        dictgen::InsensitiveStr::Ascii("tionaly"),
        dictgen::InsensitiveStr::Ascii("tionella"),
        dictgen::InsensitiveStr::Ascii("ty"),
        dictgen::InsensitiveStr::Ascii("ugh"),
        dictgen::InsensitiveStr::Ascii("ught"),
    ],
    values: &[
        &["embodiment"],
        &["emoji"],
        &["emotionally"],
        &["emotionally"],
        &["empty"],
        &["enough"],
        &["enough"],
    ],
    range: 2..=8,
};

static WORD_EMN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EMN_CHILDREN),
    value: None,
};

pub static WORD_EMN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ity")],
    values: &[&["enmity"]],
    range: 3..=3,
};

static WORD_EMM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EMM_CHILDREN),
    value: None,
};

pub static WORD_EMM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ediately"),
        dictgen::InsensitiveStr::Ascii("igrated"),
        dictgen::InsensitiveStr::Ascii("inent"),
        dictgen::InsensitiveStr::Ascii("inently"),
        dictgen::InsensitiveStr::Ascii("isaries"),
        dictgen::InsensitiveStr::Ascii("isarries"),
        dictgen::InsensitiveStr::Ascii("isarry"),
        dictgen::InsensitiveStr::Ascii("isary"),
        dictgen::InsensitiveStr::Ascii("ision"),
        dictgen::InsensitiveStr::Ascii("isions"),
        dictgen::InsensitiveStr::Ascii("it"),
        dictgen::InsensitiveStr::Ascii("ited"),
        dictgen::InsensitiveStr::Ascii("iting"),
        dictgen::InsensitiveStr::Ascii("its"),
        dictgen::InsensitiveStr::Ascii("itted"),
        dictgen::InsensitiveStr::Ascii("itting"),
    ],
    values: &[
        &["immediately"],
        &["emigrated", "immigrated"],
        &["eminent", "imminent"],
        &["eminently"],
        &["emissaries"],
        &["emissaries"],
        &["emissary"],
        &["emissary"],
        &["emission"],
        &["emissions"],
        &["emit"],
        &["emitted"],
        &["emitting"],
        &["emits"],
        &["emitted"],
        &["emitting"],
    ],
    range: 2..=8,
};

static WORD_EML_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EML_CHILDREN),
    value: None,
};

pub static WORD_EML_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ation")],
    values: &[&["emulation"]],
    range: 5..=5,
};

static WORD_EMI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EMI_CHILDREN),
    value: None,
};

pub static WORD_EMI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ited"),
        dictgen::InsensitiveStr::Ascii("nate"),
        dictgen::InsensitiveStr::Ascii("nated"),
        dictgen::InsensitiveStr::Ascii("pres"),
        dictgen::InsensitiveStr::Ascii("sion"),
        dictgen::InsensitiveStr::Ascii("ss"),
        dictgen::InsensitiveStr::Ascii("ssed"),
        dictgen::InsensitiveStr::Ascii("table"),
        dictgen::InsensitiveStr::Ascii("ted"),
        dictgen::InsensitiveStr::Ascii("ting"),
        dictgen::InsensitiveStr::Ascii("tion"),
    ],
    values: &[
        &["emitted"],
        &["emanate"],
        &["emanated"],
        &["empires"],
        &["emission"],
        &["remiss", "amiss", "amass"],
        &["amassed", "amiss"],
        &["emittable"],
        &["emitted"],
        &["emitting"],
        &["emission", "emotion"],
    ],
    range: 2..=5,
};

static WORD_EME_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EME_CHILDREN),
    value: None,
};

pub static WORD_EME_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("dded"),
        dictgen::InsensitiveStr::Ascii("grency"),
        dictgen::InsensitiveStr::Ascii("net"),
        dictgen::InsensitiveStr::Ascii("nets"),
        dictgen::InsensitiveStr::Ascii("nse"),
        dictgen::InsensitiveStr::Ascii("nsely"),
        dictgen::InsensitiveStr::Ascii("rgancies"),
        dictgen::InsensitiveStr::Ascii("rgencias"),
        dictgen::InsensitiveStr::Ascii("rgend"),
        dictgen::InsensitiveStr::Ascii("rgenices"),
        dictgen::InsensitiveStr::Ascii("rgenies"),
        dictgen::InsensitiveStr::Ascii("rgerd"),
    ],
    values: &[
        &["embedded"],
        &["emergency"],
        &["element"],
        &["elements"],
        &["immense"],
        &["immensely"],
        &["emergencies"],
        &["emergencies"],
        &["emerged"],
        &["emergencies"],
        &["emergencies"],
        &["emerged"],
    ],
    range: 3..=8,
};

static WORD_EMC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EMC_CHILDREN),
    value: None,
};

pub static WORD_EMC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("as"),
        dictgen::InsensitiveStr::Ascii("ompass"),
        dictgen::InsensitiveStr::Ascii("ompassed"),
        dictgen::InsensitiveStr::Ascii("ompassing"),
    ],
    values: &[
        &["emacs"],
        &["encompass"],
        &["encompassed"],
        &["encompassing"],
    ],
    range: 2..=9,
};

static WORD_EMB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_EMB_CHILDREN),
    value: None,
};

static WORD_EMB_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_EMBA_NODE),
    Some(&WORD_EMBB_NODE),
    None,
    Some(&WORD_EMBD_NODE),
    Some(&WORD_EMBE_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_EMBL_NODE),
    None,
    None,
    Some(&WORD_EMBO_NODE),
    None,
    None,
    Some(&WORD_EMBR_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_EMBR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EMBR_CHILDREN),
    value: None,
};

pub static WORD_EMBR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ago"),
        dictgen::InsensitiveStr::Ascii("io"),
        dictgen::InsensitiveStr::Ascii("ios"),
        dictgen::InsensitiveStr::Ascii("odery"),
    ],
    values: &[&["embargo"], &["embryo"], &["embryos"], &["embroidery"]],
    range: 2..=5,
};

static WORD_EMBO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EMBO_CHILDREN),
    value: None,
};

pub static WORD_EMBO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("dyment"),
        dictgen::InsensitiveStr::Ascii("ld"),
    ],
    values: &[&["embodiment"], &["embolden"]],
    range: 2..=6,
};

static WORD_EMBL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EMBL_CHILDREN),
    value: None,
};

pub static WORD_EMBL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("amatic")],
    values: &[&["emblematic"]],
    range: 6..=6,
};

static WORD_EMBE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EMBE_CHILDREN),
    value: None,
};

pub static WORD_EMBE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("bbed"),
        dictgen::InsensitiveStr::Ascii("dd"),
        dictgen::InsensitiveStr::Ascii("ddded"),
        dictgen::InsensitiveStr::Ascii("ddeding"),
        dictgen::InsensitiveStr::Ascii("dds"),
        dictgen::InsensitiveStr::Ascii("ded"),
        dictgen::InsensitiveStr::Ascii("dedded"),
        dictgen::InsensitiveStr::Ascii("ding"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("rrassing"),
        dictgen::InsensitiveStr::Ascii("rrassment"),
        dictgen::InsensitiveStr::Ascii("zelled"),
    ],
    values: &[
        &["embedded"],
        &["embed"],
        &["embedded"],
        &["embedding"],
        &["embeds"],
        &["embedded"],
        &["embedded"],
        &["embedding"],
        &["embed"],
        &["embarrassing"],
        &["embarrassment"],
        &["embezzled"],
    ],
    range: 2..=9,
};

static WORD_EMBD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EMBD_CHILDREN),
    value: None,
};

pub static WORD_EMBD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("der"),
        dictgen::InsensitiveStr::Ascii("edded"),
    ],
    values: &[&["embedder"], &["embedded"]],
    range: 3..=5,
};

static WORD_EMBB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EMBB_CHILDREN),
    value: None,
};

pub static WORD_EMBB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("edded"),
        dictgen::InsensitiveStr::Ascii("eded"),
    ],
    values: &[&["embedded"], &["embedded"]],
    range: 4..=5,
};

static WORD_EMBA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EMBA_CHILDREN),
    value: None,
};

pub static WORD_EMBA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("lance"),
        dictgen::InsensitiveStr::Ascii("raasing"),
        dictgen::InsensitiveStr::Ascii("ras"),
        dictgen::InsensitiveStr::Ascii("rasaing"),
        dictgen::InsensitiveStr::Ascii("rased"),
        dictgen::InsensitiveStr::Ascii("rases"),
        dictgen::InsensitiveStr::Ascii("rasing"),
        dictgen::InsensitiveStr::Ascii("rasingly"),
        dictgen::InsensitiveStr::Ascii("rass"),
        dictgen::InsensitiveStr::Ascii("rassed"),
        dictgen::InsensitiveStr::Ascii("rasses"),
        dictgen::InsensitiveStr::Ascii("rassig"),
        dictgen::InsensitiveStr::Ascii("rassign"),
        dictgen::InsensitiveStr::Ascii("rassimg"),
        dictgen::InsensitiveStr::Ascii("rassing"),
        dictgen::InsensitiveStr::Ascii("rassingly"),
        dictgen::InsensitiveStr::Ascii("rassment"),
        dictgen::InsensitiveStr::Ascii("rasssing"),
        dictgen::InsensitiveStr::Ascii("ress"),
        dictgen::InsensitiveStr::Ascii("ressed"),
        dictgen::InsensitiveStr::Ascii("resses"),
        dictgen::InsensitiveStr::Ascii("ressing"),
        dictgen::InsensitiveStr::Ascii("rgos"),
        dictgen::InsensitiveStr::Ascii("rissing"),
        dictgen::InsensitiveStr::Ascii("rras"),
        dictgen::InsensitiveStr::Ascii("rrased"),
        dictgen::InsensitiveStr::Ascii("rrasement"),
        dictgen::InsensitiveStr::Ascii("rrases"),
        dictgen::InsensitiveStr::Ascii("rrasing"),
        dictgen::InsensitiveStr::Ascii("rrasingly"),
        dictgen::InsensitiveStr::Ascii("rrasment"),
        dictgen::InsensitiveStr::Ascii("rrasments"),
        dictgen::InsensitiveStr::Ascii("rress"),
        dictgen::InsensitiveStr::Ascii("rressed"),
        dictgen::InsensitiveStr::Ascii("rressing"),
        dictgen::InsensitiveStr::Ascii("rressment"),
        dictgen::InsensitiveStr::Ascii("rrissing"),
        dictgen::InsensitiveStr::Ascii("rrssing"),
        dictgen::InsensitiveStr::Ascii("ssay"),
        dictgen::InsensitiveStr::Ascii("ssey"),
        dictgen::InsensitiveStr::Ascii("sssy"),
    ],
    values: &[
        &["imbalance"],
        &["embarrassing"],
        &["embarrass"],
        &["embarrassing"],
        &["embarrassed"],
        &["embarrasses"],
        &["embarrassing"],
        &["embarrassingly"],
        &["embarrass"],
        &["embarrassed"],
        &["embarrasses"],
        &["embarrassing"],
        &["embarrassing"],
        &["embarrassing"],
        &["embarrassing"],
        &["embarrassingly"],
        &["embarrassment"],
        &["embarrassing"],
        &["embarrass"],
        &["embarrassed"],
        &["embarrasses"],
        &["embarrassing"],
        &["embargoes"],
        &["embarrassing"],
        &["embarrass"],
        &["embarrassed"],
        &["embarrassment"],
        &["embarrassed"],
        &["embarrassing"],
        &["embarrassingly"],
        &["embarrassment"],
        &["embarrassment"],
        &["embarrassed"],
        &["embarrassed"],
        &["embarrassing"],
        &["embarrassment"],
        &["embarrassing"],
        &["embarrassing"],
        &["embassy"],
        &["embassy"],
        &["embassy"],
    ],
    range: 3..=9,
};

static WORD_EMA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EMA_CHILDREN),
    value: None,
};

pub static WORD_EMA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("baroged"),
        dictgen::InsensitiveStr::Ascii("ble"),
        dictgen::InsensitiveStr::Ascii("bled"),
        dictgen::InsensitiveStr::Ascii("bles"),
        dictgen::InsensitiveStr::Ascii("bling"),
        dictgen::InsensitiveStr::Ascii("brassing"),
        dictgen::InsensitiveStr::Ascii("brgo"),
        dictgen::InsensitiveStr::Ascii("bssy"),
        dictgen::InsensitiveStr::Ascii("i"),
        dictgen::InsensitiveStr::Ascii("illing"),
        dictgen::InsensitiveStr::Ascii("pthetic"),
        dictgen::InsensitiveStr::Ascii("pthize"),
        dictgen::InsensitiveStr::Ascii("pthy"),
        dictgen::InsensitiveStr::Ascii("sc"),
    ],
    values: &[
        &["embargoed"],
        &["enable"],
        &["enabled"],
        &["enables"],
        &["enabling"],
        &["embarrassing"],
        &["embargo"],
        &["embassy"],
        &["email"],
        &["emailing"],
        &["empathetic"],
        &["empathize"],
        &["empathy"],
        &["emacs"],
    ],
    range: 1..=8,
};

static WORD_EL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_EL_CHILDREN),
    value: None,
};

static WORD_EL_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_ELA_NODE),
    None,
    Some(&WORD_ELC_NODE),
    Some(&WORD_ELD_NODE),
    Some(&WORD_ELE_NODE),
    None,
    Some(&WORD_ELG_NODE),
    None,
    Some(&WORD_ELI_NODE),
    None,
    None,
    Some(&WORD_ELL_NODE),
    Some(&WORD_ELM_NODE),
    None,
    Some(&WORD_ELO_NODE),
    Some(&WORD_ELP_NODE),
    None,
    None,
    Some(&WORD_ELS_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_ELS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ELS_CHILDREN),
    value: None,
};

pub static WORD_ELS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ef"),
        dictgen::InsensitiveStr::Ascii("ehwere"),
        dictgen::InsensitiveStr::Ascii("eof"),
        dictgen::InsensitiveStr::Ascii("eswhere"),
        dictgen::InsensitiveStr::Ascii("eware"),
        dictgen::InsensitiveStr::Ascii("ewehere"),
        dictgen::InsensitiveStr::Ascii("ewere"),
        dictgen::InsensitiveStr::Ascii("ewhwere"),
        dictgen::InsensitiveStr::Ascii("iof"),
        dictgen::InsensitiveStr::Ascii("of"),
    ],
    values: &[
        &["elseif"],
        &["elsewhere"],
        &["elseif"],
        &["elsewhere"],
        &["elsewhere"],
        &["elsewhere"],
        &["elsewhere"],
        &["elsewhere"],
        &["elseif"],
        &["elseif"],
    ],
    range: 2..=7,
};

static WORD_ELP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ELP_CHILDREN),
    value: None,
};

pub static WORD_ELP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("hant")],
    values: &[&["elephant"]],
    range: 4..=4,
};

static WORD_ELO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ELO_CHILDREN),
    value: None,
};

pub static WORD_ELO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ctrolytes"),
        dictgen::InsensitiveStr::Ascii("quantly"),
        dictgen::InsensitiveStr::Ascii("quentely"),
        dictgen::InsensitiveStr::Ascii("quenty"),
        dictgen::InsensitiveStr::Ascii("quintly"),
    ],
    values: &[
        &["electrolytes"],
        &["eloquently"],
        &["eloquently"],
        &["eloquently"],
        &["eloquently"],
    ],
    range: 6..=9,
};

static WORD_ELM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ELM_CHILDREN),
    value: None,
};

pub static WORD_ELM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("enet"),
        dictgen::InsensitiveStr::Ascii("enets"),
        dictgen::InsensitiveStr::Ascii("ent"),
        dictgen::InsensitiveStr::Ascii("ents"),
        dictgen::InsensitiveStr::Ascii("inate"),
        dictgen::InsensitiveStr::Ascii("inated"),
        dictgen::InsensitiveStr::Ascii("inates"),
        dictgen::InsensitiveStr::Ascii("inating"),
    ],
    values: &[
        &["element"],
        &["elements"],
        &["element"],
        &["elements"],
        &["eliminate"],
        &["eliminated"],
        &["eliminates"],
        &["eliminating"],
    ],
    range: 3..=7,
};

static WORD_ELL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ELL_CHILDREN),
    value: None,
};

pub static WORD_ELL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("apsed"),
        dictgen::InsensitiveStr::Ascii("ected"),
        dictgen::InsensitiveStr::Ascii("ement"),
        dictgen::InsensitiveStr::Ascii("emental"),
        dictgen::InsensitiveStr::Ascii("ementals"),
        dictgen::InsensitiveStr::Ascii("ements"),
        dictgen::InsensitiveStr::Ascii("ignton"),
        dictgen::InsensitiveStr::Ascii("iminate"),
        dictgen::InsensitiveStr::Ascii("iminated"),
        dictgen::InsensitiveStr::Ascii("iminates"),
        dictgen::InsensitiveStr::Ascii("iminating"),
        dictgen::InsensitiveStr::Ascii("ingotn"),
        dictgen::InsensitiveStr::Ascii("ipitcal"),
        dictgen::InsensitiveStr::Ascii("ipitcals"),
        dictgen::InsensitiveStr::Ascii("ipsical"),
        dictgen::InsensitiveStr::Ascii("ipsises"),
        dictgen::InsensitiveStr::Ascii("ipticle"),
        dictgen::InsensitiveStr::Ascii("ision"),
        dictgen::InsensitiveStr::Ascii("itot"),
        dictgen::InsensitiveStr::Ascii("itpical"),
        dictgen::InsensitiveStr::Ascii("oitt"),
        dictgen::InsensitiveStr::Ascii("pitical"),
    ],
    values: &[
        &["elapsed"],
        &["elected"],
        &["element"],
        &["elemental"],
        &["elementals"],
        &["elements"],
        &["ellington"],
        &["eliminate"],
        &["eliminated"],
        &["eliminates"],
        &["eliminating"],
        &["ellington"],
        &["elliptical"],
        &["elliptical"],
        &["elliptical"],
        &["ellipsis"],
        &["elliptical"],
        &["elision"],
        &["elliott"],
        &["elliptical"],
        &["elliott"],
        &["elliptical"],
    ],
    range: 4..=9,
};

static WORD_ELI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ELI_CHILDREN),
    value: None,
};

pub static WORD_ELI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cided"),
        dictgen::InsensitiveStr::Ascii("gable"),
        dictgen::InsensitiveStr::Ascii("gble"),
        dictgen::InsensitiveStr::Ascii("manates"),
        dictgen::InsensitiveStr::Ascii("manation"),
        dictgen::InsensitiveStr::Ascii("mates"),
        dictgen::InsensitiveStr::Ascii("menates"),
        dictgen::InsensitiveStr::Ascii("mentary"),
        dictgen::InsensitiveStr::Ascii("miante"),
        dictgen::InsensitiveStr::Ascii("miate"),
        dictgen::InsensitiveStr::Ascii("mimates"),
        dictgen::InsensitiveStr::Ascii("minacion"),
        dictgen::InsensitiveStr::Ascii("minas"),
        dictgen::InsensitiveStr::Ascii("minase"),
        dictgen::InsensitiveStr::Ascii("minaste"),
        dictgen::InsensitiveStr::Ascii("minatin"),
        dictgen::InsensitiveStr::Ascii("minato"),
        dictgen::InsensitiveStr::Ascii("minaton"),
        dictgen::InsensitiveStr::Ascii("minetaion"),
        dictgen::InsensitiveStr::Ascii("minster"),
        dictgen::InsensitiveStr::Ascii("mintate"),
        dictgen::InsensitiveStr::Ascii("mintates"),
        dictgen::InsensitiveStr::Ascii("minte"),
        dictgen::InsensitiveStr::Ascii("mnated"),
        dictgen::InsensitiveStr::Ascii("pse"),
        dictgen::InsensitiveStr::Ascii("pses"),
        dictgen::InsensitiveStr::Ascii("psis"),
        dictgen::InsensitiveStr::Ascii("psises"),
        dictgen::InsensitiveStr::Ascii("ptic"),
        dictgen::InsensitiveStr::Ascii("ptical"),
        dictgen::InsensitiveStr::Ascii("pticity"),
        dictgen::InsensitiveStr::Ascii("tisim"),
        dictgen::InsensitiveStr::Ascii("tistm"),
    ],
    values: &[
        &["elicited"],
        &["eligible"],
        &["eligible"],
        &["eliminates"],
        &["elimination"],
        &["eliminates"],
        &["eliminates"],
        &["elementary"],
        &["eliminate"],
        &["eliminate"],
        &["eliminates"],
        &["elimination"],
        &["eliminates"],
        &["eliminates"],
        &["eliminates"],
        &["elimination"],
        &["elimination"],
        &["elimination"],
        &["elimination"],
        &["eliminates"],
        &["eliminate"],
        &["eliminates"],
        &["eliminate"],
        &["eliminated"],
        &["ellipse", "eclipse"],
        &["ellipses", "eclipses", "ellipsis"],
        &["ellipsis", "eclipses"],
        &["ellipses", "ellipsis"],
        &["elliptic"],
        &["elliptical"],
        &["ellipticity"],
        &["elitism"],
        &["elitism"],
    ],
    range: 3..=9,
};

static WORD_ELG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ELG_CHILDREN),
    value: None,
};

pub static WORD_ELG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ible")],
    values: &[&["eligible"]],
    range: 4..=4,
};

static WORD_ELE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_ELE_CHILDREN),
    value: None,
};

static WORD_ELE_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_ELEA_NODE),
    None,
    Some(&WORD_ELEC_NODE),
    None,
    Some(&WORD_ELEE_NODE),
    None,
    Some(&WORD_ELEG_NODE),
    None,
    None,
    None,
    Some(&WORD_ELEK_NODE),
    Some(&WORD_ELEL_NODE),
    Some(&WORD_ELEM_NODE),
    Some(&WORD_ELEN_NODE),
    None,
    Some(&WORD_ELEP_NODE),
    None,
    None,
    Some(&WORD_ELES_NODE),
    Some(&WORD_ELET_NODE),
    None,
    Some(&WORD_ELEV_NODE),
    None,
    None,
    None,
    None,
];

static WORD_ELEV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ELEV_CHILDREN),
    value: None,
};

pub static WORD_ELEV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("atin")],
    values: &[&["elevation"]],
    range: 4..=4,
};

static WORD_ELET_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ELET_CHILDREN),
    value: None,
};

pub static WORD_ELET_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ricity"),
        dictgen::InsensitiveStr::Ascii("romagnitic"),
        dictgen::InsensitiveStr::Ascii("ronic"),
    ],
    values: &[&["electricity"], &["electromagnetic"], &["electronic"]],
    range: 5..=10,
};

static WORD_ELES_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ELES_CHILDREN),
    value: Some(&["eels", "else"]),
};

pub static WORD_ELES_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[],
    values: &[],
    range: 0..=0,
};

static WORD_ELEP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ELEP_CHILDREN),
    value: None,
};

pub static WORD_ELEP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ahnts"),
        dictgen::InsensitiveStr::Ascii("hans"),
        dictgen::InsensitiveStr::Ascii("hantes"),
        dictgen::InsensitiveStr::Ascii("hantis"),
        dictgen::InsensitiveStr::Ascii("hantos"),
        dictgen::InsensitiveStr::Ascii("hantus"),
    ],
    values: &[
        &["elephants"],
        &["elephants"],
        &["elephants"],
        &["elephants"],
        &["elephants"],
        &["elephants"],
    ],
    range: 4..=6,
};

static WORD_ELEN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ELEN_CHILDREN),
    value: None,
};

pub static WORD_ELEN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ment")],
    values: &[&["element"]],
    range: 4..=4,
};

static WORD_ELEM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ELEM_CHILDREN),
    value: None,
};

pub static WORD_ELEM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ant"),
        dictgen::InsensitiveStr::Ascii("antary"),
        dictgen::InsensitiveStr::Ascii("ement"),
        dictgen::InsensitiveStr::Ascii("ements"),
        dictgen::InsensitiveStr::Ascii("emt"),
        dictgen::InsensitiveStr::Ascii("en"),
        dictgen::InsensitiveStr::Ascii("enent"),
        dictgen::InsensitiveStr::Ascii("enental"),
        dictgen::InsensitiveStr::Ascii("enents"),
        dictgen::InsensitiveStr::Ascii("enet"),
        dictgen::InsensitiveStr::Ascii("enets"),
        dictgen::InsensitiveStr::Ascii("ens"),
        dictgen::InsensitiveStr::Ascii("enst"),
        dictgen::InsensitiveStr::Ascii("entay"),
        dictgen::InsensitiveStr::Ascii("ente"),
        dictgen::InsensitiveStr::Ascii("entery"),
        dictgen::InsensitiveStr::Ascii("entrary"),
        dictgen::InsensitiveStr::Ascii("entray"),
        dictgen::InsensitiveStr::Ascii("entries"),
        dictgen::InsensitiveStr::Ascii("entry"),
        dictgen::InsensitiveStr::Ascii("enty"),
        dictgen::InsensitiveStr::Ascii("et"),
        dictgen::InsensitiveStr::Ascii("etal"),
        dictgen::InsensitiveStr::Ascii("etn"),
        dictgen::InsensitiveStr::Ascii("etns"),
        dictgen::InsensitiveStr::Ascii("ets"),
        dictgen::InsensitiveStr::Ascii("inate"),
        dictgen::InsensitiveStr::Ascii("inated"),
        dictgen::InsensitiveStr::Ascii("inates"),
        dictgen::InsensitiveStr::Ascii("inating"),
        dictgen::InsensitiveStr::Ascii("nets"),
        dictgen::InsensitiveStr::Ascii("nt"),
        dictgen::InsensitiveStr::Ascii("ntal"),
        dictgen::InsensitiveStr::Ascii("nts"),
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("tary"),
        dictgen::InsensitiveStr::Ascii("ts"),
    ],
    values: &[
        &["element"],
        &["elementary"],
        &["element"],
        &["elements"],
        &["element"],
        &["element"],
        &["element"],
        &["elemental"],
        &["elements"],
        &["element"],
        &["elements"],
        &["elements"],
        &["elements"],
        &["elementary"],
        &["element", "elements"],
        &["elementary"],
        &["elementary"],
        &["elementary"],
        &["elementaries"],
        &["elementary"],
        &["elementary"],
        &["element"],
        &["elemental"],
        &["element"],
        &["elements"],
        &["elements"],
        &["eliminate"],
        &["eliminated"],
        &["eliminates"],
        &["eliminating"],
        &["elements"],
        &["element"],
        &["elemental"],
        &["elements"],
        &["element"],
        &["elementary"],
        &["elements"],
    ],
    range: 1..=7,
};

static WORD_ELEL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ELEL_CHILDREN),
    value: None,
};

pub static WORD_ELEL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ement"),
        dictgen::InsensitiveStr::Ascii("ements"),
        dictgen::InsensitiveStr::Ascii("ment"),
        dictgen::InsensitiveStr::Ascii("mental"),
        dictgen::InsensitiveStr::Ascii("mentary"),
        dictgen::InsensitiveStr::Ascii("ments"),
    ],
    values: &[
        &["element"],
        &["elements"],
        &["element"],
        &["elemental"],
        &["elementary"],
        &["elements"],
    ],
    range: 4..=7,
};

static WORD_ELEK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ELEK_CHILDREN),
    value: None,
};

pub static WORD_ELEK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("trolytes")],
    values: &[&["electrolytes"]],
    range: 8..=8,
};

static WORD_ELEG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ELEG_CHILDREN),
    value: None,
};

pub static WORD_ELEG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ible")],
    values: &[&["eligible"]],
    range: 4..=4,
};

static WORD_ELEE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ELEE_CHILDREN),
    value: None,
};

pub static WORD_ELEE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("mnt"),
        dictgen::InsensitiveStr::Ascii("nt"),
    ],
    values: &[&["element"], &["element"]],
    range: 2..=3,
};

static WORD_ELEC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_ELEC_CHILDREN),
    value: None,
};

static WORD_ELEC_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_ELECR_NODE),
    None,
    Some(&WORD_ELECT_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_ELECT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_ELECT_CHILDREN),
    value: None,
};

static WORD_ELECT_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_ELECTH_NODE),
    Some(&WORD_ELECTI_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_ELECTO_NODE),
    None,
    None,
    Some(&WORD_ELECTR_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_ELECTR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ELECTR_CHILDREN),
    value: None,
};

pub static WORD_ELECTR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ial"),
        dictgen::InsensitiveStr::Ascii("icain"),
        dictgen::InsensitiveStr::Ascii("ican"),
        dictgen::InsensitiveStr::Ascii("icial"),
        dictgen::InsensitiveStr::Ascii("icien"),
        dictgen::InsensitiveStr::Ascii("icion"),
        dictgen::InsensitiveStr::Ascii("iciy"),
        dictgen::InsensitiveStr::Ascii("icly"),
        dictgen::InsensitiveStr::Ascii("icman"),
        dictgen::InsensitiveStr::Ascii("icrain"),
        dictgen::InsensitiveStr::Ascii("ictian"),
        dictgen::InsensitiveStr::Ascii("icty"),
        dictgen::InsensitiveStr::Ascii("icy"),
        dictgen::InsensitiveStr::Ascii("inic"),
        dictgen::InsensitiveStr::Ascii("inics"),
        dictgen::InsensitiveStr::Ascii("isity"),
        dictgen::InsensitiveStr::Ascii("itian"),
        dictgen::InsensitiveStr::Ascii("iv"),
        dictgen::InsensitiveStr::Ascii("noics"),
        dictgen::InsensitiveStr::Ascii("oal"),
        dictgen::InsensitiveStr::Ascii("oate"),
        dictgen::InsensitiveStr::Ascii("obytes"),
        dictgen::InsensitiveStr::Ascii("ocity"),
        dictgen::InsensitiveStr::Ascii("ocytes"),
        dictgen::InsensitiveStr::Ascii("odan"),
        dictgen::InsensitiveStr::Ascii("oinc"),
        dictgen::InsensitiveStr::Ascii("olites"),
        dictgen::InsensitiveStr::Ascii("oltyes"),
        dictgen::InsensitiveStr::Ascii("olye"),
        dictgen::InsensitiveStr::Ascii("olyes"),
        dictgen::InsensitiveStr::Ascii("olyts"),
        dictgen::InsensitiveStr::Ascii("omagentic"),
        dictgen::InsensitiveStr::Ascii("omagnatic"),
        dictgen::InsensitiveStr::Ascii("omagnectic"),
        dictgen::InsensitiveStr::Ascii("omagnetc"),
        dictgen::InsensitiveStr::Ascii("omagntic"),
        dictgen::InsensitiveStr::Ascii("oman"),
        dictgen::InsensitiveStr::Ascii("omangetic"),
        dictgen::InsensitiveStr::Ascii("omegnetic"),
        dictgen::InsensitiveStr::Ascii("onagnetic"),
        dictgen::InsensitiveStr::Ascii("oncis"),
        dictgen::InsensitiveStr::Ascii("oncs"),
        dictgen::InsensitiveStr::Ascii("ones"),
        dictgen::InsensitiveStr::Ascii("onicas"),
        dictgen::InsensitiveStr::Ascii("onicos"),
        dictgen::InsensitiveStr::Ascii("onik"),
        dictgen::InsensitiveStr::Ascii("onis"),
        dictgen::InsensitiveStr::Ascii("onix"),
        dictgen::InsensitiveStr::Ascii("oylte"),
        dictgen::InsensitiveStr::Ascii("oyltes"),
    ],
    values: &[
        &["electrical"],
        &["electrician"],
        &["electrician"],
        &["electrical"],
        &["electrician"],
        &["electrician"],
        &["electricity"],
        &["electrically"],
        &["electrician"],
        &["electrician"],
        &["electrician"],
        &["electricity"],
        &["electricity"],
        &["electrician"],
        &["electronics"],
        &["electricity"],
        &["electrician"],
        &["electric"],
        &["electronics"],
        &["electoral"],
        &["electorate"],
        &["electrolytes"],
        &["electricity"],
        &["electrolytes"],
        &["electron"],
        &["electron"],
        &["electrolytes"],
        &["electrolytes"],
        &["electrolytes"],
        &["electrolytes"],
        &["electrolytes"],
        &["electromagnetic"],
        &["electromagnetic"],
        &["electromagnetic"],
        &["electromagnetic"],
        &["electromagnetic"],
        &["electron"],
        &["electromagnetic"],
        &["electromagnetic"],
        &["electromagnetic"],
        &["electrons"],
        &["electrons"],
        &["electrons"],
        &["electronics"],
        &["electronics"],
        &["election"],
        &["electronics"],
        &["election"],
        &["electrolytes"],
        &["electrolytes"],
    ],
    range: 2..=10,
};

static WORD_ELECTO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ELECTO_CHILDREN),
    value: None,
};

pub static WORD_ELECTO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("n"),
        dictgen::InsensitiveStr::Ascii("raat"),
        dictgen::InsensitiveStr::Ascii("rale"),
        dictgen::InsensitiveStr::Ascii("ratul"),
        dictgen::InsensitiveStr::Ascii("rial"),
        dictgen::InsensitiveStr::Ascii("rite"),
        dictgen::InsensitiveStr::Ascii("rlytes"),
        dictgen::InsensitiveStr::Ascii("rmagnetic"),
        dictgen::InsensitiveStr::Ascii("rn"),
        dictgen::InsensitiveStr::Ascii("rnic"),
        dictgen::InsensitiveStr::Ascii("rnics"),
        dictgen::InsensitiveStr::Ascii("rns"),
    ],
    values: &[
        &["election", "electron"],
        &["electorate"],
        &["electorate"],
        &["electoral"],
        &["electoral"],
        &["electorate"],
        &["electrolytes"],
        &["electromagnetic"],
        &["electron"],
        &["electronic"],
        &["electronics"],
        &["electrons"],
    ],
    range: 1..=9,
};

static WORD_ELECTI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ELECTI_CHILDREN),
    value: None,
};

pub static WORD_ELECTI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("c"),
        dictgen::InsensitiveStr::Ascii("cal"),
        dictgen::InsensitiveStr::Ascii("rc"),
        dictgen::InsensitiveStr::Ascii("rcal"),
        dictgen::InsensitiveStr::Ascii("vite"),
        dictgen::InsensitiveStr::Ascii("vre"),
    ],
    values: &[
        &["electric", "eclectic"],
        &["electrical"],
        &["electric"],
        &["electrical"],
        &["elective"],
        &["elective"],
    ],
    range: 1..=4,
};

static WORD_ELECTH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ELECTH_CHILDREN),
    value: None,
};

pub static WORD_ELECTH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("or")],
    values: &[&["electro"]],
    range: 2..=2,
};

static WORD_ELECR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ELECR_CHILDREN),
    value: None,
};

pub static WORD_ELECR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("to"),
        dictgen::InsensitiveStr::Ascii("tomagnetic"),
        dictgen::InsensitiveStr::Ascii("ton"),
    ],
    values: &[&["electro"], &["electromagnetic"], &["electron"]],
    range: 2..=10,
};

static WORD_ELEA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ELEA_CHILDREN),
    value: None,
};

pub static WORD_ELEA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("se"),
        dictgen::InsensitiveStr::Ascii("sed"),
        dictgen::InsensitiveStr::Ascii("ses"),
        dictgen::InsensitiveStr::Ascii("te"),
    ],
    values: &[&["release"], &["released"], &["releases"], &["relate"]],
    range: 2..=3,
};

static WORD_ELD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ELD_CHILDREN),
    value: None,
};

pub static WORD_ELD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("istribution")],
    values: &[&["redistribution"]],
    range: 11..=11,
};

static WORD_ELC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ELC_CHILDREN),
    value: None,
};

pub static WORD_ELC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ipse"),
        dictgen::InsensitiveStr::Ascii("tion"),
        dictgen::InsensitiveStr::Ascii("tromagnetic"),
    ],
    values: &[&["eclipse"], &["election"], &["electromagnetic"]],
    range: 4..=11,
};

static WORD_ELA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ELA_CHILDREN),
    value: None,
};

pub static WORD_ELA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("gance"),
        dictgen::InsensitiveStr::Ascii("gant"),
        dictgen::InsensitiveStr::Ascii("gantly"),
        dictgen::InsensitiveStr::Ascii("mentaries"),
        dictgen::InsensitiveStr::Ascii("mentary"),
        dictgen::InsensitiveStr::Ascii("mentries"),
        dictgen::InsensitiveStr::Ascii("mentry"),
        dictgen::InsensitiveStr::Ascii("spe"),
        dictgen::InsensitiveStr::Ascii("sped"),
        dictgen::InsensitiveStr::Ascii("spes"),
        dictgen::InsensitiveStr::Ascii("sping"),
    ],
    values: &[
        &["elegant"],
        &["elegant"],
        &["elegantly"],
        &["elementaries"],
        &["elementary"],
        &["elementaries"],
        &["elementary"],
        &["elapse"],
        &["elapsed"],
        &["elapses"],
        &["elapsing"],
    ],
    range: 3..=9,
};

static WORD_EJ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EJ_CHILDREN),
    value: None,
};

pub static WORD_EJ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("acluation"),
        dictgen::InsensitiveStr::Ascii("acualte"),
        dictgen::InsensitiveStr::Ascii("acualtion"),
        dictgen::InsensitiveStr::Ascii("acualtions"),
        dictgen::InsensitiveStr::Ascii("aculaion"),
        dictgen::InsensitiveStr::Ascii("aculatie"),
        dictgen::InsensitiveStr::Ascii("aculatin"),
        dictgen::InsensitiveStr::Ascii("aculaton"),
        dictgen::InsensitiveStr::Ascii("aculatte"),
    ],
    values: &[
        &["ejaculation"],
        &["ejaculate"],
        &["ejaculation"],
        &["ejaculation"],
        &["ejaculation"],
        &["ejaculate"],
        &["ejaculation"],
        &["ejaculation"],
        &["ejaculate"],
    ],
    range: 7..=10,
};

static WORD_EI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EI_CHILDREN),
    value: None,
};

pub static WORD_EI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("egn"),
        dictgen::InsensitiveStr::Ascii("fnach"),
        dictgen::InsensitiveStr::Ascii("ghteeen"),
        dictgen::InsensitiveStr::Ascii("ghten"),
        dictgen::InsensitiveStr::Ascii("ghter"),
        dictgen::InsensitiveStr::Ascii("gth"),
        dictgen::InsensitiveStr::Ascii("gtheen"),
        dictgen::InsensitiveStr::Ascii("hter"),
        dictgen::InsensitiveStr::Ascii("hths"),
        dictgen::InsensitiveStr::Ascii("nfahc"),
        dictgen::InsensitiveStr::Ascii("nstance"),
        dictgen::InsensitiveStr::Ascii("sntance"),
        dictgen::InsensitiveStr::Ascii("tehr"),
        dictgen::InsensitiveStr::Ascii("ter"),
        dictgen::InsensitiveStr::Ascii("th"),
        dictgen::InsensitiveStr::Ascii("tquette"),
    ],
    values: &[
        &["eigen", "reign"],
        &["einfach"],
        &["eighteen"],
        &["eighteen"],
        &["either"],
        &["eighth", "eight"],
        &["eighteen"],
        &["either"],
        &["eighths"],
        &["einfach"],
        &["instance"],
        &["instance"],
        &["either"],
        &["either"],
        &["with"],
        &["etiquette"],
    ],
    range: 2..=7,
};

static WORD_EH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EH_CHILDREN),
    value: None,
};

pub static WORD_EH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ance"),
        dictgen::InsensitiveStr::Ascii("anced"),
        dictgen::InsensitiveStr::Ascii("ancement"),
        dictgen::InsensitiveStr::Ascii("ancements"),
        dictgen::InsensitiveStr::Ascii("en"),
        dictgen::InsensitiveStr::Ascii("enever"),
        dictgen::InsensitiveStr::Ascii("ough"),
        dictgen::InsensitiveStr::Ascii("r"),
        dictgen::InsensitiveStr::Ascii("tanol"),
        dictgen::InsensitiveStr::Ascii("tereal"),
        dictgen::InsensitiveStr::Ascii("ternet"),
        dictgen::InsensitiveStr::Ascii("ther"),
        dictgen::InsensitiveStr::Ascii("thernet"),
        dictgen::InsensitiveStr::Ascii("tically"),
        dictgen::InsensitiveStr::Ascii("tnically"),
        dictgen::InsensitiveStr::Ascii("tnicities"),
        dictgen::InsensitiveStr::Ascii("tnicity"),
    ],
    values: &[
        &["enhance"],
        &["enhanced"],
        &["enhancement"],
        &["enhancements"],
        &["when", "hen", "even", "then"],
        &["whenever"],
        &["enough"],
        &["her"],
        &["ethanol"],
        &["ethereal"],
        &["ethernet"],
        &["ether", "either"],
        &["ethernet"],
        &["ethically"],
        &["ethnically"],
        &["ethnicities"],
        &["ethnicity"],
    ],
    range: 1..=9,
};

static WORD_EG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EG_CHILDREN),
    value: None,
};

pub static WORD_EG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("al"),
        dictgen::InsensitiveStr::Ascii("aletarian"),
        dictgen::InsensitiveStr::Ascii("alitara"),
        dictgen::InsensitiveStr::Ascii("alitatian"),
        dictgen::InsensitiveStr::Ascii("aliterian"),
        dictgen::InsensitiveStr::Ascii("als"),
        dictgen::InsensitiveStr::Ascii("de"),
        dictgen::InsensitiveStr::Ascii("des"),
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("enral"),
        dictgen::InsensitiveStr::Ascii("enralise"),
        dictgen::InsensitiveStr::Ascii("enralised"),
        dictgen::InsensitiveStr::Ascii("enralises"),
        dictgen::InsensitiveStr::Ascii("enralize"),
        dictgen::InsensitiveStr::Ascii("enralized"),
        dictgen::InsensitiveStr::Ascii("enralizes"),
        dictgen::InsensitiveStr::Ascii("enrally"),
        dictgen::InsensitiveStr::Ascii("ostitical"),
        dictgen::InsensitiveStr::Ascii("otastical"),
        dictgen::InsensitiveStr::Ascii("otestical"),
        dictgen::InsensitiveStr::Ascii("otisitcal"),
        dictgen::InsensitiveStr::Ascii("otistcal"),
        dictgen::InsensitiveStr::Ascii("otisticle"),
        dictgen::InsensitiveStr::Ascii("otystical"),
        dictgen::InsensitiveStr::Ascii("pytian"),
        dictgen::InsensitiveStr::Ascii("pytians"),
        dictgen::InsensitiveStr::Ascii("regrious"),
        dictgen::InsensitiveStr::Ascii("yptain"),
        dictgen::InsensitiveStr::Ascii("yptains"),
        dictgen::InsensitiveStr::Ascii("ytpian"),
        dictgen::InsensitiveStr::Ascii("ytpians"),
    ],
    values: &[
        &["equal"],
        &["egalitarian"],
        &["egalitarian"],
        &["egalitarian"],
        &["egalitarian"],
        &["equals"],
        &["edge"],
        &["edges"],
        &["edge"],
        &["general"],
        &["generalise"],
        &["generalised"],
        &["generalises"],
        &["generalize"],
        &["generalized"],
        &["generalizes"],
        &["generally"],
        &["egotistical"],
        &["egotistical"],
        &["egotistical"],
        &["egotistical"],
        &["egotistical"],
        &["egotistical"],
        &["egotistical"],
        &["egyptian"],
        &["egyptians"],
        &["egregious"],
        &["egyptian"],
        &["egyptians"],
        &["egyptian"],
        &["egyptians"],
    ],
    range: 1..=9,
};

static WORD_EF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_EF_CHILDREN),
    value: None,
};

static WORD_EF_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    None,
    None,
    Some(&WORD_EFE_NODE),
    Some(&WORD_EFF_NODE),
    None,
    None,
    Some(&WORD_EFI_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_EFO_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_EFO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EFO_CHILDREN),
    value: None,
};

pub static WORD_EFO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("rceable"),
        dictgen::InsensitiveStr::Ascii("re"),
    ],
    values: &[&["enforceable"], &["afore", "before"]],
    range: 2..=7,
};

static WORD_EFI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EFI_CHILDREN),
    value: None,
};

pub static WORD_EFI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("cient")],
    values: &[&["efficient"]],
    range: 5..=5,
};

static WORD_EFF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EFF_CHILDREN),
    value: None,
};

pub static WORD_EFF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ciency"),
        dictgen::InsensitiveStr::Ascii("cient"),
        dictgen::InsensitiveStr::Ascii("ciently"),
        dictgen::InsensitiveStr::Ascii("ctive"),
        dictgen::InsensitiveStr::Ascii("ctively"),
        dictgen::InsensitiveStr::Ascii("eceively"),
        dictgen::InsensitiveStr::Ascii("eciency"),
        dictgen::InsensitiveStr::Ascii("ecient"),
        dictgen::InsensitiveStr::Ascii("eciently"),
        dictgen::InsensitiveStr::Ascii("ecitvely"),
        dictgen::InsensitiveStr::Ascii("ecive"),
        dictgen::InsensitiveStr::Ascii("ecively"),
        dictgen::InsensitiveStr::Ascii("eck"),
        dictgen::InsensitiveStr::Ascii("ecked"),
        dictgen::InsensitiveStr::Ascii("ecks"),
        dictgen::InsensitiveStr::Ascii("eckt"),
        dictgen::InsensitiveStr::Ascii("ectice"),
        dictgen::InsensitiveStr::Ascii("ecticely"),
        dictgen::InsensitiveStr::Ascii("ectionate"),
        dictgen::InsensitiveStr::Ascii("ectivelly"),
        dictgen::InsensitiveStr::Ascii("ectivenss"),
        dictgen::InsensitiveStr::Ascii("ectiviness"),
        dictgen::InsensitiveStr::Ascii("ectivley"),
        dictgen::InsensitiveStr::Ascii("ectivly"),
        dictgen::InsensitiveStr::Ascii("ectivness"),
        dictgen::InsensitiveStr::Ascii("ectly"),
        dictgen::InsensitiveStr::Ascii("edts"),
        dictgen::InsensitiveStr::Ascii("eect"),
        dictgen::InsensitiveStr::Ascii("eects"),
        dictgen::InsensitiveStr::Ascii("ekt"),
        dictgen::InsensitiveStr::Ascii("etct"),
        dictgen::InsensitiveStr::Ascii("exts"),
        dictgen::InsensitiveStr::Ascii("iccient"),
        dictgen::InsensitiveStr::Ascii("iceincy"),
        dictgen::InsensitiveStr::Ascii("iceint"),
        dictgen::InsensitiveStr::Ascii("iceintly"),
        dictgen::InsensitiveStr::Ascii("icencty"),
        dictgen::InsensitiveStr::Ascii("icency"),
        dictgen::InsensitiveStr::Ascii("icent"),
        dictgen::InsensitiveStr::Ascii("icently"),
        dictgen::InsensitiveStr::Ascii("iciancy"),
        dictgen::InsensitiveStr::Ascii("iciantly"),
        dictgen::InsensitiveStr::Ascii("icienct"),
        dictgen::InsensitiveStr::Ascii("icienctly"),
        dictgen::InsensitiveStr::Ascii("icientcy"),
        dictgen::InsensitiveStr::Ascii("icienty"),
        dictgen::InsensitiveStr::Ascii("icieny"),
        dictgen::InsensitiveStr::Ascii("ictiveness"),
        dictgen::InsensitiveStr::Ascii("iency"),
        dictgen::InsensitiveStr::Ascii("ient"),
        dictgen::InsensitiveStr::Ascii("iently"),
        dictgen::InsensitiveStr::Ascii("ord"),
        dictgen::InsensitiveStr::Ascii("ordlessly"),
        dictgen::InsensitiveStr::Ascii("ords"),
        dictgen::InsensitiveStr::Ascii("ortlesly"),
        dictgen::InsensitiveStr::Ascii("ortlessely"),
        dictgen::InsensitiveStr::Ascii("ortlessley"),
        dictgen::InsensitiveStr::Ascii("ortlessy"),
        dictgen::InsensitiveStr::Ascii("ulence"),
    ],
    values: &[
        &["efficiency"],
        &["efficient"],
        &["efficiently"],
        &["effective"],
        &["effectively"],
        &["effectively"],
        &["efficiency"],
        &["efficient"],
        &["efficiently"],
        &["effectively"],
        &["effective"],
        &["effectively"],
        &["effect"],
        &["effected"],
        &["effects"],
        &["effect"],
        &["effective"],
        &["effectively"],
        &["affectionate"],
        &["effectively"],
        &["effectiveness"],
        &["effectiveness"],
        &["effectively"],
        &["effectively"],
        &["effectiveness"],
        &["effectively"],
        &["effects"],
        &["effect"],
        &["effects"],
        &["effect"],
        &["effect"],
        &["effects"],
        &["efficient"],
        &["efficiency"],
        &["efficient"],
        &["efficiently"],
        &["efficiency"],
        &["efficiency"],
        &["efficient"],
        &["efficiently"],
        &["efficiency"],
        &["efficiently"],
        &["efficient"],
        &["efficiency"],
        &["efficiently"],
        &["efficiently"],
        &["efficiency", "efficiently"],
        &["effectiveness"],
        &["efficiency"],
        &["efficient"],
        &["efficiently"],
        &["effort", "afford"],
        &["effortlessly"],
        &["efforts", "affords"],
        &["effortlessly"],
        &["effortlessly"],
        &["effortlessly"],
        &["effortlessly"],
        &["effluence"],
    ],
    range: 3..=10,
};

static WORD_EFE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EFE_CHILDREN),
    value: None,
};

pub static WORD_EFE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ct"),
        dictgen::InsensitiveStr::Ascii("ctive"),
        dictgen::InsensitiveStr::Ascii("ctively"),
        dictgen::InsensitiveStr::Ascii("l"),
        dictgen::InsensitiveStr::Ascii("rences"),
        dictgen::InsensitiveStr::Ascii("tivity"),
    ],
    values: &[
        &["effect"],
        &["effective"],
        &["effectively"],
        &["evil"],
        &["references"],
        &["effectivity"],
    ],
    range: 1..=7,
};

static WORD_EE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EE_CHILDREN),
    value: None,
};

pub static WORD_EE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("arly"),
        dictgen::InsensitiveStr::Ascii("eprom"),
        dictgen::InsensitiveStr::Ascii("ger"),
        dictgen::InsensitiveStr::Ascii("gerly"),
        dictgen::InsensitiveStr::Ascii("jus"),
        dictgen::InsensitiveStr::Ascii("scription"),
        dictgen::InsensitiveStr::Ascii("very"),
        dictgen::InsensitiveStr::Ascii("verything"),
        dictgen::InsensitiveStr::Ascii("verywhere"),
        dictgen::InsensitiveStr::Ascii("xtract"),
        dictgen::InsensitiveStr::Ascii("xtracted"),
        dictgen::InsensitiveStr::Ascii("xtracting"),
        dictgen::InsensitiveStr::Ascii("xtraction"),
        dictgen::InsensitiveStr::Ascii("xtracts"),
    ],
    values: &[
        &["early"],
        &["eeprom"],
        &["eager"],
        &["eagerly"],
        &["aegis"],
        &["description"],
        &["every"],
        &["everything"],
        &["everywhere"],
        &["extract"],
        &["extracted"],
        &["extracting"],
        &["extraction"],
        &["extracts"],
    ],
    range: 3..=9,
};

static WORD_ED_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ED_CHILDREN),
    value: None,
};

pub static WORD_ED_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("biles"),
        dictgen::InsensitiveStr::Ascii("cdic"),
        dictgen::InsensitiveStr::Ascii("dge"),
        dictgen::InsensitiveStr::Ascii("dges"),
        dictgen::InsensitiveStr::Ascii("ditable"),
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("eycat"),
        dictgen::InsensitiveStr::Ascii("eycats"),
        dictgen::InsensitiveStr::Ascii("ficient"),
        dictgen::InsensitiveStr::Ascii("iable"),
        dictgen::InsensitiveStr::Ascii("ibels"),
        dictgen::InsensitiveStr::Ascii("ige"),
        dictgen::InsensitiveStr::Ascii("iges"),
        dictgen::InsensitiveStr::Ascii("iit"),
        dictgen::InsensitiveStr::Ascii("iiting"),
        dictgen::InsensitiveStr::Ascii("iitor"),
        dictgen::InsensitiveStr::Ascii("iitors"),
        dictgen::InsensitiveStr::Ascii("iits"),
        dictgen::InsensitiveStr::Ascii("itedt"),
        dictgen::InsensitiveStr::Ascii("itiing"),
        dictgen::InsensitiveStr::Ascii("itoras"),
        dictgen::InsensitiveStr::Ascii("itores"),
        dictgen::InsensitiveStr::Ascii("itoro"),
        dictgen::InsensitiveStr::Ascii("itot"),
        dictgen::InsensitiveStr::Ascii("itots"),
        dictgen::InsensitiveStr::Ascii("itt"),
        dictgen::InsensitiveStr::Ascii("itted"),
        dictgen::InsensitiveStr::Ascii("itter"),
        dictgen::InsensitiveStr::Ascii("itting"),
        dictgen::InsensitiveStr::Ascii("ittor"),
        dictgen::InsensitiveStr::Ascii("n"),
        dictgen::InsensitiveStr::Ascii("nif"),
        dictgen::InsensitiveStr::Ascii("ning"),
        dictgen::InsensitiveStr::Ascii("npoint"),
        dictgen::InsensitiveStr::Ascii("oema"),
        dictgen::InsensitiveStr::Ascii("ucacional"),
        dictgen::InsensitiveStr::Ascii("ucationnal"),
        dictgen::InsensitiveStr::Ascii("xpected"),
    ],
    values: &[
        &["edibles"],
        &["ebcdic"],
        &["edge"],
        &["edges"],
        &["editable"],
        &["edge"],
        &["etiquette"],
        &["etiquettes"],
        &["deficient"],
        &["editable"],
        &["edibles"],
        &["edge"],
        &["edges"],
        &["edit"],
        &["editing"],
        &["editor"],
        &["editors"],
        &["edits"],
        &["edited"],
        &["editing"],
        &["editors"],
        &["editors"],
        &["editor"],
        &["editor"],
        &["editors"],
        &["edit"],
        &["edited"],
        &["editor"],
        &["editing"],
        &["editor"],
        &["end"],
        &["endif"],
        &["edging", "ending"],
        &["endpoint"],
        &["edema"],
        &["educational"],
        &["educational"],
        &["expected"],
    ],
    range: 1..=10,
};

static WORD_EC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EC_CHILDREN),
    value: None,
};

pub static WORD_EC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cessive"),
        dictgen::InsensitiveStr::Ascii("clectic"),
        dictgen::InsensitiveStr::Ascii("eonomy"),
        dictgen::InsensitiveStr::Ascii("ept"),
        dictgen::InsensitiveStr::Ascii("eption"),
        dictgen::InsensitiveStr::Ascii("eptions"),
        dictgen::InsensitiveStr::Ascii("idious"),
        dictgen::InsensitiveStr::Ascii("ilpse"),
        dictgen::InsensitiveStr::Ascii("lipes"),
        dictgen::InsensitiveStr::Ascii("lise"),
        dictgen::InsensitiveStr::Ascii("lispe"),
        dictgen::InsensitiveStr::Ascii("lpise"),
        dictgen::InsensitiveStr::Ascii("netricity"),
        dictgen::InsensitiveStr::Ascii("ognized"),
        dictgen::InsensitiveStr::Ascii("oligical"),
        dictgen::InsensitiveStr::Ascii("ologia"),
        dictgen::InsensitiveStr::Ascii("omonic"),
        dictgen::InsensitiveStr::Ascii("omonical"),
        dictgen::InsensitiveStr::Ascii("omonics"),
        dictgen::InsensitiveStr::Ascii("onimical"),
        dictgen::InsensitiveStr::Ascii("onimically"),
        dictgen::InsensitiveStr::Ascii("onimists"),
        dictgen::InsensitiveStr::Ascii("onomicaly"),
        dictgen::InsensitiveStr::Ascii("onomicas"),
        dictgen::InsensitiveStr::Ascii("onomiclly"),
        dictgen::InsensitiveStr::Ascii("onomicos"),
        dictgen::InsensitiveStr::Ascii("onomicus"),
        dictgen::InsensitiveStr::Ascii("onomisch"),
        dictgen::InsensitiveStr::Ascii("onomisesti"),
        dictgen::InsensitiveStr::Ascii("onomisit"),
        dictgen::InsensitiveStr::Ascii("onomisiti"),
        dictgen::InsensitiveStr::Ascii("onomistes"),
        dictgen::InsensitiveStr::Ascii("ounter"),
        dictgen::InsensitiveStr::Ascii("ountered"),
        dictgen::InsensitiveStr::Ascii("ountering"),
        dictgen::InsensitiveStr::Ascii("ounters"),
        dictgen::InsensitiveStr::Ascii("plicit"),
        dictgen::InsensitiveStr::Ascii("plicitly"),
        dictgen::InsensitiveStr::Ascii("ret"),
        dictgen::InsensitiveStr::Ascii("specially"),
        dictgen::InsensitiveStr::Ascii("stacys"),
        dictgen::InsensitiveStr::Ascii("stascy"),
        dictgen::InsensitiveStr::Ascii("stasty"),
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("tastic"),
        dictgen::InsensitiveStr::Ascii("tsasy"),
        dictgen::InsensitiveStr::Ascii("xept"),
        dictgen::InsensitiveStr::Ascii("xite"),
        dictgen::InsensitiveStr::Ascii("xited"),
        dictgen::InsensitiveStr::Ascii("xites"),
        dictgen::InsensitiveStr::Ascii("xiting"),
        dictgen::InsensitiveStr::Ascii("xtracted"),
        dictgen::InsensitiveStr::Ascii("zecute"),
        dictgen::InsensitiveStr::Ascii("zecuted"),
        dictgen::InsensitiveStr::Ascii("zecutes"),
        dictgen::InsensitiveStr::Ascii("zecuting"),
        dictgen::InsensitiveStr::Ascii("zecutive"),
        dictgen::InsensitiveStr::Ascii("zecutives"),
    ],
    values: &[
        &["excessive"],
        &["eclectic"],
        &["economy"],
        &["except"],
        &["exception"],
        &["exceptions"],
        &["deciduous"],
        &["eclipse"],
        &["eclipse"],
        &["eclipse"],
        &["eclipse"],
        &["eclipse"],
        &["eccentricity"],
        &["recognized"],
        &["ecological"],
        &["ecological"],
        &["economic"],
        &["economical"],
        &["economics"],
        &["economical"],
        &["economically"],
        &["economists"],
        &["economically"],
        &["economics"],
        &["economically"],
        &["economics"],
        &["economics"],
        &["economic"],
        &["economists"],
        &["economists"],
        &["economist"],
        &["economists"],
        &["encounter"],
        &["encountered"],
        &["encountering"],
        &["encounters"],
        &["explicit"],
        &["explicitly"],
        &["secret", "erect"],
        &["especially"],
        &["ecstasy"],
        &["ecstasy"],
        &["ecstasy"],
        &["etc"],
        &["ecstatic"],
        &["ecstasy"],
        &["except"],
        &["excite"],
        &["excited"],
        &["excites"],
        &["exciting"],
        &["extracted"],
        &["execute"],
        &["executed"],
        &["executes"],
        &["executing"],
        &["executive"],
        &["executives"],
    ],
    range: 1..=10,
};

static WORD_EB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EB_CHILDREN),
    value: None,
};

pub static WORD_EB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ale"),
        dictgen::InsensitiveStr::Ascii("aled"),
        dictgen::InsensitiveStr::Ascii("cidc"),
        dictgen::InsensitiveStr::Ascii("cuase"),
        dictgen::InsensitiveStr::Ascii("edded"),
    ],
    values: &[
        &["enable"],
        &["enabled"],
        &["ebcdic"],
        &["because"],
        &["embedded"],
    ],
    range: 3..=5,
};

static WORD_EA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_EA_CHILDREN),
    value: None,
};

static WORD_EA_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    Some(&WORD_EAB_NODE),
    Some(&WORD_EAC_NODE),
    None,
    None,
    None,
    Some(&WORD_EAG_NODE),
    Some(&WORD_EAH_NODE),
    Some(&WORD_EAI_NODE),
    None,
    None,
    Some(&WORD_EAL_NODE),
    Some(&WORD_EAM_NODE),
    Some(&WORD_EAN_NODE),
    None,
    None,
    None,
    Some(&WORD_EAR_NODE),
    Some(&WORD_EAS_NODE),
    Some(&WORD_EAT_NODE),
    None,
    None,
    None,
    Some(&WORD_EAX_NODE),
    None,
    Some(&WORD_EAZ_NODE),
];

static WORD_EAZ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EAZ_CHILDREN),
    value: None,
};

pub static WORD_EAZ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ier"),
        dictgen::InsensitiveStr::Ascii("iest"),
        dictgen::InsensitiveStr::Ascii("y"),
    ],
    values: &[&["easier"], &["easiest"], &["easy"]],
    range: 1..=4,
};

static WORD_EAX_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EAX_CHILDREN),
    value: None,
};

pub static WORD_EAX_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ct")],
    values: &[&["exact"]],
    range: 2..=2,
};

static WORD_EAT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EAT_CHILDREN),
    value: None,
};

pub static WORD_EAT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("swood"),
        dictgen::InsensitiveStr::Ascii("urn"),
    ],
    values: &[&["eastwood"], &["return", "saturn", "eaten"]],
    range: 3..=5,
};

static WORD_EAS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EAS_CHILDREN),
    value: None,
};

pub static WORD_EAS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ely"),
        dictgen::InsensitiveStr::Ascii("er"),
        dictgen::InsensitiveStr::Ascii("ili"),
        dictgen::InsensitiveStr::Ascii("iliy"),
        dictgen::InsensitiveStr::Ascii("illy"),
        dictgen::InsensitiveStr::Ascii("ilty"),
        dictgen::InsensitiveStr::Ascii("isly"),
        dictgen::InsensitiveStr::Ascii("ist"),
        dictgen::InsensitiveStr::Ascii("iy"),
        dictgen::InsensitiveStr::Ascii("ly"),
        dictgen::InsensitiveStr::Ascii("thetically"),
        dictgen::InsensitiveStr::Ascii("thetics"),
        dictgen::InsensitiveStr::Ascii("twod"),
        dictgen::InsensitiveStr::Ascii("twoood"),
        dictgen::InsensitiveStr::Ascii("twoord"),
        dictgen::InsensitiveStr::Ascii("yer"),
    ],
    values: &[
        &["easily"],
        &["easier", "eraser"],
        &["easily"],
        &["easily"],
        &["easily"],
        &["easily"],
        &["easily"],
        &["easiest"],
        &["easily"],
        &["easily"],
        &["esthetically"],
        &["esthetics"],
        &["eastwood"],
        &["eastwood"],
        &["eastwood"],
        &["easier"],
    ],
    range: 2..=10,
};

static WORD_EAR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EAR_CHILDREN),
    value: None,
};

pub static WORD_EAR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ch"),
        dictgen::InsensitiveStr::Ascii("htbound"),
        dictgen::InsensitiveStr::Ascii("htquakes"),
        dictgen::InsensitiveStr::Ascii("iler"),
        dictgen::InsensitiveStr::Ascii("ilest"),
        dictgen::InsensitiveStr::Ascii("ily"),
        dictgen::InsensitiveStr::Ascii("leir"),
        dictgen::InsensitiveStr::Ascii("ler"),
        dictgen::InsensitiveStr::Ascii("liear"),
        dictgen::InsensitiveStr::Ascii("lies"),
        dictgen::InsensitiveStr::Ascii("liet"),
        dictgen::InsensitiveStr::Ascii("list"),
        dictgen::InsensitiveStr::Ascii("lyer"),
        dictgen::InsensitiveStr::Ascii("nt"),
        dictgen::InsensitiveStr::Ascii("peice"),
        dictgen::InsensitiveStr::Ascii("pluggs"),
        dictgen::InsensitiveStr::Ascii("plus"),
        dictgen::InsensitiveStr::Ascii("thboud"),
        dictgen::InsensitiveStr::Ascii("thqauke"),
        dictgen::InsensitiveStr::Ascii("thqaukes"),
        dictgen::InsensitiveStr::Ascii("thquack"),
        dictgen::InsensitiveStr::Ascii("thquackes"),
        dictgen::InsensitiveStr::Ascii("thquacks"),
        dictgen::InsensitiveStr::Ascii("thquakers"),
        dictgen::InsensitiveStr::Ascii("thquaks"),
        dictgen::InsensitiveStr::Ascii("thquate"),
        dictgen::InsensitiveStr::Ascii("thqukes"),
        dictgen::InsensitiveStr::Ascii("y"),
        dictgen::InsensitiveStr::Ascii("yly"),
    ],
    values: &[
        &["search", "each"],
        &["earthbound"],
        &["earthquakes"],
        &["earlier"],
        &["earliest"],
        &["easily", "eerily"],
        &["earlier"],
        &["earlier"],
        &["earlier"],
        &["earliest"],
        &["earliest"],
        &["earliest"],
        &["earlier"],
        &["earned"],
        &["earpiece"],
        &["earplugs"],
        &["earplugs"],
        &["earthbound"],
        &["earthquake"],
        &["earthquakes"],
        &["earthquake"],
        &["earthquakes"],
        &["earthquakes"],
        &["earthquakes"],
        &["earthquakes"],
        &["earthquake"],
        &["earthquakes"],
        &["eery"],
        &["eerily"],
    ],
    range: 1..=9,
};

static WORD_EAN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EAN_CHILDREN),
    value: None,
};

pub static WORD_EAN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("able"),
        dictgen::InsensitiveStr::Ascii("ble"),
    ],
    values: &[&["enable"], &["enable"]],
    range: 3..=4,
};

static WORD_EAM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EAM_CHILDREN),
    value: None,
};

pub static WORD_EAM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cs"),
        dictgen::InsensitiveStr::Ascii("ple"),
        dictgen::InsensitiveStr::Ascii("ples"),
    ],
    values: &[&["emacs"], &["example"], &["examples"]],
    range: 2..=4,
};

static WORD_EAL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EAL_CHILDREN),
    value: None,
};

pub static WORD_EAL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ier"),
        dictgen::InsensitiveStr::Ascii("iest"),
    ],
    values: &[&["earlier"], &["earliest"]],
    range: 3..=4,
};

static WORD_EAI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EAI_CHILDREN),
    value: None,
};

pub static WORD_EAI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("lier"),
        dictgen::InsensitiveStr::Ascii("ser"),
    ],
    values: &[&["earlier"], &["easier"]],
    range: 3..=4,
};

static WORD_EAH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EAH_CHILDREN),
    value: None,
};

pub static WORD_EAH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("c")],
    values: &[&["each"]],
    range: 1..=1,
};

static WORD_EAG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EAG_CHILDREN),
    value: None,
};

pub static WORD_EAG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("rely")],
    values: &[&["eagerly"]],
    range: 4..=4,
};

static WORD_EAC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EAC_CHILDREN),
    value: None,
};

pub static WORD_EAC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("f"),
        dictgen::InsensitiveStr::Ascii("g"),
        dictgen::InsensitiveStr::Ascii("hohter"),
        dictgen::InsensitiveStr::Ascii("hotehr"),
        dictgen::InsensitiveStr::Ascii("hs"),
        dictgen::InsensitiveStr::Ascii("htoher"),
        dictgen::InsensitiveStr::Ascii("tly"),
    ],
    values: &[
        &["each"],
        &["each"],
        &["eachother"],
        &["eachother"],
        &["each"],
        &["eachother"],
        &["exactly"],
    ],
    range: 1..=6,
};

static WORD_EAB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_EAB_CHILDREN),
    value: None,
};

pub static WORD_EAB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("led")],
    values: &[&["enabled"]],
    range: 3..=3,
};

static WORD_D_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_D_CHILDREN),
    value: None,
};

static WORD_D_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_DA_NODE),
    Some(&WORD_DB_NODE),
    Some(&WORD_DC_NODE),
    Some(&WORD_DD_NODE),
    Some(&WORD_DE_NODE),
    Some(&WORD_DF_NODE),
    Some(&WORD_DG_NODE),
    None,
    Some(&WORD_DI_NODE),
    None,
    None,
    Some(&WORD_DL_NODE),
    None,
    Some(&WORD_DN_NODE),
    Some(&WORD_DO_NODE),
    Some(&WORD_DP_NODE),
    None,
    Some(&WORD_DR_NODE),
    Some(&WORD_DS_NODE),
    Some(&WORD_DT_NODE),
    Some(&WORD_DU_NODE),
    None,
    Some(&WORD_DW_NODE),
    None,
    Some(&WORD_DY_NODE),
    None,
];

static WORD_DY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DY_CHILDREN),
    value: None,
};

pub static WORD_DY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("amically"),
        dictgen::InsensitiveStr::Ascii("anamically"),
        dictgen::InsensitiveStr::Ascii("anmic"),
        dictgen::InsensitiveStr::Ascii("anmically"),
        dictgen::InsensitiveStr::Ascii("anmics"),
        dictgen::InsensitiveStr::Ascii("anmite"),
        dictgen::InsensitiveStr::Ascii("ansty"),
        dictgen::InsensitiveStr::Ascii("as"),
        dictgen::InsensitiveStr::Ascii("mamically"),
        dictgen::InsensitiveStr::Ascii("manically"),
        dictgen::InsensitiveStr::Ascii("manics"),
        dictgen::InsensitiveStr::Ascii("manite"),
        dictgen::InsensitiveStr::Ascii("namc"),
        dictgen::InsensitiveStr::Ascii("namcly"),
        dictgen::InsensitiveStr::Ascii("namcs"),
        dictgen::InsensitiveStr::Ascii("namicallly"),
        dictgen::InsensitiveStr::Ascii("namicaly"),
        dictgen::InsensitiveStr::Ascii("namicdns"),
        dictgen::InsensitiveStr::Ascii("namiclly"),
        dictgen::InsensitiveStr::Ascii("namicly"),
        dictgen::InsensitiveStr::Ascii("namicpsf"),
        dictgen::InsensitiveStr::Ascii("namicus"),
        dictgen::InsensitiveStr::Ascii("naminc"),
        dictgen::InsensitiveStr::Ascii("namincal"),
        dictgen::InsensitiveStr::Ascii("namincs"),
        dictgen::InsensitiveStr::Ascii("namis"),
        dictgen::InsensitiveStr::Ascii("namitage"),
        dictgen::InsensitiveStr::Ascii("namlic"),
        dictgen::InsensitiveStr::Ascii("namlically"),
        dictgen::InsensitiveStr::Ascii("nastry"),
        dictgen::InsensitiveStr::Ascii("nically"),
        dictgen::InsensitiveStr::Ascii("nmaic"),
        dictgen::InsensitiveStr::Ascii("nmaically"),
        dictgen::InsensitiveStr::Ascii("nmic"),
        dictgen::InsensitiveStr::Ascii("nmically"),
        dictgen::InsensitiveStr::Ascii("nmics"),
        dictgen::InsensitiveStr::Ascii("nsaty"),
        dictgen::InsensitiveStr::Ascii("pshoria"),
        dictgen::InsensitiveStr::Ascii("regulation"),
        dictgen::InsensitiveStr::Ascii("sentry"),
        dictgen::InsensitiveStr::Ascii("sfonction"),
        dictgen::InsensitiveStr::Ascii("sfonctional"),
        dictgen::InsensitiveStr::Ascii("sfucntion"),
        dictgen::InsensitiveStr::Ascii("sfucntional"),
        dictgen::InsensitiveStr::Ascii("sfuncion"),
        dictgen::InsensitiveStr::Ascii("sfunciton"),
        dictgen::InsensitiveStr::Ascii("sfuncitonal"),
        dictgen::InsensitiveStr::Ascii("sfunctionnal"),
        dictgen::InsensitiveStr::Ascii("sfunktion"),
        dictgen::InsensitiveStr::Ascii("sfunktional"),
        dictgen::InsensitiveStr::Ascii("shporia"),
        dictgen::InsensitiveStr::Ascii("soptian"),
        dictgen::InsensitiveStr::Ascii("sphoira"),
        dictgen::InsensitiveStr::Ascii("sphora"),
        dictgen::InsensitiveStr::Ascii("sphroia"),
        dictgen::InsensitiveStr::Ascii("spohria"),
        dictgen::InsensitiveStr::Ascii("spotian"),
        dictgen::InsensitiveStr::Ascii("stopain"),
        dictgen::InsensitiveStr::Ascii("stpoian"),
    ],
    values: &[
        &["dynamically"],
        &["dynamically"],
        &["dynamic"],
        &["dynamically"],
        &["dynamics"],
        &["dynamite"],
        &["dynasty"],
        &["dryas"],
        &["dynamically"],
        &["dynamically"],
        &["dynamics"],
        &["dynamite"],
        &["dynamic"],
        &["dynamincally", "dynamically"],
        &["dynamics"],
        &["dynamically"],
        &["dynamically"],
        &["dynamics"],
        &["dynamically"],
        &["dynamically"],
        &["dynamics"],
        &["dynamics"],
        &["dynamic"],
        &["dynamical"],
        &["dynamics"],
        &["dynamics"],
        &["dynamite"],
        &["dynamic"],
        &["dynamically"],
        &["dynasty"],
        &["dynamically"],
        &["dynamic"],
        &["dynamically"],
        &["dynamic"],
        &["dynamically"],
        &["dynamics"],
        &["dynasty"],
        &["dysphoria"],
        &["deregulation"],
        &["dysentery"],
        &["dysfunction"],
        &["dysfunctional"],
        &["dysfunction"],
        &["dysfunctional"],
        &["dysfunction"],
        &["dysfunction"],
        &["dysfunctional"],
        &["dysfunctional"],
        &["dysfunction"],
        &["dysfunctional"],
        &["dysphoria"],
        &["dystopian"],
        &["dysphoria"],
        &["dysphoria"],
        &["dysphoria"],
        &["dysphoria"],
        &["dystopian"],
        &["dystopian"],
        &["dystopian"],
    ],
    range: 2..=12,
};

static WORD_DW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DW_CHILDREN),
    value: None,
};

pub static WORD_DW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("arvens")],
    values: &[&["dwarves"]],
    range: 6..=6,
};

static WORD_DU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_DU_CHILDREN),
    value: None,
};

static WORD_DU_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_DUA_NODE),
    Some(&WORD_DUB_NODE),
    Some(&WORD_DUC_NODE),
    Some(&WORD_DUD_NODE),
    Some(&WORD_DUE_NODE),
    None,
    None,
    None,
    Some(&WORD_DUI_NODE),
    None,
    None,
    Some(&WORD_DUL_NODE),
    Some(&WORD_DUM_NODE),
    Some(&WORD_DUN_NODE),
    Some(&WORD_DUO_NODE),
    Some(&WORD_DUP_NODE),
    None,
    Some(&WORD_DUR_NODE),
    Some(&WORD_DUS_NODE),
    Some(&WORD_DUT_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_DUT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DUT_CHILDREN),
    value: None,
};

pub static WORD_DUT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ing")],
    values: &[&["during"]],
    range: 3..=3,
};

static WORD_DUS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DUS_CHILDREN),
    value: None,
};

pub static WORD_DUS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("btep"),
        dictgen::InsensitiveStr::Ascii("functional"),
        dictgen::InsensitiveStr::Ascii("gustingly"),
        dictgen::InsensitiveStr::Ascii("tification"),
    ],
    values: &[
        &["dubstep"],
        &["dysfunctional"],
        &["disgustingly"],
        &["justification"],
    ],
    range: 4..=10,
};

static WORD_DUR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DUR_CHILDREN),
    value: None,
};

pub static WORD_DUR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("abiliy"),
        dictgen::InsensitiveStr::Ascii("abillity"),
        dictgen::InsensitiveStr::Ascii("abiltiy"),
        dictgen::InsensitiveStr::Ascii("ationm"),
        dictgen::InsensitiveStr::Ascii("ectories"),
        dictgen::InsensitiveStr::Ascii("ectory"),
        dictgen::InsensitiveStr::Ascii("eing"),
        dictgen::InsensitiveStr::Ascii("ig"),
        dictgen::InsensitiveStr::Ascii("ining"),
        dictgen::InsensitiveStr::Ascii("ning"),
        dictgen::InsensitiveStr::Ascii("ring"),
    ],
    values: &[
        &["durability"],
        &["durability"],
        &["durability"],
        &["duration"],
        &["directories"],
        &["directory"],
        &["during"],
        &["during"],
        &["during"],
        &["during"],
        &["during"],
    ],
    range: 2..=8,
};

static WORD_DUP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DUP_CHILDREN),
    value: None,
};

pub static WORD_DUP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("icate"),
        dictgen::InsensitiveStr::Ascii("ilcates"),
        dictgen::InsensitiveStr::Ascii("lacate"),
        dictgen::InsensitiveStr::Ascii("lacated"),
        dictgen::InsensitiveStr::Ascii("lacates"),
        dictgen::InsensitiveStr::Ascii("lacation"),
        dictgen::InsensitiveStr::Ascii("lacte"),
        dictgen::InsensitiveStr::Ascii("lacted"),
        dictgen::InsensitiveStr::Ascii("lactes"),
        dictgen::InsensitiveStr::Ascii("laction"),
        dictgen::InsensitiveStr::Ascii("laicate"),
        dictgen::InsensitiveStr::Ascii("laicated"),
        dictgen::InsensitiveStr::Ascii("laicates"),
        dictgen::InsensitiveStr::Ascii("laication"),
        dictgen::InsensitiveStr::Ascii("late"),
        dictgen::InsensitiveStr::Ascii("lated"),
        dictgen::InsensitiveStr::Ascii("lates"),
        dictgen::InsensitiveStr::Ascii("lation"),
        dictgen::InsensitiveStr::Ascii("lcate"),
        dictgen::InsensitiveStr::Ascii("lciate"),
        dictgen::InsensitiveStr::Ascii("liacate"),
        dictgen::InsensitiveStr::Ascii("liacates"),
        dictgen::InsensitiveStr::Ascii("liace"),
        dictgen::InsensitiveStr::Ascii("liacte"),
        dictgen::InsensitiveStr::Ascii("liacted"),
        dictgen::InsensitiveStr::Ascii("liactes"),
        dictgen::InsensitiveStr::Ascii("liagte"),
        dictgen::InsensitiveStr::Ascii("liate"),
        dictgen::InsensitiveStr::Ascii("liated"),
        dictgen::InsensitiveStr::Ascii("liates"),
        dictgen::InsensitiveStr::Ascii("liating"),
        dictgen::InsensitiveStr::Ascii("liation"),
        dictgen::InsensitiveStr::Ascii("liations"),
        dictgen::InsensitiveStr::Ascii("licants"),
        dictgen::InsensitiveStr::Ascii("licas"),
        dictgen::InsensitiveStr::Ascii("licat"),
        dictgen::InsensitiveStr::Ascii("licatas"),
        dictgen::InsensitiveStr::Ascii("licatd"),
        dictgen::InsensitiveStr::Ascii("licats"),
        dictgen::InsensitiveStr::Ascii("licitas"),
        dictgen::InsensitiveStr::Ascii("licte"),
        dictgen::InsensitiveStr::Ascii("licted"),
        dictgen::InsensitiveStr::Ascii("lictes"),
        dictgen::InsensitiveStr::Ascii("liction"),
        dictgen::InsensitiveStr::Ascii("lifaces"),
        dictgen::InsensitiveStr::Ascii("lucated"),
        dictgen::InsensitiveStr::Ascii("plicate"),
        dictgen::InsensitiveStr::Ascii("plicated"),
        dictgen::InsensitiveStr::Ascii("plicates"),
        dictgen::InsensitiveStr::Ascii("plicating"),
        dictgen::InsensitiveStr::Ascii("plication"),
        dictgen::InsensitiveStr::Ascii("plications"),
    ],
    values: &[
        &["duplicate"],
        &["duplicates"],
        &["duplicate"],
        &["duplicated"],
        &["duplicates"],
        &["duplication"],
        &["duplicate"],
        &["duplicated"],
        &["duplicates"],
        &["duplication"],
        &["duplicate"],
        &["duplicated"],
        &["duplicates"],
        &["duplication"],
        &["duplicate"],
        &["duplicated"],
        &["duplicates"],
        &["duplication"],
        &["duplicate"],
        &["duplicate"],
        &["duplicate"],
        &["duplicates"],
        &["duplicate"],
        &["duplicate"],
        &["duplicated"],
        &["duplicates"],
        &["duplicate"],
        &["duplicate"],
        &["duplicated"],
        &["duplicates"],
        &["duplicating"],
        &["duplication"],
        &["duplications"],
        &["duplicates"],
        &["duplicates"],
        &["duplicate"],
        &["duplicates"],
        &["duplicated"],
        &["duplicates"],
        &["duplicates"],
        &["duplicate"],
        &["duplicated"],
        &["duplicates"],
        &["duplication"],
        &["duplicates"],
        &["duplicated"],
        &["duplicate"],
        &["duplicated"],
        &["duplicates"],
        &["duplicating"],
        &["duplication"],
        &["duplications"],
    ],
    range: 4..=10,
};

static WORD_DUO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DUO_CHILDREN),
    value: None,
};

pub static WORD_DUO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("blequote")],
    values: &[&["doublequote"]],
    range: 8..=8,
};

static WORD_DUN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DUN_CHILDREN),
    value: None,
};

pub static WORD_DUN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("egon"),
        dictgen::InsensitiveStr::Ascii("egons"),
        dictgen::InsensitiveStr::Ascii("geoness"),
        dictgen::InsensitiveStr::Ascii("geos"),
        dictgen::InsensitiveStr::Ascii("geoun"),
        dictgen::InsensitiveStr::Ascii("goen"),
        dictgen::InsensitiveStr::Ascii("goens"),
    ],
    values: &[
        &["dungeon"],
        &["dungeons"],
        &["dungeons"],
        &["dungeons"],
        &["dungeon"],
        &["dungeon"],
        &["dungeons"],
    ],
    range: 4..=7,
};

static WORD_DUM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DUM_CHILDREN),
    value: Some(&["dumb"]),
};

pub static WORD_DUM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("bbellls"),
        dictgen::InsensitiveStr::Ascii("bbels"),
        dictgen::InsensitiveStr::Ascii("bfouded"),
        dictgen::InsensitiveStr::Ascii("bfoundeads"),
        dictgen::InsensitiveStr::Ascii("bfouned"),
        dictgen::InsensitiveStr::Ascii("mp"),
        dictgen::InsensitiveStr::Ascii("plicate"),
        dictgen::InsensitiveStr::Ascii("plicated"),
        dictgen::InsensitiveStr::Ascii("plicates"),
        dictgen::InsensitiveStr::Ascii("plicating"),
        dictgen::InsensitiveStr::Ascii("ptser"),
        dictgen::InsensitiveStr::Ascii("spter"),
    ],
    values: &[
        &["dumbbells"],
        &["dumbbells"],
        &["dumbfounded"],
        &["dumbfounded"],
        &["dumbfounded"],
        &["dump", "dummy"],
        &["duplicate"],
        &["duplicated"],
        &["duplicates"],
        &["duplicating"],
        &["dumpster"],
        &["dumpster"],
    ],
    range: 2..=10,
};

static WORD_DUL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DUL_CHILDREN),
    value: None,
};

pub static WORD_DUL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aity"),
        dictgen::InsensitiveStr::Ascii("eing"),
        dictgen::InsensitiveStr::Ascii("icate"),
    ],
    values: &[&["duality"], &["dueling"], &["duplicate"]],
    range: 4..=5,
};

static WORD_DUI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DUI_CHILDREN),
    value: None,
};

pub static WORD_DUI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("rng")],
    values: &[&["during"]],
    range: 3..=3,
};

static WORD_DUE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DUE_CHILDREN),
    value: None,
};

pub static WORD_DUE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("tschland"),
    ],
    values: &[&["doing", "during", "dueling"], &["deutschland"]],
    range: 3..=8,
};

static WORD_DUD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DUD_CHILDREN),
    value: None,
};

pub static WORD_DUD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("o")],
    values: &[&["sudo"]],
    range: 1..=1,
};

static WORD_DUC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DUC_CHILDREN),
    value: None,
};

pub static WORD_DUC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ment"),
        dictgen::InsensitiveStr::Ascii("ument"),
    ],
    values: &[&["document"], &["document"]],
    range: 4..=5,
};

static WORD_DUB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DUB_CHILDREN),
    value: None,
};

pub static WORD_DUB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ios"),
        dictgen::InsensitiveStr::Ascii("le"),
        dictgen::InsensitiveStr::Ascii("led"),
        dictgen::InsensitiveStr::Ascii("ley"),
        dictgen::InsensitiveStr::Ascii("licade"),
        dictgen::InsensitiveStr::Ascii("licat"),
        dictgen::InsensitiveStr::Ascii("licate"),
        dictgen::InsensitiveStr::Ascii("licated"),
        dictgen::InsensitiveStr::Ascii("licates"),
        dictgen::InsensitiveStr::Ascii("lication"),
        dictgen::InsensitiveStr::Ascii("lications"),
        dictgen::InsensitiveStr::Ascii("ling"),
        dictgen::InsensitiveStr::Ascii("ly"),
        dictgen::InsensitiveStr::Ascii("setp"),
    ],
    values: &[
        &["dubious"],
        &["double"],
        &["doubled"],
        &["doubly"],
        &["duplicate"],
        &["duplicate"],
        &["duplicate"],
        &["duplicated"],
        &["duplicates"],
        &["duplication"],
        &["publications"],
        &["doubling", "dublin"],
        &["doubly"],
        &["dubstep"],
    ],
    range: 2..=9,
};

static WORD_DUA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DUA_CHILDREN),
    value: None,
};

pub static WORD_DUA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ghter"),
        dictgen::InsensitiveStr::Ascii("ghters"),
        dictgen::InsensitiveStr::Ascii("ilty"),
        dictgen::InsensitiveStr::Ascii("ltiy"),
    ],
    values: &[&["daughter"], &["daughters"], &["duality"], &["duality"]],
    range: 4..=6,
};

static WORD_DT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DT_CHILDREN),
    value: None,
};

pub static WORD_DT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("he"),
        dictgen::InsensitiveStr::Ascii("oring"),
    ],
    values: &[&["the"], &["storing"]],
    range: 2..=5,
};

static WORD_DS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DS_CHILDREN),
    value: None,
};

pub static WORD_DS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("crete"),
        dictgen::InsensitiveStr::Ascii("cretion"),
        dictgen::InsensitiveStr::Ascii("cribed"),
        dictgen::InsensitiveStr::Ascii("iable"),
        dictgen::InsensitiveStr::Ascii("iabled"),
        dictgen::InsensitiveStr::Ascii("plays"),
        dictgen::InsensitiveStr::Ascii("tination"),
        dictgen::InsensitiveStr::Ascii("tinations"),
        dictgen::InsensitiveStr::Ascii("yfunction"),
        dictgen::InsensitiveStr::Ascii("yfunctional"),
        dictgen::InsensitiveStr::Ascii("yphoria"),
        dictgen::InsensitiveStr::Ascii("ytopian"),
    ],
    values: &[
        &["discrete"],
        &["discretion"],
        &["described"],
        &["disable"],
        &["disabled"],
        &["displays"],
        &["destination"],
        &["destinations"],
        &["dysfunction"],
        &["dysfunctional"],
        &["dysphoria"],
        &["dystopian"],
    ],
    range: 5..=11,
};

static WORD_DR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_DR_CHILDREN),
    value: None,
};

static WORD_DR_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_DRA_NODE),
    None,
    None,
    None,
    Some(&WORD_DRE_NODE),
    Some(&WORD_DRF_NODE),
    None,
    None,
    Some(&WORD_DRI_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_DRN_NODE),
    Some(&WORD_DRO_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_DRU_NODE),
    Some(&WORD_DRV_NODE),
    Some(&WORD_DRW_NODE),
    None,
    None,
    None,
];

static WORD_DRW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DRW_CHILDREN),
    value: None,
};

pub static WORD_DRW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aing"),
        dictgen::InsensitiveStr::Ascii("awing"),
        dictgen::InsensitiveStr::Ascii("awings"),
    ],
    values: &[&["drawing"], &["drawing"], &["drawings"]],
    range: 4..=6,
};

static WORD_DRV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DRV_CHILDREN),
    value: None,
};

pub static WORD_DRV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ier")],
    values: &[&["driver"]],
    range: 3..=3,
};

static WORD_DRU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DRU_CHILDREN),
    value: None,
};

pub static WORD_DRU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("ming"),
        dictgen::InsensitiveStr::Ascii("mmless"),
    ],
    values: &[&["during"], &["drumming"], &["drumless"]],
    range: 3..=6,
};

static WORD_DRO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DRO_CHILDREN),
    value: None,
};

pub static WORD_DRO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("b"),
        dictgen::InsensitiveStr::Ascii("pabel"),
        dictgen::InsensitiveStr::Ascii("pable"),
        dictgen::InsensitiveStr::Ascii("ped"),
        dictgen::InsensitiveStr::Ascii("ping"),
        dictgen::InsensitiveStr::Ascii("ppend"),
        dictgen::InsensitiveStr::Ascii("ppped"),
        dictgen::InsensitiveStr::Ascii("pse"),
        dictgen::InsensitiveStr::Ascii("put"),
        dictgen::InsensitiveStr::Ascii("tmund"),
        dictgen::InsensitiveStr::Ascii("wt"),
        dictgen::InsensitiveStr::Ascii("wts"),
    ],
    values: &[
        &["drop"],
        &["droppable"],
        &["droppable"],
        &["dropped"],
        &["dropping"],
        &["dropped"],
        &["dropped"],
        &["drops"],
        &["dropout"],
        &["dortmund"],
        &["drouth"],
        &["droughts"],
    ],
    range: 1..=5,
};

static WORD_DRN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DRN_CHILDREN),
    value: None,
};

pub static WORD_DRN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ik")],
    values: &[&["drink"]],
    range: 2..=2,
};

static WORD_DRI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DRI_CHILDREN),
    value: None,
};

pub static WORD_DRI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("agram"),
        dictgen::InsensitiveStr::Ascii("agrammed"),
        dictgen::InsensitiveStr::Ascii("agramming"),
        dictgen::InsensitiveStr::Ascii("agrams"),
        dictgen::InsensitiveStr::Ascii("bbel"),
        dictgen::InsensitiveStr::Ascii("bbeld"),
        dictgen::InsensitiveStr::Ascii("bbeled"),
        dictgen::InsensitiveStr::Ascii("bbeling"),
        dictgen::InsensitiveStr::Ascii("bbels"),
        dictgen::InsensitiveStr::Ascii("ectly"),
        dictgen::InsensitiveStr::Ascii("ectx"),
        dictgen::InsensitiveStr::Ascii("fitng"),
        dictgen::InsensitiveStr::Ascii("ftig"),
        dictgen::InsensitiveStr::Ascii("nkes"),
        dictgen::InsensitiveStr::Ascii("ty"),
        dictgen::InsensitiveStr::Ascii("veable"),
        dictgen::InsensitiveStr::Ascii("veing"),
        dictgen::InsensitiveStr::Ascii("veris"),
        dictgen::InsensitiveStr::Ascii("vr"),
    ],
    values: &[
        &["diagram"],
        &["diagrammed"],
        &["diagramming"],
        &["diagrams"],
        &["dribble"],
        &["dribbled"],
        &["dribbled"],
        &["dribbling"],
        &["dribbles"],
        &["directly"],
        &["directx"],
        &["drifting"],
        &["drifting"],
        &["drinkers"],
        &["dirty"],
        &["drivable"],
        &["driving"],
        &["drivers"],
        &["driver"],
    ],
    range: 2..=9,
};

static WORD_DRF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DRF_CHILDREN),
    value: None,
};

pub static WORD_DRF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("iting")],
    values: &[&["drifting"]],
    range: 5..=5,
};

static WORD_DRE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DRE_CHILDREN),
    value: None,
};

pub static WORD_DRE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("asm"),
        dictgen::InsensitiveStr::Ascii("awn"),
        dictgen::InsensitiveStr::Ascii("gee"),
        dictgen::InsensitiveStr::Ascii("gees"),
        dictgen::InsensitiveStr::Ascii("gree"),
        dictgen::InsensitiveStr::Ascii("grees"),
        dictgen::InsensitiveStr::Ascii("scription"),
        dictgen::InsensitiveStr::Ascii("scriptions"),
    ],
    values: &[
        &["dreams"],
        &["drawn"],
        &["degree"],
        &["degrees"],
        &["degree"],
        &["degrees"],
        &["description"],
        &["descriptions"],
    ],
    range: 3..=10,
};

static WORD_DRA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DRA_CHILDREN),
    value: None,
};

pub static WORD_DRA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("clua"),
        dictgen::InsensitiveStr::Ascii("conain"),
        dictgen::InsensitiveStr::Ascii("cual"),
        dictgen::InsensitiveStr::Ascii("culea"),
        dictgen::InsensitiveStr::Ascii("culla"),
        dictgen::InsensitiveStr::Ascii("gable"),
        dictgen::InsensitiveStr::Ascii("ged"),
        dictgen::InsensitiveStr::Ascii("ging"),
        dictgen::InsensitiveStr::Ascii("gones"),
        dictgen::InsensitiveStr::Ascii("gonus"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("kest"),
        dictgen::InsensitiveStr::Ascii("maticaly"),
        dictgen::InsensitiveStr::Ascii("maticlly"),
        dictgen::InsensitiveStr::Ascii("mmatic"),
        dictgen::InsensitiveStr::Ascii("mmatically"),
        dictgen::InsensitiveStr::Ascii("mtic"),
        dictgen::InsensitiveStr::Ascii("n"),
        dictgen::InsensitiveStr::Ascii("nkenstein"),
        dictgen::InsensitiveStr::Ascii("sitcally"),
        dictgen::InsensitiveStr::Ascii("stical"),
        dictgen::InsensitiveStr::Ascii("sticaly"),
        dictgen::InsensitiveStr::Ascii("sticlly"),
        dictgen::InsensitiveStr::Ascii("ts"),
        dictgen::InsensitiveStr::Ascii("ughtman"),
        dictgen::InsensitiveStr::Ascii("vadian"),
        dictgen::InsensitiveStr::Ascii("view"),
        dictgen::InsensitiveStr::Ascii("wack"),
        dictgen::InsensitiveStr::Ascii("wacks"),
        dictgen::InsensitiveStr::Ascii("wed"),
        dictgen::InsensitiveStr::Ascii("wm"),
        dictgen::InsensitiveStr::Ascii("wng"),
    ],
    values: &[
        &["dracula"],
        &["draconian"],
        &["dracula"],
        &["dracula"],
        &["dracula"],
        &["draggable"],
        &["dragged"],
        &["dragging"],
        &["dragons"],
        &["dragons"],
        &["drawing"],
        &["darkest"],
        &["dramatically"],
        &["dramatically"],
        &["dramatic"],
        &["grammatically"],
        &["dramatic"],
        &["drawn"],
        &["frankenstein"],
        &["drastically"],
        &["drastically"],
        &["drastically"],
        &["drastically"],
        &["drafts"],
        &["draughtsman"],
        &["dravidian"],
        &["drawview"],
        &["drawback"],
        &["drawbacks"],
        &["drew", "drawn"],
        &["drawn"],
        &["drawing"],
    ],
    range: 1..=10,
};

static WORD_DP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DP_CHILDREN),
    value: None,
};

pub static WORD_DP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eends"),
        dictgen::InsensitiveStr::Ascii("endent"),
        dictgen::InsensitiveStr::Ascii("uble"),
        dictgen::InsensitiveStr::Ascii("ubles"),
    ],
    values: &[&["depends"], &["dependent"], &["double"], &["doubles"]],
    range: 4..=6,
};

static WORD_DO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_DO_CHILDREN),
    value: None,
};

static WORD_DO_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_DOA_NODE),
    Some(&WORD_DOB_NODE),
    Some(&WORD_DOC_NODE),
    None,
    Some(&WORD_DOE_NODE),
    None,
    Some(&WORD_DOG_NODE),
    None,
    Some(&WORD_DOI_NODE),
    None,
    Some(&WORD_DOK_NODE),
    Some(&WORD_DOL_NODE),
    Some(&WORD_DOM_NODE),
    Some(&WORD_DON_NODE),
    Some(&WORD_DOO_NODE),
    Some(&WORD_DOP_NODE),
    None,
    Some(&WORD_DOR_NODE),
    Some(&WORD_DOS_NODE),
    Some(&WORD_DOT_NODE),
    Some(&WORD_DOU_NODE),
    None,
    Some(&WORD_DOW_NODE),
    Some(&WORD_DOX_NODE),
    Some(&WORD_DOY_NODE),
    None,
];

static WORD_DOY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DOY_CHILDREN),
    value: None,
};

pub static WORD_DOY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("gen")],
    values: &[&["doxygen"]],
    range: 3..=3,
};

static WORD_DOX_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DOX_CHILDREN),
    value: None,
};

pub static WORD_DOX_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("gen")],
    values: &[&["doxygen"]],
    range: 3..=3,
};

static WORD_DOW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_DOW_CHILDREN),
    value: None,
};

static WORD_DOW_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_DOWG_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_DOWL_NODE),
    None,
    Some(&WORD_DOWN_NODE),
    None,
    None,
    None,
    Some(&WORD_DOWR_NODE),
    Some(&WORD_DOWS_NODE),
    Some(&WORD_DOWT_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_DOWT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DOWT_CHILDREN),
    value: Some(&["doubt"]),
};

pub static WORD_DOWT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[],
    values: &[],
    range: 0..=0,
};

static WORD_DOWS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DOWS_CHILDREN),
    value: Some(&["does"]),
};

pub static WORD_DOWS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[],
    values: &[],
    range: 0..=0,
};

static WORD_DOWR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DOWR_CHILDREN),
    value: None,
};

pub static WORD_DOWR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("d"),
        dictgen::InsensitiveStr::Ascii("ds"),
    ],
    values: &[&["dword"], &["dwords"]],
    range: 1..=2,
};

static WORD_DOWN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_DOWN_CHILDREN),
    value: None,
};

static WORD_DOWN_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_DOWNA_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_DOWNG_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_DOWNL_NODE),
    None,
    None,
    Some(&WORD_DOWNO_NODE),
    None,
    None,
    Some(&WORD_DOWNR_NODE),
    Some(&WORD_DOWNS_NODE),
    Some(&WORD_DOWNT_NODE),
    None,
    Some(&WORD_DOWNV_NODE),
    Some(&WORD_DOWNW_NODE),
    None,
    None,
    None,
];

static WORD_DOWNW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DOWNW_CHILDREN),
    value: None,
};

pub static WORD_DOWNW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("oters"),
        dictgen::InsensitiveStr::Ascii("oting"),
    ],
    values: &[&["downvoters"], &["downvoting"]],
    range: 5..=5,
};

static WORD_DOWNV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DOWNV_CHILDREN),
    value: None,
};

pub static WORD_DOWNV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("iting"),
        dictgen::InsensitiveStr::Ascii("ore"),
        dictgen::InsensitiveStr::Ascii("otear"),
        dictgen::InsensitiveStr::Ascii("oteas"),
        dictgen::InsensitiveStr::Ascii("oteds"),
        dictgen::InsensitiveStr::Ascii("oteers"),
        dictgen::InsensitiveStr::Ascii("otees"),
        dictgen::InsensitiveStr::Ascii("oteing"),
        dictgen::InsensitiveStr::Ascii("oteres"),
        dictgen::InsensitiveStr::Ascii("oteros"),
        dictgen::InsensitiveStr::Ascii("otesd"),
        dictgen::InsensitiveStr::Ascii("otess"),
        dictgen::InsensitiveStr::Ascii("otest"),
        dictgen::InsensitiveStr::Ascii("oteur"),
        dictgen::InsensitiveStr::Ascii("oteurs"),
        dictgen::InsensitiveStr::Ascii("oties"),
        dictgen::InsensitiveStr::Ascii("otr"),
        dictgen::InsensitiveStr::Ascii("otres"),
        dictgen::InsensitiveStr::Ascii("ots"),
        dictgen::InsensitiveStr::Ascii("otted"),
        dictgen::InsensitiveStr::Ascii("otters"),
        dictgen::InsensitiveStr::Ascii("ottes"),
        dictgen::InsensitiveStr::Ascii("otting"),
    ],
    values: &[
        &["downvoting"],
        &["downvoters"],
        &["downvoters"],
        &["downvoters"],
        &["downvoters"],
        &["downvoters"],
        &["downvoters"],
        &["downvoting"],
        &["downvoters"],
        &["downvoters"],
        &["downvoters"],
        &["downvoters"],
        &["downvoters"],
        &["downvoters"],
        &["downvoters"],
        &["downvoters"],
        &["downvoters"],
        &["downvoters"],
        &["downvotes"],
        &["downvote"],
        &["downvoters"],
        &["downvoters"],
        &["downvoting"],
    ],
    range: 3..=6,
};

static WORD_DOWNT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DOWNT_CHILDREN),
    value: None,
};

pub static WORD_DOWNT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("okers"),
        dictgen::InsensitiveStr::Ascii("oking"),
        dictgen::InsensitiveStr::Ascii("raded"),
    ],
    values: &[&["downvoters"], &["downvoting"], &["downgraded"]],
    range: 5..=5,
};

static WORD_DOWNS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DOWNS_CHILDREN),
    value: None,
};

pub static WORD_DOWNS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("iders"),
        dictgen::InsensitiveStr::Ascii("tar"),
        dictgen::InsensitiveStr::Ascii("taris"),
        dictgen::InsensitiveStr::Ascii("teram"),
        dictgen::InsensitiveStr::Ascii("teramed"),
        dictgen::InsensitiveStr::Ascii("teramer"),
        dictgen::InsensitiveStr::Ascii("teramers"),
        dictgen::InsensitiveStr::Ascii("teraming"),
        dictgen::InsensitiveStr::Ascii("terams"),
        dictgen::InsensitiveStr::Ascii("tiars"),
    ],
    values: &[
        &["downsides"],
        &["downstairs"],
        &["downstairs"],
        &["downstream"],
        &["downstreamed"],
        &["downstreamer"],
        &["downstreamers"],
        &["downstreaming"],
        &["downstreams"],
        &["downstairs"],
    ],
    range: 3..=8,
};

static WORD_DOWNR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DOWNR_CHILDREN),
    value: None,
};

pub static WORD_DOWNR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ade"),
        dictgen::InsensitiveStr::Ascii("aded"),
        dictgen::InsensitiveStr::Ascii("ades"),
        dictgen::InsensitiveStr::Ascii("ading"),
        dictgen::InsensitiveStr::Ascii("gade"),
        dictgen::InsensitiveStr::Ascii("gaded"),
        dictgen::InsensitiveStr::Ascii("gades"),
        dictgen::InsensitiveStr::Ascii("gading"),
        dictgen::InsensitiveStr::Ascii("oaded"),
    ],
    values: &[
        &["downgrade"],
        &["downgraded"],
        &["downgrades"],
        &["downgrading"],
        &["downgrade"],
        &["downgraded"],
        &["downgrades"],
        &["downgrading"],
        &["downgraded"],
    ],
    range: 3..=6,
};

static WORD_DOWNO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DOWNO_CHILDREN),
    value: None,
};

pub static WORD_DOWNO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ad"),
        dictgen::InsensitiveStr::Ascii("aded"),
        dictgen::InsensitiveStr::Ascii("ading"),
        dictgen::InsensitiveStr::Ascii("ads"),
        dictgen::InsensitiveStr::Ascii("load"),
        dictgen::InsensitiveStr::Ascii("loaded"),
        dictgen::InsensitiveStr::Ascii("loading"),
        dictgen::InsensitiveStr::Ascii("loads"),
        dictgen::InsensitiveStr::Ascii("vted"),
        dictgen::InsensitiveStr::Ascii("vting"),
    ],
    values: &[
        &["download"],
        &["downloaded"],
        &["downloading"],
        &["downloads"],
        &["download"],
        &["downloaded"],
        &["downloading"],
        &["downloads"],
        &["downvoted"],
        &["downvoting"],
    ],
    range: 2..=7,
};

static WORD_DOWNL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DOWNL_CHILDREN),
    value: None,
};

pub static WORD_DOWNL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ad"),
        dictgen::InsensitiveStr::Ascii("aded"),
        dictgen::InsensitiveStr::Ascii("ading"),
        dictgen::InsensitiveStr::Ascii("ads"),
        dictgen::InsensitiveStr::Ascii("aod"),
        dictgen::InsensitiveStr::Ascii("aodable"),
        dictgen::InsensitiveStr::Ascii("aoded"),
        dictgen::InsensitiveStr::Ascii("aodes"),
        dictgen::InsensitiveStr::Ascii("aoding"),
        dictgen::InsensitiveStr::Ascii("aods"),
        dictgen::InsensitiveStr::Ascii("oaad"),
        dictgen::InsensitiveStr::Ascii("oadas"),
        dictgen::InsensitiveStr::Ascii("oadbale"),
        dictgen::InsensitiveStr::Ascii("oadbel"),
        dictgen::InsensitiveStr::Ascii("oadbig"),
        dictgen::InsensitiveStr::Ascii("oadble"),
        dictgen::InsensitiveStr::Ascii("oadeble"),
        dictgen::InsensitiveStr::Ascii("oades"),
        dictgen::InsensitiveStr::Ascii("oadmanger"),
        dictgen::InsensitiveStr::Ascii("oas"),
        dictgen::InsensitiveStr::Ascii("od"),
        dictgen::InsensitiveStr::Ascii("oded"),
        dictgen::InsensitiveStr::Ascii("oding"),
        dictgen::InsensitiveStr::Ascii("ods"),
        dictgen::InsensitiveStr::Ascii("ond"),
        dictgen::InsensitiveStr::Ascii("owd"),
        dictgen::InsensitiveStr::Ascii("owded"),
        dictgen::InsensitiveStr::Ascii("owding"),
        dictgen::InsensitiveStr::Ascii("owds"),
    ],
    values: &[
        &["download"],
        &["downloaded"],
        &["downloading"],
        &["downloads"],
        &["download"],
        &["downloadable"],
        &["downloaded"],
        &["downloads"],
        &["downloading"],
        &["downloads"],
        &["download"],
        &["downloads"],
        &["downloadable"],
        &["downloadable"],
        &["downloading"],
        &["downloadable"],
        &["downloadable"],
        &["downloads"],
        &["downloadmanager"],
        &["downloads"],
        &["download"],
        &["downloaded"],
        &["downloading"],
        &["downloads"],
        &["download"],
        &["download"],
        &["downloaded"],
        &["downloading"],
        &["downloads"],
    ],
    range: 2..=9,
};

static WORD_DOWNG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DOWNG_CHILDREN),
    value: None,
};

pub static WORD_DOWNG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ade"),
        dictgen::InsensitiveStr::Ascii("aded"),
        dictgen::InsensitiveStr::Ascii("ades"),
        dictgen::InsensitiveStr::Ascii("ading"),
        dictgen::InsensitiveStr::Ascii("arade"),
        dictgen::InsensitiveStr::Ascii("araded"),
        dictgen::InsensitiveStr::Ascii("arades"),
        dictgen::InsensitiveStr::Ascii("arading"),
        dictgen::InsensitiveStr::Ascii("arde"),
        dictgen::InsensitiveStr::Ascii("arded"),
        dictgen::InsensitiveStr::Ascii("ardes"),
        dictgen::InsensitiveStr::Ascii("arding"),
        dictgen::InsensitiveStr::Ascii("arte"),
        dictgen::InsensitiveStr::Ascii("arted"),
        dictgen::InsensitiveStr::Ascii("artes"),
        dictgen::InsensitiveStr::Ascii("arting"),
        dictgen::InsensitiveStr::Ascii("radde"),
        dictgen::InsensitiveStr::Ascii("radded"),
        dictgen::InsensitiveStr::Ascii("raddes"),
        dictgen::InsensitiveStr::Ascii("radding"),
        dictgen::InsensitiveStr::Ascii("radei"),
        dictgen::InsensitiveStr::Ascii("radingn"),
        dictgen::InsensitiveStr::Ascii("rate"),
        dictgen::InsensitiveStr::Ascii("rated"),
        dictgen::InsensitiveStr::Ascii("rates"),
        dictgen::InsensitiveStr::Ascii("rating"),
    ],
    values: &[
        &["downgrade"],
        &["downgraded"],
        &["downgrades"],
        &["downgrading"],
        &["downgrade"],
        &["downgraded"],
        &["downgrades"],
        &["downgrading"],
        &["downgrade"],
        &["downgraded"],
        &["downgrades"],
        &["downgrading"],
        &["downgrade"],
        &["downgraded"],
        &["downgrades"],
        &["downgrading"],
        &["downgrade"],
        &["downgraded"],
        &["downgrades"],
        &["downgrading"],
        &["downgrade"],
        &["downgrading"],
        &["downgrade"],
        &["downgrade", "downgraded"],
        &["downgrades"],
        &["downgrading"],
    ],
    range: 3..=7,
};

static WORD_DOWNA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DOWNA_CHILDREN),
    value: None,
};

pub static WORD_DOWNA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("grade"),
        dictgen::InsensitiveStr::Ascii("graded"),
        dictgen::InsensitiveStr::Ascii("grades"),
        dictgen::InsensitiveStr::Ascii("grading"),
    ],
    values: &[
        &["downgrade"],
        &["downgraded"],
        &["downgrades"],
        &["downgrading"],
    ],
    range: 5..=7,
};

static WORD_DOWL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DOWL_CHILDREN),
    value: None,
};

pub static WORD_DOWL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ink"),
        dictgen::InsensitiveStr::Ascii("inks"),
        dictgen::InsensitiveStr::Ascii("oad"),
        dictgen::InsensitiveStr::Ascii("oaded"),
        dictgen::InsensitiveStr::Ascii("oader"),
        dictgen::InsensitiveStr::Ascii("oaders"),
        dictgen::InsensitiveStr::Ascii("oading"),
        dictgen::InsensitiveStr::Ascii("oads"),
    ],
    values: &[
        &["downlink"],
        &["downlinks"],
        &["download"],
        &["downloaded"],
        &["downloader"],
        &["downloaders"],
        &["downloading"],
        &["downloads"],
    ],
    range: 3..=6,
};

static WORD_DOWG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DOWG_CHILDREN),
    value: None,
};

pub static WORD_DOWG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("rade")],
    values: &[&["downgrade"]],
    range: 4..=4,
};

static WORD_DOU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DOU_CHILDREN),
    value: None,
};

pub static WORD_DOU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("b"),
        dictgen::InsensitiveStr::Ascii("be"),
        dictgen::InsensitiveStr::Ascii("bel"),
        dictgen::InsensitiveStr::Ascii("bellift"),
        dictgen::InsensitiveStr::Ascii("bely"),
        dictgen::InsensitiveStr::Ascii("bes"),
        dictgen::InsensitiveStr::Ascii("blde"),
        dictgen::InsensitiveStr::Ascii("blded"),
        dictgen::InsensitiveStr::Ascii("bldes"),
        dictgen::InsensitiveStr::Ascii("bleiift"),
        dictgen::InsensitiveStr::Ascii("bleleft"),
        dictgen::InsensitiveStr::Ascii("blelfit"),
        dictgen::InsensitiveStr::Ascii("blelit"),
        dictgen::InsensitiveStr::Ascii("blellift"),
        dictgen::InsensitiveStr::Ascii("blely"),
        dictgen::InsensitiveStr::Ascii("blerift"),
        dictgen::InsensitiveStr::Ascii("bletquote"),
        dictgen::InsensitiveStr::Ascii("bth"),
        dictgen::InsensitiveStr::Ascii("bthed"),
        dictgen::InsensitiveStr::Ascii("bthing"),
        dictgen::InsensitiveStr::Ascii("bths"),
        dictgen::InsensitiveStr::Ascii("cehbag"),
        dictgen::InsensitiveStr::Ascii("chely"),
        dictgen::InsensitiveStr::Ascii("cheus"),
        dictgen::InsensitiveStr::Ascii("cment"),
        dictgen::InsensitiveStr::Ascii("cmentated"),
        dictgen::InsensitiveStr::Ascii("cmentation"),
        dictgen::InsensitiveStr::Ascii("cmented"),
        dictgen::InsensitiveStr::Ascii("cmenter"),
        dictgen::InsensitiveStr::Ascii("cmenters"),
        dictgen::InsensitiveStr::Ascii("cmentes"),
        dictgen::InsensitiveStr::Ascii("cmenting"),
        dictgen::InsensitiveStr::Ascii("cments"),
        dictgen::InsensitiveStr::Ascii("ible"),
        dictgen::InsensitiveStr::Ascii("ibled"),
        dictgen::InsensitiveStr::Ascii("lbe"),
        dictgen::InsensitiveStr::Ascii("lbelift"),
        dictgen::InsensitiveStr::Ascii("mentation"),
        dictgen::InsensitiveStr::Ascii("mentc"),
        dictgen::InsensitiveStr::Ascii("t"),
    ],
    values: &[
        &["doubt", "daub"],
        &["double"],
        &["double"],
        &["doublelift"],
        &["doubly"],
        &["doubles"],
        &["double"],
        &["doubled"],
        &["doubles"],
        &["doublelift"],
        &["doublelift"],
        &["doublelift"],
        &["doublelift"],
        &["doublelift"],
        &["doubly"],
        &["doublelift"],
        &["doublequote"],
        &["doubt"],
        &["doubted"],
        &["doubting"],
        &["doubts"],
        &["douchebag"],
        &["douchey"],
        &["douches"],
        &["document"],
        &["documented"],
        &["documentation"],
        &["documented"],
        &["documenter"],
        &["documenters"],
        &["documents"],
        &["documenting"],
        &["documents"],
        &["double"],
        &["doubled"],
        &["double"],
        &["doublelift"],
        &["documentation"],
        &["document"],
        &["doubt"],
    ],
    range: 1..=10,
};

static WORD_DOT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DOT_CHILDREN),
    value: None,
};

pub static WORD_DOT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("a"),
        dictgen::InsensitiveStr::Ascii("rmund"),
    ],
    values: &[&["data"], &["dortmund"]],
    range: 1..=5,
};

static WORD_DOS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DOS_CHILDREN),
    value: None,
};

pub static WORD_DOS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("closed"),
        dictgen::InsensitiveStr::Ascii("closes"),
        dictgen::InsensitiveStr::Ascii("closing"),
        dictgen::InsensitiveStr::Ascii("closure"),
        dictgen::InsensitiveStr::Ascii("closures"),
        dictgen::InsensitiveStr::Ascii("en"),
        dictgen::InsensitiveStr::Ascii("ens"),
        dictgen::InsensitiveStr::Ascii("posing"),
        dictgen::InsensitiveStr::Ascii("sapointed"),
        dictgen::InsensitiveStr::Ascii("seay"),
        dictgen::InsensitiveStr::Ascii("seays"),
        dictgen::InsensitiveStr::Ascii("ument"),
        dictgen::InsensitiveStr::Ascii("uments"),
    ],
    values: &[
        &["disclosed"],
        &["discloses"],
        &["disclosing"],
        &["disclosure"],
        &["disclosures"],
        &["dozen", "dose", "doesn"],
        &["dozens"],
        &["disposing"],
        &["disappointed"],
        &["dossier"],
        &["dossiers"],
        &["document"],
        &["documents"],
    ],
    range: 2..=9,
};

static WORD_DOR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DOR_CHILDREN),
    value: None,
};

pub static WORD_DOR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ce"),
        dictgen::InsensitiveStr::Ascii("ced"),
        dictgen::InsensitiveStr::Ascii("ceful"),
        dictgen::InsensitiveStr::Ascii("der"),
        dictgen::InsensitiveStr::Ascii("dered"),
        dictgen::InsensitiveStr::Ascii("ment"),
        dictgen::InsensitiveStr::Ascii("mtund"),
        dictgen::InsensitiveStr::Ascii("p"),
        dictgen::InsensitiveStr::Ascii("tmud"),
        dictgen::InsensitiveStr::Ascii("tumnd"),
    ],
    values: &[
        &["force"],
        &["forced"],
        &["forceful"],
        &["order", "disorder"],
        &["ordered"],
        &["dormant"],
        &["dortmund"],
        &["drop"],
        &["dortmund"],
        &["dortmund"],
    ],
    range: 1..=5,
};

static WORD_DOP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DOP_CHILDREN),
    value: None,
};

pub static WORD_DOP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("lhin"),
        dictgen::InsensitiveStr::Ascii("lhins"),
        dictgen::InsensitiveStr::Ascii("maine"),
    ],
    values: &[&["dolphin"], &["dolphins"], &["dopamine"]],
    range: 4..=5,
};

static WORD_DOO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DOO_CHILDREN),
    value: None,
};

pub static WORD_DOO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cument"),
        dictgen::InsensitiveStr::Ascii("cumentaries"),
        dictgen::InsensitiveStr::Ascii("cumentary"),
        dictgen::InsensitiveStr::Ascii("cumentation"),
        dictgen::InsensitiveStr::Ascii("cumentations"),
        dictgen::InsensitiveStr::Ascii("cumented"),
        dictgen::InsensitiveStr::Ascii("cumenting"),
        dictgen::InsensitiveStr::Ascii("cuments"),
        dictgen::InsensitiveStr::Ascii("mdsay"),
        dictgen::InsensitiveStr::Ascii("msdaily"),
        dictgen::InsensitiveStr::Ascii("rjam"),
        dictgen::InsensitiveStr::Ascii("smday"),
    ],
    values: &[
        &["document"],
        &["documentaries"],
        &["documentary"],
        &["documentation"],
        &["documentations"],
        &["documented"],
        &["documenting"],
        &["documents"],
        &["doomsday"],
        &["doomsday"],
        &["doorjamb"],
        &["doomsday"],
    ],
    range: 4..=12,
};

static WORD_DON_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DON_CHILDREN),
    value: None,
};

pub static WORD_DON_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ain"),
        dictgen::InsensitiveStr::Ascii("ains"),
        dictgen::InsensitiveStr::Ascii("ejun"),
        dictgen::InsensitiveStr::Ascii("ejuns"),
        dictgen::InsensitiveStr::Ascii("esticated"),
        dictgen::InsensitiveStr::Ascii("ig"),
        dictgen::InsensitiveStr::Ascii("n"),
        dictgen::InsensitiveStr::Ascii("wgrade"),
        dictgen::InsensitiveStr::Ascii("wgraded"),
        dictgen::InsensitiveStr::Ascii("wload"),
        dictgen::InsensitiveStr::Ascii("wloadable"),
        dictgen::InsensitiveStr::Ascii("wloaded"),
        dictgen::InsensitiveStr::Ascii("wloading"),
        dictgen::InsensitiveStr::Ascii("wloads"),
        dictgen::InsensitiveStr::Ascii("wsides"),
        dictgen::InsensitiveStr::Ascii("wvote"),
        dictgen::InsensitiveStr::Ascii("wvoted"),
        dictgen::InsensitiveStr::Ascii("wvoters"),
        dictgen::InsensitiveStr::Ascii("wvotes"),
        dictgen::InsensitiveStr::Ascii("wvoting"),
    ],
    values: &[
        &["domain"],
        &["domains"],
        &["dungeon"],
        &["dungeons"],
        &["domesticated"],
        &["doing"],
        &["done", "don"],
        &["downgrade"],
        &["downgraded"],
        &["download"],
        &["downloadable"],
        &["downloaded"],
        &["downloading"],
        &["downloads"],
        &["downsides"],
        &["downvote"],
        &["downvoted"],
        &["downvoters"],
        &["downvotes"],
        &["downvoting"],
    ],
    range: 1..=9,
};

static WORD_DOM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DOM_CHILDREN),
    value: None,
};

pub static WORD_DOM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ait"),
        dictgen::InsensitiveStr::Ascii("an"),
        dictgen::InsensitiveStr::Ascii("ans"),
        dictgen::InsensitiveStr::Ascii("apine"),
        dictgen::InsensitiveStr::Ascii("ecracy"),
        dictgen::InsensitiveStr::Ascii("ecrat"),
        dictgen::InsensitiveStr::Ascii("ecrats"),
        dictgen::InsensitiveStr::Ascii("ension"),
        dictgen::InsensitiveStr::Ascii("ensions"),
        dictgen::InsensitiveStr::Ascii("esitcated"),
        dictgen::InsensitiveStr::Ascii("esticted"),
        dictgen::InsensitiveStr::Ascii("ian"),
        dictgen::InsensitiveStr::Ascii("ians"),
        dictgen::InsensitiveStr::Ascii("iante"),
        dictgen::InsensitiveStr::Ascii("iantes"),
        dictgen::InsensitiveStr::Ascii("ianting"),
        dictgen::InsensitiveStr::Ascii("imation"),
        dictgen::InsensitiveStr::Ascii("inacion"),
        dictgen::InsensitiveStr::Ascii("inante"),
        dictgen::InsensitiveStr::Ascii("inanted"),
        dictgen::InsensitiveStr::Ascii("inantes"),
        dictgen::InsensitiveStr::Ascii("inanting"),
        dictgen::InsensitiveStr::Ascii("inantion"),
        dictgen::InsensitiveStr::Ascii("inaters"),
        dictgen::InsensitiveStr::Ascii("inateurs"),
        dictgen::InsensitiveStr::Ascii("inatin"),
        dictgen::InsensitiveStr::Ascii("inationg"),
        dictgen::InsensitiveStr::Ascii("inato"),
        dictgen::InsensitiveStr::Ascii("inaton"),
        dictgen::InsensitiveStr::Ascii("inats"),
        dictgen::InsensitiveStr::Ascii("inent"),
        dictgen::InsensitiveStr::Ascii("iniant"),
        dictgen::InsensitiveStr::Ascii("inno"),
        dictgen::InsensitiveStr::Ascii("inoin"),
        dictgen::InsensitiveStr::Ascii("isticated"),
        dictgen::InsensitiveStr::Ascii("onstrate"),
        dictgen::InsensitiveStr::Ascii("onstrates"),
        dictgen::InsensitiveStr::Ascii("onstrating"),
        dictgen::InsensitiveStr::Ascii("onstration"),
        dictgen::InsensitiveStr::Ascii("onstrations"),
    ],
    values: &[
        &["domain"],
        &["domain"],
        &["domains"],
        &["dopamine"],
        &["democracy"],
        &["democrat"],
        &["democrats"],
        &["dimension"],
        &["dimensions"],
        &["domesticated"],
        &["domesticated"],
        &["domain"],
        &["domains"],
        &["dominate"],
        &["dominates"],
        &["dominating"],
        &["domination"],
        &["domination"],
        &["dominant", "dominate"],
        &["dominated"],
        &["dominants", "dominates"],
        &["dominating"],
        &["domination"],
        &["dominates"],
        &["dominates"],
        &["domination"],
        &["dominating"],
        &["domination"],
        &["domination"],
        &["dominates"],
        &["dominant"],
        &["dominant"],
        &["dominion"],
        &["dominion"],
        &["domesticated"],
        &["demonstrate"],
        &["demonstrates"],
        &["demonstrating"],
        &["demonstration"],
        &["demonstrations"],
    ],
    range: 2..=11,
};

static WORD_DOL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DOL_CHILDREN),
    value: None,
};

pub static WORD_DOL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("hpin"),
        dictgen::InsensitiveStr::Ascii("hpins"),
        dictgen::InsensitiveStr::Ascii("ler"),
        dictgen::InsensitiveStr::Ascii("lers"),
        dictgen::InsensitiveStr::Ascii("lor"),
        dictgen::InsensitiveStr::Ascii("lors"),
        dictgen::InsensitiveStr::Ascii("phines"),
        dictgen::InsensitiveStr::Ascii("phinese"),
        dictgen::InsensitiveStr::Ascii("phis"),
    ],
    values: &[
        &["dolphin"],
        &["dolphins"],
        &["dollar"],
        &["dollars"],
        &["dollar"],
        &["dollars"],
        &["dolphins"],
        &["dolphins"],
        &["dolphins"],
    ],
    range: 3..=7,
};

static WORD_DOK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DOK_CHILDREN),
    value: None,
};

pub static WORD_DOK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("c"),
        dictgen::InsensitiveStr::Ascii("ced"),
        dictgen::InsensitiveStr::Ascii("cer"),
        dictgen::InsensitiveStr::Ascii("cerd"),
        dictgen::InsensitiveStr::Ascii("cing"),
        dictgen::InsensitiveStr::Ascii("cre"),
        dictgen::InsensitiveStr::Ascii("cred"),
        dictgen::InsensitiveStr::Ascii("cs"),
        dictgen::InsensitiveStr::Ascii("er"),
    ],
    values: &[
        &["dock"],
        &["docked"],
        &["docker"],
        &["dockerd", "docked", "docker"],
        &["docking"],
        &["docker"],
        &["dockerd", "docked", "docker"],
        &["docks"],
        &["docker"],
    ],
    range: 1..=4,
};

static WORD_DOI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DOI_CHILDREN),
    value: None,
};

pub static WORD_DOI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("gn"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("uble"),
        dictgen::InsensitiveStr::Ascii("ubled"),
    ],
    values: &[&["doing"], &["doing"], &["double"], &["doubled"]],
    range: 2..=5,
};

static WORD_DOG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DOG_CHILDREN),
    value: None,
};

pub static WORD_DOG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("amtic"),
        dictgen::InsensitiveStr::Ascii("dammit"),
        dictgen::InsensitiveStr::Ascii("ders"),
        dictgen::InsensitiveStr::Ascii("ding"),
        dictgen::InsensitiveStr::Ascii("father"),
        dictgen::InsensitiveStr::Ascii("matisch"),
    ],
    values: &[
        &["dogmatic"],
        &["goddammit"],
        &["dodgers"],
        &["dodging"],
        &["godfather"],
        &["dogmatic"],
    ],
    range: 4..=7,
};

static WORD_DOE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DOE_CHILDREN),
    value: None,
};

pub static WORD_DOE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("d"),
        dictgen::InsensitiveStr::Ascii("n"),
        dictgen::InsensitiveStr::Ascii("ns"),
        dictgen::InsensitiveStr::Ascii("se"),
        dictgen::InsensitiveStr::Ascii("sing"),
        dictgen::InsensitiveStr::Ascii("ss"),
    ],
    values: &[
        &["does"],
        &["done", "don", "doesn"],
        &["does", "doesn"],
        &["does"],
        &["doing", "does", "dosing", "dozing"],
        &["does"],
    ],
    range: 1..=4,
};

static WORD_DOC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_DOC_CHILDREN),
    value: None,
};

static WORD_DOC_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    Some(&WORD_DOCC_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_DOCK_NODE),
    None,
    Some(&WORD_DOCM_NODE),
    None,
    Some(&WORD_DOCO_NODE),
    None,
    None,
    Some(&WORD_DOCR_NODE),
    Some(&WORD_DOCS_NODE),
    Some(&WORD_DOCT_NODE),
    Some(&WORD_DOCU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_DOCU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_DOCU_CHILDREN),
    value: None,
};

static WORD_DOCU_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    Some(&WORD_DOCUC_NODE),
    None,
    Some(&WORD_DOCUE_NODE),
    None,
    None,
    Some(&WORD_DOCUH_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_DOCUM_NODE),
    Some(&WORD_DOCUN_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_DOCUN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DOCUN_CHILDREN),
    value: None,
};

pub static WORD_DOCUN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ment")],
    values: &[&["document"]],
    range: 4..=4,
};

static WORD_DOCUM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DOCUM_CHILDREN),
    value: None,
};

pub static WORD_DOCUM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ant"),
        dictgen::InsensitiveStr::Ascii("antaries"),
        dictgen::InsensitiveStr::Ascii("antary"),
        dictgen::InsensitiveStr::Ascii("antation"),
        dictgen::InsensitiveStr::Ascii("ants"),
        dictgen::InsensitiveStr::Ascii("ation"),
        dictgen::InsensitiveStr::Ascii("emt"),
        dictgen::InsensitiveStr::Ascii("en"),
        dictgen::InsensitiveStr::Ascii("enatation"),
        dictgen::InsensitiveStr::Ascii("enation"),
        dictgen::InsensitiveStr::Ascii("enatries"),
        dictgen::InsensitiveStr::Ascii("enatry"),
        dictgen::InsensitiveStr::Ascii("ened"),
        dictgen::InsensitiveStr::Ascii("enet"),
        dictgen::InsensitiveStr::Ascii("enetation"),
        dictgen::InsensitiveStr::Ascii("eneted"),
        dictgen::InsensitiveStr::Ascii("eneter"),
        dictgen::InsensitiveStr::Ascii("eneters"),
        dictgen::InsensitiveStr::Ascii("eneting"),
        dictgen::InsensitiveStr::Ascii("enets"),
        dictgen::InsensitiveStr::Ascii("entacion"),
        dictgen::InsensitiveStr::Ascii("entaion"),
        dictgen::InsensitiveStr::Ascii("entaire"),
        dictgen::InsensitiveStr::Ascii("entaires"),
        dictgen::InsensitiveStr::Ascii("entaiton"),
        dictgen::InsensitiveStr::Ascii("entare"),
        dictgen::InsensitiveStr::Ascii("entarios"),
        dictgen::InsensitiveStr::Ascii("entarse"),
        dictgen::InsensitiveStr::Ascii("entarsi"),
        dictgen::InsensitiveStr::Ascii("entataion"),
        dictgen::InsensitiveStr::Ascii("entataions"),
        dictgen::InsensitiveStr::Ascii("entatation"),
        dictgen::InsensitiveStr::Ascii("entaties"),
        dictgen::InsensitiveStr::Ascii("entating"),
        dictgen::InsensitiveStr::Ascii("entato"),
        dictgen::InsensitiveStr::Ascii("entaton"),
        dictgen::InsensitiveStr::Ascii("enteries"),
        dictgen::InsensitiveStr::Ascii("entery"),
        dictgen::InsensitiveStr::Ascii("entes"),
        dictgen::InsensitiveStr::Ascii("entiation"),
        dictgen::InsensitiveStr::Ascii("ention"),
        dictgen::InsensitiveStr::Ascii("entories"),
        dictgen::InsensitiveStr::Ascii("entory"),
        dictgen::InsensitiveStr::Ascii("entry"),
        dictgen::InsensitiveStr::Ascii("etation"),
        dictgen::InsensitiveStr::Ascii("etn"),
        dictgen::InsensitiveStr::Ascii("etnation"),
        dictgen::InsensitiveStr::Ascii("ment"),
        dictgen::InsensitiveStr::Ascii("ments"),
        dictgen::InsensitiveStr::Ascii("net"),
        dictgen::InsensitiveStr::Ascii("netation"),
        dictgen::InsensitiveStr::Ascii("ument"),
    ],
    values: &[
        &["document"],
        &["documentaries"],
        &["documentary"],
        &["documentation"],
        &["documents"],
        &["documentation"],
        &["document"],
        &["document"],
        &["documentation"],
        &["documentation"],
        &["documentaries"],
        &["documentary"],
        &["documented"],
        &["document"],
        &["documentation"],
        &["documented"],
        &["documenter"],
        &["documenters"],
        &["documenting"],
        &["documents"],
        &["documentation"],
        &["documentation"],
        &["documentaries"],
        &["documentaries"],
        &["documentation"],
        &["documentaries"],
        &["documentaries"],
        &["documentaries"],
        &["documentaries"],
        &["documentation"],
        &["documentations"],
        &["documentation"],
        &["documentaries"],
        &["documentation"],
        &["documentation"],
        &["documentation"],
        &["documentaries"],
        &["documentary"],
        &["documents"],
        &["documentation"],
        &["documentation"],
        &["documentaries"],
        &["documentary"],
        &["documentary"],
        &["documentation"],
        &["document"],
        &["documentation"],
        &["document"],
        &["documents"],
        &["document"],
        &["documentation"],
        &["document"],
    ],
    range: 2..=10,
};

static WORD_DOCUH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DOCUH_CHILDREN),
    value: None,
};

pub static WORD_DOCUH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ebag"),
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("ey"),
    ],
    values: &[&["douchebag"], &["douches"], &["douchey"]],
    range: 2..=4,
};

static WORD_DOCUE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DOCUE_CHILDREN),
    value: None,
};

pub static WORD_DOCUE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ment"),
        dictgen::InsensitiveStr::Ascii("ments"),
        dictgen::InsensitiveStr::Ascii("mnt"),
        dictgen::InsensitiveStr::Ascii("mnts"),
        dictgen::InsensitiveStr::Ascii("mtn"),
        dictgen::InsensitiveStr::Ascii("mtnation"),
        dictgen::InsensitiveStr::Ascii("mtned"),
        dictgen::InsensitiveStr::Ascii("mtning"),
        dictgen::InsensitiveStr::Ascii("mtns"),
        dictgen::InsensitiveStr::Ascii("nt"),
        dictgen::InsensitiveStr::Ascii("ntation"),
    ],
    values: &[
        &["document"],
        &["documents"],
        &["document"],
        &["documents"],
        &["document"],
        &["documentation"],
        &["documented"],
        &["documenting"],
        &["documents"],
        &["document"],
        &["documentation"],
    ],
    range: 2..=8,
};

static WORD_DOCUC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DOCUC_CHILDREN),
    value: None,
};

pub static WORD_DOCUC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ument")],
    values: &[&["document"]],
    range: 5..=5,
};

static WORD_DOCT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DOCT_CHILDREN),
    value: None,
};

pub static WORD_DOCT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ines"),
        dictgen::InsensitiveStr::Ascii("irne"),
        dictgen::InsensitiveStr::Ascii("orial"),
        dictgen::InsensitiveStr::Ascii("rins"),
    ],
    values: &[&["doctrines"], &["doctrine"], &["doctoral"], &["doctrines"]],
    range: 4..=5,
};

static WORD_DOCS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DOCS_CHILDREN),
    value: None,
};

pub static WORD_DOCS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("tatistik"),
        dictgen::InsensitiveStr::Ascii("und"),
    ],
    values: &[&["docstatistic"], &["dachshund"]],
    range: 3..=8,
};

static WORD_DOCR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DOCR_CHILDREN),
    value: None,
};

pub static WORD_DOCR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ines"),
        dictgen::InsensitiveStr::Ascii("tine"),
        dictgen::InsensitiveStr::Ascii("tines"),
    ],
    values: &[&["doctrines"], &["doctrine"], &["doctrines"]],
    range: 4..=5,
};

static WORD_DOCO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DOCO_CHILDREN),
    value: None,
};

pub static WORD_DOCO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ment"),
        dictgen::InsensitiveStr::Ascii("mentation"),
        dictgen::InsensitiveStr::Ascii("mented"),
        dictgen::InsensitiveStr::Ascii("menting"),
        dictgen::InsensitiveStr::Ascii("ments"),
    ],
    values: &[
        &["document"],
        &["documentation"],
        &["documented"],
        &["documenting"],
        &["documents"],
    ],
    range: 4..=9,
};

static WORD_DOCM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DOCM_CHILDREN),
    value: None,
};

pub static WORD_DOCM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("enetation"),
        dictgen::InsensitiveStr::Ascii("uent"),
        dictgen::InsensitiveStr::Ascii("unet"),
        dictgen::InsensitiveStr::Ascii("unetation"),
        dictgen::InsensitiveStr::Ascii("uneted"),
        dictgen::InsensitiveStr::Ascii("uneting"),
        dictgen::InsensitiveStr::Ascii("unets"),
    ],
    values: &[
        &["documentation"],
        &["document"],
        &["document"],
        &["documentation"],
        &["documented"],
        &["documenting"],
        &["documents"],
    ],
    range: 4..=9,
};

static WORD_DOCK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DOCK_CHILDREN),
    value: None,
};

pub static WORD_DOCK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("son")],
    values: &[&["dachshund"]],
    range: 3..=3,
};

static WORD_DOCC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DOCC_CHILDREN),
    value: None,
};

pub static WORD_DOCC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ument"),
        dictgen::InsensitiveStr::Ascii("umented"),
        dictgen::InsensitiveStr::Ascii("uments"),
    ],
    values: &[&["document"], &["documented"], &["documents"]],
    range: 5..=7,
};

static WORD_DOB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DOB_CHILDREN),
    value: None,
};

pub static WORD_DOB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("le"),
        dictgen::InsensitiveStr::Ascii("led"),
        dictgen::InsensitiveStr::Ascii("les"),
        dictgen::InsensitiveStr::Ascii("ling"),
        dictgen::InsensitiveStr::Ascii("ulelift"),
    ],
    values: &[
        &["double"],
        &["doubled"],
        &["doubles"],
        &["doubling"],
        &["doublelift"],
    ],
    range: 2..=7,
};

static WORD_DOA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DOA_CHILDREN),
    value: None,
};

pub static WORD_DOA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("gonal"),
        dictgen::InsensitiveStr::Ascii("gonals"),
        dictgen::InsensitiveStr::Ascii("log"),
        dictgen::InsensitiveStr::Ascii("min"),
        dictgen::InsensitiveStr::Ascii("mine"),
        dictgen::InsensitiveStr::Ascii("mins"),
        dictgen::InsensitiveStr::Ascii("pmine"),
        dictgen::InsensitiveStr::Ascii("s"),
    ],
    values: &[
        &["diagonal"],
        &["diagonals"],
        &["dialog"],
        &["domain", "dopamine"],
        &["dopamine", "domain"],
        &["domains"],
        &["dopamine"],
        &["does"],
    ],
    range: 1..=6,
};

static WORD_DN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DN_CHILDREN),
    value: None,
};

pub static WORD_DN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("amically"),
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("ymaic"),
    ],
    values: &[&["dynamically"], &["done"], &["dynamic"]],
    range: 1..=8,
};

static WORD_DL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DL_CHILDREN),
    value: None,
};

pub static WORD_DL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("oating")],
    values: &[&["floating"]],
    range: 6..=6,
};

static WORD_DI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_DI_CHILDREN),
    value: None,
};

static WORD_DI_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_DIA_NODE),
    None,
    Some(&WORD_DIC_NODE),
    Some(&WORD_DID_NODE),
    Some(&WORD_DIE_NODE),
    Some(&WORD_DIF_NODE),
    Some(&WORD_DIG_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_DIL_NODE),
    Some(&WORD_DIM_NODE),
    Some(&WORD_DIN_NODE),
    Some(&WORD_DIO_NODE),
    Some(&WORD_DIP_NODE),
    None,
    Some(&WORD_DIR_NODE),
    Some(&WORD_DIS_NODE),
    Some(&WORD_DIT_NODE),
    None,
    Some(&WORD_DIV_NODE),
    None,
    None,
    None,
    None,
];

static WORD_DIV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DIV_CHILDREN),
    value: None,
};

pub static WORD_DIV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("de"),
        dictgen::InsensitiveStr::Ascii("ded"),
        dictgen::InsensitiveStr::Ascii("des"),
        dictgen::InsensitiveStr::Ascii("ding"),
        dictgen::InsensitiveStr::Ascii("erisfy"),
        dictgen::InsensitiveStr::Ascii("eristy"),
        dictgen::InsensitiveStr::Ascii("ersed"),
        dictgen::InsensitiveStr::Ascii("ersifiy"),
        dictgen::InsensitiveStr::Ascii("ersiy"),
        dictgen::InsensitiveStr::Ascii("erstiy"),
        dictgen::InsensitiveStr::Ascii("ertion"),
        dictgen::InsensitiveStr::Ascii("ertions"),
        dictgen::InsensitiveStr::Ascii("et"),
        dictgen::InsensitiveStr::Ascii("iation"),
        dictgen::InsensitiveStr::Ascii("ice"),
        dictgen::InsensitiveStr::Ascii("icer"),
        dictgen::InsensitiveStr::Ascii("idendes"),
        dictgen::InsensitiveStr::Ascii("idendos"),
        dictgen::InsensitiveStr::Ascii("idened"),
        dictgen::InsensitiveStr::Ascii("ideneds"),
        dictgen::InsensitiveStr::Ascii("idens"),
        dictgen::InsensitiveStr::Ascii("idor"),
        dictgen::InsensitiveStr::Ascii("idors"),
        dictgen::InsensitiveStr::Ascii("inition"),
        dictgen::InsensitiveStr::Ascii("initiy"),
        dictgen::InsensitiveStr::Ascii("initory"),
        dictgen::InsensitiveStr::Ascii("intiy"),
        dictgen::InsensitiveStr::Ascii("ion"),
        dictgen::InsensitiveStr::Ascii("isable"),
        dictgen::InsensitiveStr::Ascii("isionals"),
        dictgen::InsensitiveStr::Ascii("isiones"),
        dictgen::InsensitiveStr::Ascii("isior"),
        dictgen::InsensitiveStr::Ascii("ison"),
        dictgen::InsensitiveStr::Ascii("isons"),
        dictgen::InsensitiveStr::Ascii("rese"),
        dictgen::InsensitiveStr::Ascii("sion"),
        dictgen::InsensitiveStr::Ascii("sions"),
        dictgen::InsensitiveStr::Ascii("siors"),
    ],
    values: &[
        &["divide"],
        &["divided"],
        &["divides"],
        &["dividing"],
        &["diversify"],
        &["diversity"],
        &["diverse", "diverged"],
        &["diversify"],
        &["diversify"],
        &["diversity"],
        &["diversion"],
        &["diversions"],
        &["divot"],
        &["divination", "deviation"],
        &["device"],
        &["divider"],
        &["dividends"],
        &["dividends"],
        &["dividend"],
        &["dividend"],
        &["dividends"],
        &["divider", "divisor"],
        &["dividers", "divisors"],
        &["divination", "definition"],
        &["divinity"],
        &["divinity"],
        &["divinity"],
        &["division"],
        &["divisible"],
        &["divisions"],
        &["divisions"],
        &["divisor"],
        &["division"],
        &["divisions"],
        &["diverse"],
        &["division"],
        &["divisions"],
        &["divisors"],
    ],
    range: 2..=8,
};

static WORD_DIT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DIT_CHILDREN),
    value: None,
};

pub static WORD_DIT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("actorship"),
        dictgen::InsensitiveStr::Ascii("ance"),
        dictgen::InsensitiveStr::Ascii("ial"),
        dictgen::InsensitiveStr::Ascii("inguishes"),
        dictgen::InsensitiveStr::Ascii("o"),
        dictgen::InsensitiveStr::Ascii("orconfig"),
        dictgen::InsensitiveStr::Ascii("ribute"),
        dictgen::InsensitiveStr::Ascii("ributed"),
        dictgen::InsensitiveStr::Ascii("ribution"),
        dictgen::InsensitiveStr::Ascii("ributions"),
    ],
    values: &[
        &["dictatorship"],
        &["distance"],
        &["digital"],
        &["distinguishes"],
        &["ditto"],
        &["editorconfig"],
        &["distribute"],
        &["distributed"],
        &["distribution"],
        &["distributions"],
    ],
    range: 1..=9,
};

static WORD_DIS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_DIS_CHILDREN),
    value: None,
};

static WORD_DIS_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_DISA_NODE),
    Some(&WORD_DISB_NODE),
    Some(&WORD_DISC_NODE),
    Some(&WORD_DISD_NODE),
    Some(&WORD_DISE_NODE),
    Some(&WORD_DISF_NODE),
    Some(&WORD_DISG_NODE),
    Some(&WORD_DISH_NODE),
    Some(&WORD_DISI_NODE),
    None,
    Some(&WORD_DISK_NODE),
    Some(&WORD_DISL_NODE),
    Some(&WORD_DISM_NODE),
    Some(&WORD_DISN_NODE),
    Some(&WORD_DISO_NODE),
    Some(&WORD_DISP_NODE),
    Some(&WORD_DISQ_NODE),
    Some(&WORD_DISR_NODE),
    Some(&WORD_DISS_NODE),
    Some(&WORD_DIST_NODE),
    Some(&WORD_DISU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_DISU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DISU_CHILDREN),
    value: None,
};

pub static WORD_DISU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ade"),
        dictgen::InsensitiveStr::Ascii("cssing"),
        dictgen::InsensitiveStr::Ascii("cssion"),
        dictgen::InsensitiveStr::Ascii("cssions"),
        dictgen::InsensitiveStr::Ascii("cussion"),
        dictgen::InsensitiveStr::Ascii("pted"),
        dictgen::InsensitiveStr::Ascii("ptes"),
        dictgen::InsensitiveStr::Ascii("rption"),
        dictgen::InsensitiveStr::Ascii("ssion"),
        dictgen::InsensitiveStr::Ascii("ssions"),
        dictgen::InsensitiveStr::Ascii("tils"),
    ],
    values: &[
        &["dissuade"],
        &["discussing"],
        &["discussion"],
        &["discussions"],
        &["discussion"],
        &["disputed"],
        &["disputes"],
        &["disruption"],
        &["discussion"],
        &["discussions"],
        &["distutils"],
    ],
    range: 3..=7,
};

static WORD_DIST_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_DIST_CHILDREN),
    value: None,
};

static WORD_DIST_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_DISTA_NODE),
    None,
    None,
    None,
    Some(&WORD_DISTE_NODE),
    None,
    None,
    None,
    Some(&WORD_DISTI_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_DISTN_NODE),
    Some(&WORD_DISTO_NODE),
    None,
    None,
    Some(&WORD_DISTR_NODE),
    None,
    None,
    Some(&WORD_DISTU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_DISTU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DISTU_CHILDREN),
    value: None,
};

pub static WORD_DISTU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("bring"),
        dictgen::InsensitiveStr::Ascii("ingish"),
        dictgen::InsensitiveStr::Ascii("ingished"),
        dictgen::InsensitiveStr::Ascii("ingishing"),
        dictgen::InsensitiveStr::Ascii("nguish"),
        dictgen::InsensitiveStr::Ascii("rbace"),
        dictgen::InsensitiveStr::Ascii("rbante"),
        dictgen::InsensitiveStr::Ascii("rbd"),
        dictgen::InsensitiveStr::Ascii("rben"),
        dictgen::InsensitiveStr::Ascii("rbence"),
        dictgen::InsensitiveStr::Ascii("rping"),
        dictgen::InsensitiveStr::Ascii("stingly"),
    ],
    values: &[
        &["disturbing"],
        &["distinguish"],
        &["distinguished"],
        &["distinguishing"],
        &["distinguish"],
        &["disturbance"],
        &["disturbance"],
        &["disturbed"],
        &["disturbance"],
        &["disturbance"],
        &["disrupting"],
        &["disgustingly"],
    ],
    range: 3..=9,
};

static WORD_DISTR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_DISTR_CHILDREN),
    value: None,
};

static WORD_DISTR_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_DISTRA_NODE),
    Some(&WORD_DISTRB_NODE),
    Some(&WORD_DISTRC_NODE),
    None,
    Some(&WORD_DISTRE_NODE),
    None,
    None,
    None,
    Some(&WORD_DISTRI_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_DISTRO_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_DISTRU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_DISTRU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DISTRU_CHILDREN),
    value: None,
};

pub static WORD_DISTRU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("b"),
        dictgen::InsensitiveStr::Ascii("bance"),
        dictgen::InsensitiveStr::Ascii("bances"),
        dictgen::InsensitiveStr::Ascii("bed"),
        dictgen::InsensitiveStr::Ascii("bing"),
        dictgen::InsensitiveStr::Ascii("biotion"),
        dictgen::InsensitiveStr::Ascii("bite"),
        dictgen::InsensitiveStr::Ascii("bited"),
        dictgen::InsensitiveStr::Ascii("biting"),
        dictgen::InsensitiveStr::Ascii("bition"),
        dictgen::InsensitiveStr::Ascii("bitions"),
        dictgen::InsensitiveStr::Ascii("bitor"),
        dictgen::InsensitiveStr::Ascii("bitors"),
        dictgen::InsensitiveStr::Ascii("bted"),
        dictgen::InsensitiveStr::Ascii("btes"),
        dictgen::InsensitiveStr::Ascii("btion"),
        dictgen::InsensitiveStr::Ascii("bute"),
        dictgen::InsensitiveStr::Ascii("buted"),
        dictgen::InsensitiveStr::Ascii("bution"),
        dictgen::InsensitiveStr::Ascii("butions"),
        dictgen::InsensitiveStr::Ascii("butor"),
        dictgen::InsensitiveStr::Ascii("butors"),
        dictgen::InsensitiveStr::Ascii("ction"),
        dictgen::InsensitiveStr::Ascii("ctions"),
        dictgen::InsensitiveStr::Ascii("ctive"),
        dictgen::InsensitiveStr::Ascii("ctor"),
        dictgen::InsensitiveStr::Ascii("ctors"),
        dictgen::InsensitiveStr::Ascii("pts"),
    ],
    values: &[
        &["disturb"],
        &["disturbance"],
        &["disturbance"],
        &["disturbed"],
        &["disturbing"],
        &["distribution"],
        &["distribute"],
        &["distributed"],
        &["distributing"],
        &["distribution"],
        &["distributions"],
        &["distributor"],
        &["distributors"],
        &["distributed", "disrupted"],
        &["distrust"],
        &["distribution"],
        &["distribute"],
        &["distributed"],
        &["distribution"],
        &["distributions"],
        &["distributor"],
        &["distributors"],
        &["destruction"],
        &["distractions"],
        &["destructive"],
        &["destructor"],
        &["destructors"],
        &["distrust"],
    ],
    range: 1..=7,
};

static WORD_DISTRO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DISTRO_CHILDREN),
    value: None,
};

pub static WORD_DISTRO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("bute"),
        dictgen::InsensitiveStr::Ascii("buted"),
        dictgen::InsensitiveStr::Ascii("butes"),
        dictgen::InsensitiveStr::Ascii("buting"),
        dictgen::InsensitiveStr::Ascii("bution"),
        dictgen::InsensitiveStr::Ascii("butions"),
        dictgen::InsensitiveStr::Ascii("buts"),
        dictgen::InsensitiveStr::Ascii("tion"),
        dictgen::InsensitiveStr::Ascii("ying"),
    ],
    values: &[
        &["distribute"],
        &["distributed"],
        &["distributes"],
        &["distributing"],
        &["distribution"],
        &["distributions"],
        &["distributes"],
        &["distortion"],
        &["destroying"],
    ],
    range: 4..=7,
};

static WORD_DISTRI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DISTRI_CHILDREN),
    value: None,
};

pub static WORD_DISTRI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("bitor"),
        dictgen::InsensitiveStr::Ascii("bitors"),
        dictgen::InsensitiveStr::Ascii("btion"),
        dictgen::InsensitiveStr::Ascii("btions"),
        dictgen::InsensitiveStr::Ascii("btuion"),
        dictgen::InsensitiveStr::Ascii("btuions"),
        dictgen::InsensitiveStr::Ascii("btution"),
        dictgen::InsensitiveStr::Ascii("bucion"),
        dictgen::InsensitiveStr::Ascii("bue"),
        dictgen::InsensitiveStr::Ascii("bued"),
        dictgen::InsensitiveStr::Ascii("buem"),
        dictgen::InsensitiveStr::Ascii("buent"),
        dictgen::InsensitiveStr::Ascii("buer"),
        dictgen::InsensitiveStr::Ascii("bues"),
        dictgen::InsensitiveStr::Ascii("buie"),
        dictgen::InsensitiveStr::Ascii("buion"),
        dictgen::InsensitiveStr::Ascii("buit"),
        dictgen::InsensitiveStr::Ascii("buite"),
        dictgen::InsensitiveStr::Ascii("buited"),
        dictgen::InsensitiveStr::Ascii("buiting"),
        dictgen::InsensitiveStr::Ascii("buition"),
        dictgen::InsensitiveStr::Ascii("buitng"),
        dictgen::InsensitiveStr::Ascii("buito"),
        dictgen::InsensitiveStr::Ascii("buiton"),
        dictgen::InsensitiveStr::Ascii("buitor"),
        dictgen::InsensitiveStr::Ascii("bure"),
        dictgen::InsensitiveStr::Ascii("busion"),
        dictgen::InsensitiveStr::Ascii("bustion"),
        dictgen::InsensitiveStr::Ascii("butie"),
        dictgen::InsensitiveStr::Ascii("butin"),
        dictgen::InsensitiveStr::Ascii("butino"),
        dictgen::InsensitiveStr::Ascii("butio"),
        dictgen::InsensitiveStr::Ascii("butior"),
        dictgen::InsensitiveStr::Ascii("butiors"),
        dictgen::InsensitiveStr::Ascii("butivos"),
        dictgen::InsensitiveStr::Ascii("butons"),
        dictgen::InsensitiveStr::Ascii("butore"),
        dictgen::InsensitiveStr::Ascii("buts"),
        dictgen::InsensitiveStr::Ascii("buye"),
        dictgen::InsensitiveStr::Ascii("cct"),
        dictgen::InsensitiveStr::Ascii("cs"),
        dictgen::InsensitiveStr::Ascii("ubtion"),
    ],
    values: &[
        &["distributor"],
        &["distributors"],
        &["distribution"],
        &["distributions"],
        &["distributions", "distribution"],
        &["distributions"],
        &["distributions"],
        &["distribution"],
        &["distributed", "distribute"],
        &["distributed"],
        &["distribute"],
        &["distribute"],
        &["distribute"],
        &["distributes"],
        &["distribute"],
        &["distribution"],
        &["distribute"],
        &["distribute"],
        &["distributed"],
        &["distributing"],
        &["distribution"],
        &["distributing"],
        &["distribution"],
        &["distributions"],
        &["distributor"],
        &["distribute"],
        &["distributions"],
        &["distributions"],
        &["distributed"],
        &["distribution"],
        &["distributions"],
        &["distributor"],
        &["distributor"],
        &["distributors"],
        &["distributions"],
        &["distributors"],
        &["distribute"],
        &["distributors"],
        &["distribute"],
        &["district"],
        &["districts"],
        &["distributions"],
    ],
    range: 2..=7,
};

static WORD_DISTRE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DISTRE_CHILDREN),
    value: None,
};

pub static WORD_DISTRE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("buted")],
    values: &[&["distributed"]],
    range: 5..=5,
};

static WORD_DISTRC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DISTRC_CHILDREN),
    value: None,
};

pub static WORD_DISTRC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("it"),
        dictgen::InsensitiveStr::Ascii("its"),
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("ts"),
    ],
    values: &[&["district"], &["districts"], &["district"], &["districts"]],
    range: 1..=3,
};

static WORD_DISTRB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DISTRB_CHILDREN),
    value: None,
};

pub static WORD_DISTRB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ute"),
        dictgen::InsensitiveStr::Ascii("uted"),
        dictgen::InsensitiveStr::Ascii("utes"),
        dictgen::InsensitiveStr::Ascii("uting"),
        dictgen::InsensitiveStr::Ascii("ution"),
        dictgen::InsensitiveStr::Ascii("utions"),
    ],
    values: &[
        &["distribute"],
        &["distributed"],
        &["distributes"],
        &["distributing"],
        &["distribution"],
        &["distributions"],
    ],
    range: 3..=6,
};

static WORD_DISTRA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DISTRA_CHILDREN),
    value: None,
};

pub static WORD_DISTRA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("bution"),
        dictgen::InsensitiveStr::Ascii("ccion"),
        dictgen::InsensitiveStr::Ascii("ctes"),
        dictgen::InsensitiveStr::Ascii("ctia"),
        dictgen::InsensitiveStr::Ascii("ctin"),
        dictgen::InsensitiveStr::Ascii("ctiv"),
        dictgen::InsensitiveStr::Ascii("ctons"),
        dictgen::InsensitiveStr::Ascii("ktion"),
        dictgen::InsensitiveStr::Ascii("tion"),
    ],
    values: &[
        &["distribution"],
        &["distraction"],
        &["distracts"],
        &["district"],
        &["district"],
        &["district"],
        &["distracts"],
        &["distraction"],
        &["distortion"],
    ],
    range: 4..=6,
};

static WORD_DISTO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DISTO_CHILDREN),
    value: None,
};

pub static WORD_DISTO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("riton"),
        dictgen::InsensitiveStr::Ascii("rsion"),
        dictgen::InsensitiveStr::Ascii("rsional"),
        dictgen::InsensitiveStr::Ascii("rsions"),
        dictgen::InsensitiveStr::Ascii("rtian"),
        dictgen::InsensitiveStr::Ascii("rto"),
        dictgen::InsensitiveStr::Ascii("rtron"),
        dictgen::InsensitiveStr::Ascii("ry"),
    ],
    values: &[
        &["distortion"],
        &["distortion"],
        &["distortional"],
        &["distortions"],
        &["distortion"],
        &["distortion"],
        &["distortion"],
        &["destroy", "distort", "history"],
    ],
    range: 2..=7,
};

static WORD_DISTN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DISTN_CHILDREN),
    value: None,
};

pub static WORD_DISTN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ace"),
        dictgen::InsensitiveStr::Ascii("aces"),
        dictgen::InsensitiveStr::Ascii("ce"),
        dictgen::InsensitiveStr::Ascii("ces"),
        dictgen::InsensitiveStr::Ascii("ct"),
        dictgen::InsensitiveStr::Ascii("cte"),
        dictgen::InsensitiveStr::Ascii("ctes"),
        dictgen::InsensitiveStr::Ascii("guish"),
        dictgen::InsensitiveStr::Ascii("guished"),
        dictgen::InsensitiveStr::Ascii("iguish"),
        dictgen::InsensitiveStr::Ascii("iguished"),
    ],
    values: &[
        &["distance"],
        &["distances"],
        &["distance"],
        &["distances"],
        &["distinct"],
        &["distance"],
        &["distances"],
        &["distinguish"],
        &["distinguished"],
        &["distinguish"],
        &["distinguished"],
    ],
    range: 2..=8,
};

static WORD_DISTI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DISTI_CHILDREN),
    value: None,
};

pub static WORD_DISTI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("bute"),
        dictgen::InsensitiveStr::Ascii("buted"),
        dictgen::InsensitiveStr::Ascii("butes"),
        dictgen::InsensitiveStr::Ascii("buting"),
        dictgen::InsensitiveStr::Ascii("bution"),
        dictgen::InsensitiveStr::Ascii("butions"),
        dictgen::InsensitiveStr::Ascii("cnt"),
        dictgen::InsensitiveStr::Ascii("cntion"),
        dictgen::InsensitiveStr::Ascii("cntly"),
        dictgen::InsensitiveStr::Ascii("ction"),
        dictgen::InsensitiveStr::Ascii("ctly"),
        dictgen::InsensitiveStr::Ascii("guish"),
        dictgen::InsensitiveStr::Ascii("guished"),
        dictgen::InsensitiveStr::Ascii("nation"),
        dictgen::InsensitiveStr::Ascii("nations"),
        dictgen::InsensitiveStr::Ascii("native"),
        dictgen::InsensitiveStr::Ascii("ncion"),
        dictgen::InsensitiveStr::Ascii("nciton"),
        dictgen::InsensitiveStr::Ascii("ncitons"),
        dictgen::InsensitiveStr::Ascii("ncitve"),
        dictgen::InsensitiveStr::Ascii("ncive"),
        dictgen::InsensitiveStr::Ascii("nclty"),
        dictgen::InsensitiveStr::Ascii("ncte"),
        dictgen::InsensitiveStr::Ascii("nctie"),
        dictgen::InsensitiveStr::Ascii("nctily"),
        dictgen::InsensitiveStr::Ascii("nctin"),
        dictgen::InsensitiveStr::Ascii("ngish"),
        dictgen::InsensitiveStr::Ascii("ngished"),
        dictgen::InsensitiveStr::Ascii("ngishes"),
        dictgen::InsensitiveStr::Ascii("ngishing"),
        dictgen::InsensitiveStr::Ascii("ngiush"),
        dictgen::InsensitiveStr::Ascii("ngiushing"),
        dictgen::InsensitiveStr::Ascii("ngquished"),
        dictgen::InsensitiveStr::Ascii("nguise"),
        dictgen::InsensitiveStr::Ascii("nguised"),
        dictgen::InsensitiveStr::Ascii("nguises"),
        dictgen::InsensitiveStr::Ascii("nguising"),
        dictgen::InsensitiveStr::Ascii("ngush"),
        dictgen::InsensitiveStr::Ascii("ngushed"),
        dictgen::InsensitiveStr::Ascii("ngushes"),
        dictgen::InsensitiveStr::Ascii("ngushing"),
        dictgen::InsensitiveStr::Ascii("ngusih"),
        dictgen::InsensitiveStr::Ascii("ngusihing"),
        dictgen::InsensitiveStr::Ascii("nktion"),
        dictgen::InsensitiveStr::Ascii("nquish"),
        dictgen::InsensitiveStr::Ascii("nquishable"),
        dictgen::InsensitiveStr::Ascii("nquished"),
        dictgen::InsensitiveStr::Ascii("nquishes"),
        dictgen::InsensitiveStr::Ascii("nquishing"),
        dictgen::InsensitiveStr::Ascii("nt"),
        dictgen::InsensitiveStr::Ascii("ntcly"),
        dictgen::InsensitiveStr::Ascii("ntions"),
        dictgen::InsensitiveStr::Ascii("rbance"),
        dictgen::InsensitiveStr::Ascii("rbute"),
        dictgen::InsensitiveStr::Ascii("rbuted"),
        dictgen::InsensitiveStr::Ascii("rbutes"),
        dictgen::InsensitiveStr::Ascii("rbuting"),
        dictgen::InsensitiveStr::Ascii("rbution"),
        dictgen::InsensitiveStr::Ascii("rbutions"),
        dictgen::InsensitiveStr::Ascii("rbutor"),
        dictgen::InsensitiveStr::Ascii("rted"),
        dictgen::InsensitiveStr::Ascii("ungished"),
    ],
    values: &[
        &["distribute"],
        &["distributed"],
        &["distributes"],
        &["distributing"],
        &["distribution"],
        &["distributions"],
        &["distinct"],
        &["distinctions"],
        &["distinctly"],
        &["distinction"],
        &["distinctly"],
        &["distinguish"],
        &["distinguished"],
        &["destination", "distinction"],
        &["distinctions", "destinations"],
        &["distinctive"],
        &["distinction"],
        &["distinction"],
        &["distinctions"],
        &["distinctive"],
        &["distinctive"],
        &["distinctly"],
        &["distinctive"],
        &["distinctive"],
        &["distinctly"],
        &["distinctions"],
        &["distinguish"],
        &["distinguished"],
        &["distinguishes"],
        &["distinguishing"],
        &["distinguish"],
        &["distinguishing"],
        &["distinguished"],
        &["distinguished", "distinguish"],
        &["distinguished"],
        &["distinguishes"],
        &["distinguishing"],
        &["distinguish"],
        &["distinguished"],
        &["distinguishes"],
        &["distinguishing"],
        &["distinguish"],
        &["distinguishing"],
        &["distinction"],
        &["distinguish"],
        &["distinguishable"],
        &["distinguished"],
        &["distinguishes"],
        &["distinguishing"],
        &["distinct"],
        &["distinctly"],
        &["distinctions"],
        &["disturbance"],
        &["distribute"],
        &["distribute", "distributed"],
        &["distributes"],
        &["distributing"],
        &["distribution"],
        &["distributions"],
        &["distributor"],
        &["distorted"],
        &["distinguished"],
    ],
    range: 2..=10,
};

static WORD_DISTE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DISTE_CHILDREN),
    value: None,
};

pub static WORD_DISTE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ngish"),
        dictgen::InsensitiveStr::Ascii("rbance"),
    ],
    values: &[&["distinguish"], &["disturbance"]],
    range: 5..=6,
};

static WORD_DISTA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DISTA_CHILDREN),
    value: None,
};

pub static WORD_DISTA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ce"),
        dictgen::InsensitiveStr::Ascii("ced"),
        dictgen::InsensitiveStr::Ascii("ces"),
        dictgen::InsensitiveStr::Ascii("ncef"),
        dictgen::InsensitiveStr::Ascii("nge"),
        dictgen::InsensitiveStr::Ascii("nse"),
        dictgen::InsensitiveStr::Ascii("ntce"),
        dictgen::InsensitiveStr::Ascii("rct"),
        dictgen::InsensitiveStr::Ascii("se"),
        dictgen::InsensitiveStr::Ascii("stful"),
        dictgen::InsensitiveStr::Ascii("ter"),
        dictgen::InsensitiveStr::Ascii("tes"),
        dictgen::InsensitiveStr::Ascii("tesful"),
        dictgen::InsensitiveStr::Ascii("tse"),
        dictgen::InsensitiveStr::Ascii("tseful"),
    ],
    values: &[
        &["distance", "distaste"],
        &["distanced"],
        &["distances", "distastes"],
        &["distanced", "distances", "distance"],
        &["distance"],
        &["distance"],
        &["distance"],
        &["distract"],
        &["distaste"],
        &["distasteful"],
        &["disaster"],
        &["distaste"],
        &["distasteful"],
        &["distaste"],
        &["distasteful"],
    ],
    range: 2..=6,
};

static WORD_DISS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_DISS_CHILDREN),
    value: None,
};

static WORD_DISS_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_DISSA_NODE),
    Some(&WORD_DISSB_NODE),
    Some(&WORD_DISSC_NODE),
    None,
    Some(&WORD_DISSE_NODE),
    None,
    None,
    Some(&WORD_DISSH_NODE),
    Some(&WORD_DISSI_NODE),
    None,
    None,
    None,
    Some(&WORD_DISSM_NODE),
    None,
    Some(&WORD_DISSO_NODE),
    Some(&WORD_DISSP_NODE),
    None,
    Some(&WORD_DISSR_NODE),
    Some(&WORD_DISSS_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_DISSS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DISSS_CHILDREN),
    value: None,
};

pub static WORD_DISSS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("emble"),
        dictgen::InsensitiveStr::Ascii("embled"),
        dictgen::InsensitiveStr::Ascii("embler"),
        dictgen::InsensitiveStr::Ascii("embles"),
        dictgen::InsensitiveStr::Ascii("emblies"),
        dictgen::InsensitiveStr::Ascii("embling"),
        dictgen::InsensitiveStr::Ascii("embly"),
        dictgen::InsensitiveStr::Ascii("ociate"),
        dictgen::InsensitiveStr::Ascii("ociated"),
        dictgen::InsensitiveStr::Ascii("ociates"),
        dictgen::InsensitiveStr::Ascii("ociating"),
        dictgen::InsensitiveStr::Ascii("pointed"),
    ],
    values: &[
        &["disassemble"],
        &["disassembled"],
        &["disassembler"],
        &["disassembles"],
        &["disassemblies"],
        &["disassembling"],
        &["disassembly"],
        &["dissociate"],
        &["dissociated"],
        &["dissociates"],
        &["dissociating"],
        &["disappointed"],
    ],
    range: 5..=8,
};

static WORD_DISSR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DISSR_CHILDREN),
    value: None,
};

pub static WORD_DISSR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("upt"),
        dictgen::InsensitiveStr::Ascii("upted"),
        dictgen::InsensitiveStr::Ascii("upting"),
        dictgen::InsensitiveStr::Ascii("upts"),
    ],
    values: &[&["disrupt"], &["disrupted"], &["disrupting"], &["disrupts"]],
    range: 3..=6,
};

static WORD_DISSP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DISSP_CHILDREN),
    value: None,
};

pub static WORD_DISSP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aointed"),
        dictgen::InsensitiveStr::Ascii("iate"),
        dictgen::InsensitiveStr::Ascii("lay"),
        dictgen::InsensitiveStr::Ascii("pointed"),
    ],
    values: &[
        &["disappointed"],
        &["dissipate"],
        &["display"],
        &["disappointed"],
    ],
    range: 3..=7,
};

static WORD_DISSO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DISSO_CHILDREN),
    value: None,
};

pub static WORD_DISSO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("bediance"),
        dictgen::InsensitiveStr::Ascii("bediant"),
        dictgen::InsensitiveStr::Ascii("bedience"),
        dictgen::InsensitiveStr::Ascii("bedient"),
        dictgen::InsensitiveStr::Ascii("dance"),
        dictgen::InsensitiveStr::Ascii("le"),
        dictgen::InsensitiveStr::Ascii("nante"),
        dictgen::InsensitiveStr::Ascii("nence"),
        dictgen::InsensitiveStr::Ascii("pointed"),
        dictgen::InsensitiveStr::Ascii("vle"),
    ],
    values: &[
        &["disobedience"],
        &["disobedient"],
        &["disobedience"],
        &["disobedient"],
        &["dissonance"],
        &["dissolve"],
        &["dissonance"],
        &["dissonance"],
        &["disappointed"],
        &["dissolve"],
    ],
    range: 2..=8,
};

static WORD_DISSM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DISSM_CHILDREN),
    value: None,
};

pub static WORD_DISSM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("antle"),
        dictgen::InsensitiveStr::Ascii("antled"),
        dictgen::InsensitiveStr::Ascii("antles"),
        dictgen::InsensitiveStr::Ascii("antling"),
        dictgen::InsensitiveStr::Ascii("is"),
        dictgen::InsensitiveStr::Ascii("isal"),
        dictgen::InsensitiveStr::Ascii("ised"),
        dictgen::InsensitiveStr::Ascii("ises"),
        dictgen::InsensitiveStr::Ascii("ising"),
        dictgen::InsensitiveStr::Ascii("isive"),
        dictgen::InsensitiveStr::Ascii("iss"),
        dictgen::InsensitiveStr::Ascii("issed"),
        dictgen::InsensitiveStr::Ascii("isses"),
        dictgen::InsensitiveStr::Ascii("issing"),
    ],
    values: &[
        &["dismantle"],
        &["dismantled"],
        &["dismantles"],
        &["dismantling"],
        &["dismiss"],
        &["dismissal"],
        &["dismissed"],
        &["dismisses"],
        &["dismissing"],
        &["dismissive"],
        &["dismiss"],
        &["dismissed"],
        &["dismisses"],
        &["dismissing"],
    ],
    range: 2..=7,
};

static WORD_DISSI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DISSI_CHILDREN),
    value: None,
};

pub static WORD_DISSI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("mialr"),
        dictgen::InsensitiveStr::Ascii("mialrity"),
        dictgen::InsensitiveStr::Ascii("mialrly"),
        dictgen::InsensitiveStr::Ascii("miar"),
        dictgen::InsensitiveStr::Ascii("milarily"),
        dictgen::InsensitiveStr::Ascii("milary"),
        dictgen::InsensitiveStr::Ascii("milat"),
        dictgen::InsensitiveStr::Ascii("milia"),
        dictgen::InsensitiveStr::Ascii("miliar"),
        dictgen::InsensitiveStr::Ascii("miliarity"),
        dictgen::InsensitiveStr::Ascii("miliarly"),
        dictgen::InsensitiveStr::Ascii("miliarty"),
        dictgen::InsensitiveStr::Ascii("miliary"),
        dictgen::InsensitiveStr::Ascii("millar"),
        dictgen::InsensitiveStr::Ascii("mlar"),
        dictgen::InsensitiveStr::Ascii("mlarlity"),
        dictgen::InsensitiveStr::Ascii("mlarly"),
        dictgen::InsensitiveStr::Ascii("mliar"),
        dictgen::InsensitiveStr::Ascii("mliarly"),
        dictgen::InsensitiveStr::Ascii("mmetric"),
        dictgen::InsensitiveStr::Ascii("mmetrical"),
        dictgen::InsensitiveStr::Ascii("mmetry"),
        dictgen::InsensitiveStr::Ascii("patore"),
        dictgen::InsensitiveStr::Ascii("pointed"),
    ],
    values: &[
        &["dissimilar"],
        &["dissimilarity"],
        &["dissimilarly"],
        &["dissimilar"],
        &["dissimilarly"],
        &["dissimilarly"],
        &["dissimilar"],
        &["dissimilar"],
        &["dissimilar"],
        &["dissimilarity"],
        &["dissimilarly"],
        &["dissimilarity"],
        &["dissimilarity"],
        &["dissimilar"],
        &["dissimilar"],
        &["dissimilarity"],
        &["dissimilarly"],
        &["dissimilar"],
        &["dissimilarly"],
        &["dissymmetric"],
        &["dissymmetrical"],
        &["dissymmetry"],
        &["dissipate"],
        &["disappointed"],
    ],
    range: 4..=9,
};

static WORD_DISSH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DISSH_CHILDREN),
    value: None,
};

pub static WORD_DISSH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("earteningly")],
    values: &[&["dishearteningly"]],
    range: 11..=11,
};

static WORD_DISSE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DISSE_CHILDREN),
    value: None,
};

pub static WORD_DISSE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("pointed"),
        dictgen::InsensitiveStr::Ascii("rtaion"),
    ],
    values: &[&["disappointed"], &["dissertation"]],
    range: 6..=7,
};

static WORD_DISSC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DISSC_CHILDREN),
    value: None,
};

pub static WORD_DISSC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("onect"),
        dictgen::InsensitiveStr::Ascii("onnect"),
        dictgen::InsensitiveStr::Ascii("onnected"),
        dictgen::InsensitiveStr::Ascii("onnects"),
        dictgen::InsensitiveStr::Ascii("over"),
        dictgen::InsensitiveStr::Ascii("overed"),
        dictgen::InsensitiveStr::Ascii("overing"),
        dictgen::InsensitiveStr::Ascii("overs"),
        dictgen::InsensitiveStr::Ascii("overy"),
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("ted"),
        dictgen::InsensitiveStr::Ascii("ting"),
        dictgen::InsensitiveStr::Ascii("tor"),
        dictgen::InsensitiveStr::Ascii("tors"),
        dictgen::InsensitiveStr::Ascii("ts"),
        dictgen::InsensitiveStr::Ascii("uesed"),
        dictgen::InsensitiveStr::Ascii("us"),
        dictgen::InsensitiveStr::Ascii("used"),
        dictgen::InsensitiveStr::Ascii("uses"),
        dictgen::InsensitiveStr::Ascii("using"),
        dictgen::InsensitiveStr::Ascii("usion"),
        dictgen::InsensitiveStr::Ascii("usions"),
        dictgen::InsensitiveStr::Ascii("uss"),
        dictgen::InsensitiveStr::Ascii("ussed"),
        dictgen::InsensitiveStr::Ascii("usses"),
        dictgen::InsensitiveStr::Ascii("ussing"),
        dictgen::InsensitiveStr::Ascii("ussion"),
        dictgen::InsensitiveStr::Ascii("ussions"),
    ],
    values: &[
        &["disconnect"],
        &["disconnect"],
        &["disconnected"],
        &["disconnects"],
        &["discover"],
        &["discovered"],
        &["discovering"],
        &["discovers"],
        &["discovery"],
        &["dissect"],
        &["dissected"],
        &["dissecting"],
        &["dissector"],
        &["dissectors"],
        &["dissects"],
        &["discussed"],
        &["discuss"],
        &["discussed"],
        &["discusses"],
        &["discussing"],
        &["discussion"],
        &["discussions"],
        &["discuss"],
        &["discussed"],
        &["discusses"],
        &["discussing"],
        &["discussion"],
        &["discussions"],
    ],
    range: 1..=8,
};

static WORD_DISSB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DISSB_CHILDREN),
    value: None,
};

pub static WORD_DISSB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("le"),
        dictgen::InsensitiveStr::Ascii("led"),
        dictgen::InsensitiveStr::Ascii("les"),
        dictgen::InsensitiveStr::Ascii("ling"),
    ],
    values: &[&["disable"], &["disabled"], &["disables"], &["disabling"]],
    range: 2..=4,
};

static WORD_DISSA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_DISSA_CHILDREN),
    value: None,
};

static WORD_DISSA_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    Some(&WORD_DISSAB_NODE),
    None,
    Some(&WORD_DISSAD_NODE),
    None,
    None,
    Some(&WORD_DISSAG_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_DISSAL_NODE),
    Some(&WORD_DISSAM_NODE),
    None,
    None,
    Some(&WORD_DISSAP_NODE),
    None,
    Some(&WORD_DISSAR_NODE),
    Some(&WORD_DISSAS_NODE),
    Some(&WORD_DISSAT_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_DISSAT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DISSAT_CHILDREN),
    value: None,
};

pub static WORD_DISSAT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("isfed"),
        dictgen::InsensitiveStr::Ascii("isifed"),
        dictgen::InsensitiveStr::Ascii("sified"),
    ],
    values: &[&["dissatisfied"], &["dissatisfied"], &["dissatisfied"]],
    range: 5..=6,
};

static WORD_DISSAS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DISSAS_CHILDREN),
    value: None,
};

pub static WORD_DISSAS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("emble"),
        dictgen::InsensitiveStr::Ascii("embled"),
        dictgen::InsensitiveStr::Ascii("embler"),
        dictgen::InsensitiveStr::Ascii("embles"),
        dictgen::InsensitiveStr::Ascii("emblies"),
        dictgen::InsensitiveStr::Ascii("embling"),
        dictgen::InsensitiveStr::Ascii("embly"),
        dictgen::InsensitiveStr::Ascii("ociate"),
        dictgen::InsensitiveStr::Ascii("ociated"),
        dictgen::InsensitiveStr::Ascii("ociates"),
        dictgen::InsensitiveStr::Ascii("ociation"),
        dictgen::InsensitiveStr::Ascii("semble"),
        dictgen::InsensitiveStr::Ascii("sembled"),
        dictgen::InsensitiveStr::Ascii("sembler"),
        dictgen::InsensitiveStr::Ascii("sembles"),
        dictgen::InsensitiveStr::Ascii("semblies"),
        dictgen::InsensitiveStr::Ascii("sembling"),
        dictgen::InsensitiveStr::Ascii("sembly"),
        dictgen::InsensitiveStr::Ascii("sociate"),
        dictgen::InsensitiveStr::Ascii("sociated"),
        dictgen::InsensitiveStr::Ascii("sociates"),
        dictgen::InsensitiveStr::Ascii("sociating"),
        dictgen::InsensitiveStr::Ascii("ter"),
        dictgen::InsensitiveStr::Ascii("ters"),
        dictgen::InsensitiveStr::Ascii("tified"),
    ],
    values: &[
        &["disassemble"],
        &["disassembled"],
        &["disassembler"],
        &["disassembles"],
        &["disassemblies"],
        &["disassembling"],
        &["disassembly"],
        &["disassociate"],
        &["disassociated"],
        &["disassociates"],
        &["disassociation"],
        &["disassemble"],
        &["disassembled"],
        &["disassembler"],
        &["disassembles"],
        &["disassemblies"],
        &["disassembling"],
        &["disassembly"],
        &["disassociate"],
        &["disassociated"],
        &["disassociates"],
        &["disassociating"],
        &["disaster"],
        &["disasters"],
        &["dissatisfied"],
    ],
    range: 3..=9,
};

static WORD_DISSAR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DISSAR_CHILDREN),
    value: None,
};

pub static WORD_DISSAR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ray")],
    values: &[&["disarray"]],
    range: 3..=3,
};

static WORD_DISSAP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DISSAP_CHILDREN),
    value: None,
};

pub static WORD_DISSAP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ate"),
        dictgen::InsensitiveStr::Ascii("ates"),
        dictgen::InsensitiveStr::Ascii("ear"),
        dictgen::InsensitiveStr::Ascii("earance"),
        dictgen::InsensitiveStr::Ascii("eard"),
        dictgen::InsensitiveStr::Ascii("eared"),
        dictgen::InsensitiveStr::Ascii("earing"),
        dictgen::InsensitiveStr::Ascii("ears"),
        dictgen::InsensitiveStr::Ascii("er"),
        dictgen::InsensitiveStr::Ascii("erd"),
        dictgen::InsensitiveStr::Ascii("ered"),
        dictgen::InsensitiveStr::Ascii("ering"),
        dictgen::InsensitiveStr::Ascii("ers"),
        dictgen::InsensitiveStr::Ascii("ionted"),
        dictgen::InsensitiveStr::Ascii("oimted"),
        dictgen::InsensitiveStr::Ascii("oined"),
        dictgen::InsensitiveStr::Ascii("oint"),
        dictgen::InsensitiveStr::Ascii("ointd"),
        dictgen::InsensitiveStr::Ascii("ointed"),
        dictgen::InsensitiveStr::Ascii("ointing"),
        dictgen::InsensitiveStr::Ascii("oints"),
        dictgen::InsensitiveStr::Ascii("ointted"),
        dictgen::InsensitiveStr::Ascii("oited"),
        dictgen::InsensitiveStr::Ascii("oitned"),
        dictgen::InsensitiveStr::Ascii("onited"),
        dictgen::InsensitiveStr::Ascii("oonted"),
        dictgen::InsensitiveStr::Ascii("ounted"),
        dictgen::InsensitiveStr::Ascii("pear"),
        dictgen::InsensitiveStr::Ascii("peard"),
        dictgen::InsensitiveStr::Ascii("peared"),
        dictgen::InsensitiveStr::Ascii("pearing"),
        dictgen::InsensitiveStr::Ascii("pears"),
        dictgen::InsensitiveStr::Ascii("per"),
        dictgen::InsensitiveStr::Ascii("perd"),
        dictgen::InsensitiveStr::Ascii("pered"),
        dictgen::InsensitiveStr::Ascii("pering"),
        dictgen::InsensitiveStr::Ascii("pers"),
        dictgen::InsensitiveStr::Ascii("pinted"),
        dictgen::InsensitiveStr::Ascii("pointed"),
        dictgen::InsensitiveStr::Ascii("ponted"),
        dictgen::InsensitiveStr::Ascii("prove"),
        dictgen::InsensitiveStr::Ascii("proves"),
    ],
    values: &[
        &["dissipate"],
        &["dissipates"],
        &["disappear"],
        &["disappearance"],
        &["disappeared"],
        &["disappeared"],
        &["disappearing"],
        &["disappears"],
        &["disappear"],
        &["disappeared"],
        &["disappeared"],
        &["disappearing"],
        &["disappears"],
        &["disappointed"],
        &["disappointed"],
        &["disappointed"],
        &["disappoint"],
        &["disappointed"],
        &["disappointed"],
        &["disappointing"],
        &["disappoints"],
        &["disappointed"],
        &["disappointed"],
        &["disappointed"],
        &["disappointed"],
        &["disappointed"],
        &["disappointed"],
        &["disappear"],
        &["disappeared"],
        &["disappeared"],
        &["disappearing"],
        &["disappears"],
        &["disappear"],
        &["disappeared"],
        &["disappeared"],
        &["disappearing"],
        &["disappears"],
        &["disappointed"],
        &["disappointed"],
        &["disappointed"],
        &["disapprove"],
        &["disapproves"],
    ],
    range: 2..=7,
};

static WORD_DISSAM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DISSAM_CHILDREN),
    value: None,
};

pub static WORD_DISSAM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("biguate"),
        dictgen::InsensitiveStr::Ascii("ble"),
        dictgen::InsensitiveStr::Ascii("bled"),
        dictgen::InsensitiveStr::Ascii("bler"),
        dictgen::InsensitiveStr::Ascii("bles"),
        dictgen::InsensitiveStr::Ascii("blies"),
        dictgen::InsensitiveStr::Ascii("bling"),
        dictgen::InsensitiveStr::Ascii("bly"),
    ],
    values: &[
        &["disambiguate"],
        &["disassemble"],
        &["disassembled"],
        &["disassembler"],
        &["disassembles"],
        &["disassemblies"],
        &["disassembling"],
        &["disassembly"],
    ],
    range: 3..=7,
};

static WORD_DISSAL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DISSAL_CHILDREN),
    value: None,
};

pub static WORD_DISSAL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("low"),
        dictgen::InsensitiveStr::Ascii("lowed"),
        dictgen::InsensitiveStr::Ascii("lowing"),
        dictgen::InsensitiveStr::Ascii("lows"),
        dictgen::InsensitiveStr::Ascii("ow"),
        dictgen::InsensitiveStr::Ascii("owed"),
        dictgen::InsensitiveStr::Ascii("owing"),
        dictgen::InsensitiveStr::Ascii("ows"),
    ],
    values: &[
        &["disallow"],
        &["disallowed"],
        &["disallowing"],
        &["disallows"],
        &["disallow"],
        &["disallowed"],
        &["disallowing"],
        &["disallows"],
    ],
    range: 2..=6,
};

static WORD_DISSAG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DISSAG_CHILDREN),
    value: None,
};

pub static WORD_DISSAG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("reement"),
        dictgen::InsensitiveStr::Ascii("regation"),
    ],
    values: &[&["disagreement"], &["dissaggregation"]],
    range: 7..=8,
};

static WORD_DISSAD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DISSAD_CHILDREN),
    value: None,
};

pub static WORD_DISSAD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("vantage"),
        dictgen::InsensitiveStr::Ascii("vantages"),
    ],
    values: &[&["disadvantage"], &["disadvantages"]],
    range: 7..=8,
};

static WORD_DISSAB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DISSAB_CHILDREN),
    value: None,
};

pub static WORD_DISSAB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("le"),
        dictgen::InsensitiveStr::Ascii("led"),
        dictgen::InsensitiveStr::Ascii("les"),
        dictgen::InsensitiveStr::Ascii("ling"),
    ],
    values: &[&["disable"], &["disabled"], &["disables"], &["disabling"]],
    range: 2..=4,
};

static WORD_DISR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DISR_CHILDREN),
    value: None,
};

pub static WORD_DISR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ecpect"),
        dictgen::InsensitiveStr::Ascii("ecpected"),
        dictgen::InsensitiveStr::Ascii("ecpectful"),
        dictgen::InsensitiveStr::Ascii("ecpecting"),
        dictgen::InsensitiveStr::Ascii("ection"),
        dictgen::InsensitiveStr::Ascii("egaring"),
        dictgen::InsensitiveStr::Ascii("egrad"),
        dictgen::InsensitiveStr::Ascii("epectful"),
        dictgen::InsensitiveStr::Ascii("epectfully"),
        dictgen::InsensitiveStr::Ascii("epresentation"),
        dictgen::InsensitiveStr::Ascii("epsect"),
        dictgen::InsensitiveStr::Ascii("epsected"),
        dictgen::InsensitiveStr::Ascii("epsectful"),
        dictgen::InsensitiveStr::Ascii("epsecting"),
        dictgen::InsensitiveStr::Ascii("esepct"),
        dictgen::InsensitiveStr::Ascii("esepcted"),
        dictgen::InsensitiveStr::Ascii("esepctful"),
        dictgen::InsensitiveStr::Ascii("esepcting"),
        dictgen::InsensitiveStr::Ascii("especful"),
        dictgen::InsensitiveStr::Ascii("especing"),
        dictgen::InsensitiveStr::Ascii("espection"),
        dictgen::InsensitiveStr::Ascii("espectul"),
        dictgen::InsensitiveStr::Ascii("espekt"),
        dictgen::InsensitiveStr::Ascii("espekted"),
        dictgen::InsensitiveStr::Ascii("espekting"),
        dictgen::InsensitiveStr::Ascii("ete"),
        dictgen::InsensitiveStr::Ascii("etion"),
        dictgen::InsensitiveStr::Ascii("ibution"),
        dictgen::InsensitiveStr::Ascii("icts"),
        dictgen::InsensitiveStr::Ascii("iption"),
        dictgen::InsensitiveStr::Ascii("ispect"),
        dictgen::InsensitiveStr::Ascii("ispectful"),
        dictgen::InsensitiveStr::Ascii("ispecting"),
        dictgen::InsensitiveStr::Ascii("m"),
        dictgen::InsensitiveStr::Ascii("puting"),
        dictgen::InsensitiveStr::Ascii("tibution"),
        dictgen::InsensitiveStr::Ascii("uptin"),
        dictgen::InsensitiveStr::Ascii("uptivo"),
        dictgen::InsensitiveStr::Ascii("uptron"),
    ],
    values: &[
        &["disrespect"],
        &["disrespected"],
        &["disrespectful"],
        &["disrespecting"],
        &["discretion"],
        &["disregarding"],
        &["disregard"],
        &["disrespectful"],
        &["disrespectfully"],
        &["misrepresentation"],
        &["disrespect"],
        &["disrespected"],
        &["disrespectful"],
        &["disrespecting"],
        &["disrespect"],
        &["disrespected"],
        &["disrespectful"],
        &["disrespecting"],
        &["disrespectful"],
        &["disrespecting"],
        &["disrespecting"],
        &["disrespectful"],
        &["disrespect"],
        &["disrespected"],
        &["disrespecting"],
        &["discrete"],
        &["discretion"],
        &["distribution"],
        &["districts"],
        &["disruption"],
        &["disrespect"],
        &["disrespectful"],
        &["disrespecting"],
        &["disarm"],
        &["disrupting"],
        &["distributions"],
        &["disruption"],
        &["disruption"],
        &["disruption"],
    ],
    range: 1..=13,
};

static WORD_DISQ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DISQ_CHILDREN),
    value: None,
};

pub static WORD_DISQ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aulified"),
        dictgen::InsensitiveStr::Ascii("ualifed"),
        dictgen::InsensitiveStr::Ascii("ualifyed"),
        dictgen::InsensitiveStr::Ascii("ustingly"),
    ],
    values: &[
        &["disqualified"],
        &["disqualified"],
        &["disqualified"],
        &["disgustingly"],
    ],
    range: 7..=8,
};

static WORD_DISP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_DISP_CHILDREN),
    value: None,
};

static WORD_DISP_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_DISPA_NODE),
    Some(&WORD_DISPB_NODE),
    None,
    None,
    Some(&WORD_DISPE_NODE),
    None,
    None,
    None,
    Some(&WORD_DISPI_NODE),
    None,
    None,
    Some(&WORD_DISPL_NODE),
    None,
    None,
    Some(&WORD_DISPO_NODE),
    Some(&WORD_DISPP_NODE),
    None,
    Some(&WORD_DISPR_NODE),
    None,
    Some(&WORD_DISPT_NODE),
    Some(&WORD_DISPU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_DISPU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DISPU_CHILDREN),
    value: None,
};

pub static WORD_DISPU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("se"),
        dictgen::InsensitiveStr::Ascii("tandem"),
        dictgen::InsensitiveStr::Ascii("terad"),
        dictgen::InsensitiveStr::Ascii("ts"),
    ],
    values: &[
        &["disputes"],
        &["disputandum"],
        &["disputed"],
        &["disputes"],
    ],
    range: 2..=6,
};

static WORD_DISPT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DISPT_CHILDREN),
    value: None,
};

pub static WORD_DISPT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ach")],
    values: &[&["dispatch"]],
    range: 3..=3,
};

static WORD_DISPR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DISPR_CHILDREN),
    value: None,
};

pub static WORD_DISPR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aportionate"),
        dictgen::InsensitiveStr::Ascii("aportionately"),
        dictgen::InsensitiveStr::Ascii("oportianate"),
        dictgen::InsensitiveStr::Ascii("oportianately"),
        dictgen::InsensitiveStr::Ascii("oportiante"),
        dictgen::InsensitiveStr::Ascii("oportiantely"),
        dictgen::InsensitiveStr::Ascii("oportiate"),
        dictgen::InsensitiveStr::Ascii("oportinate"),
        dictgen::InsensitiveStr::Ascii("oportionaltely"),
        dictgen::InsensitiveStr::Ascii("oportionaly"),
        dictgen::InsensitiveStr::Ascii("oportionatley"),
        dictgen::InsensitiveStr::Ascii("oportionatly"),
        dictgen::InsensitiveStr::Ascii("oportionnate"),
        dictgen::InsensitiveStr::Ascii("oprotionate"),
        dictgen::InsensitiveStr::Ascii("oprotionately"),
    ],
    values: &[
        &["disproportionate"],
        &["disproportionately"],
        &["disproportionate"],
        &["disproportionately"],
        &["disproportionate"],
        &["disproportionately"],
        &["disproportionate"],
        &["disproportionate"],
        &["disproportionately"],
        &["disproportionately"],
        &["disproportionately"],
        &["disproportionately"],
        &["disproportionate"],
        &["disproportionate"],
        &["disproportionately"],
    ],
    range: 9..=14,
};

static WORD_DISPP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DISPP_CHILDREN),
    value: None,
};

pub static WORD_DISPP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("rove")],
    values: &[&["disprove", "disapprove"]],
    range: 4..=4,
};

static WORD_DISPO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DISPO_CHILDREN),
    value: None,
};

pub static WORD_DISPO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("de"),
        dictgen::InsensitiveStr::Ascii("rportionate"),
        dictgen::InsensitiveStr::Ascii("rportionately"),
        dictgen::InsensitiveStr::Ascii("rportionatly"),
        dictgen::InsensitiveStr::Ascii("rue"),
        dictgen::InsensitiveStr::Ascii("rve"),
        dictgen::InsensitiveStr::Ascii("rved"),
        dictgen::InsensitiveStr::Ascii("rves"),
        dictgen::InsensitiveStr::Ascii("rving"),
        dictgen::InsensitiveStr::Ascii("sel"),
        dictgen::InsensitiveStr::Ascii("sicion"),
        dictgen::InsensitiveStr::Ascii("siton"),
        dictgen::InsensitiveStr::Ascii("sle"),
        dictgen::InsensitiveStr::Ascii("ssable"),
        dictgen::InsensitiveStr::Ascii("ssal"),
        dictgen::InsensitiveStr::Ascii("sse"),
        dictgen::InsensitiveStr::Ascii("ssed"),
        dictgen::InsensitiveStr::Ascii("sses"),
        dictgen::InsensitiveStr::Ascii("ssing"),
        dictgen::InsensitiveStr::Ascii("ste"),
        dictgen::InsensitiveStr::Ascii("stion"),
        dictgen::InsensitiveStr::Ascii("ves"),
    ],
    values: &[
        &["dispose"],
        &["disproportionate"],
        &["disproportionately"],
        &["disproportionately"],
        &["disparue"],
        &["disprove"],
        &["disproved"],
        &["disproves"],
        &["disproving"],
        &["disposal"],
        &["disposition"],
        &["disposition"],
        &["dispose"],
        &["disposable"],
        &["disposal"],
        &["dispose"],
        &["disposed", "dispossessed"],
        &["disposes", "dispossess"],
        &["disposing"],
        &["dispose"],
        &["disposition"],
        &["dispose"],
    ],
    range: 2..=13,
};

static WORD_DISPL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DISPL_CHILDREN),
    value: None,
};

pub static WORD_DISPL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("a"),
        dictgen::InsensitiveStr::Ascii("acemnt"),
        dictgen::InsensitiveStr::Ascii("acemnts"),
        dictgen::InsensitiveStr::Ascii("acment"),
        dictgen::InsensitiveStr::Ascii("acments"),
        dictgen::InsensitiveStr::Ascii("aing"),
        dictgen::InsensitiveStr::Ascii("ayd"),
        dictgen::InsensitiveStr::Ascii("ayes"),
        dictgen::InsensitiveStr::Ascii("ayfps"),
        dictgen::InsensitiveStr::Ascii("ayied"),
        dictgen::InsensitiveStr::Ascii("ayig"),
        dictgen::InsensitiveStr::Ascii("y"),
        dictgen::InsensitiveStr::Ascii("yed"),
        dictgen::InsensitiveStr::Ascii("ying"),
        dictgen::InsensitiveStr::Ascii("ys"),
    ],
    values: &[
        &["display"],
        &["displacement"],
        &["displacements"],
        &["displacement"],
        &["displacements"],
        &["displaying"],
        &["displayed"],
        &["displays", "displayed"],
        &["displays"],
        &["displayed"],
        &["displaying"],
        &["display"],
        &["displayed"],
        &["displaying"],
        &["displays"],
    ],
    range: 1..=7,
};

static WORD_DISPI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DISPI_CHILDREN),
    value: None,
};

pub static WORD_DISPI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cable"),
        dictgen::InsensitiveStr::Ascii("te"),
    ],
    values: &[&["despicable"], &["despite"]],
    range: 2..=5,
};

static WORD_DISPE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DISPE_CHILDREN),
    value: None,
};

pub static WORD_DISPE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cable"),
        dictgen::InsensitiveStr::Ascii("ll"),
        dictgen::InsensitiveStr::Ascii("ncaries"),
        dictgen::InsensitiveStr::Ascii("ncary"),
        dictgen::InsensitiveStr::Ascii("nce"),
        dictgen::InsensitiveStr::Ascii("nced"),
        dictgen::InsensitiveStr::Ascii("ncers"),
        dictgen::InsensitiveStr::Ascii("ncing"),
        dictgen::InsensitiveStr::Ascii("ners"),
        dictgen::InsensitiveStr::Ascii("nsaire"),
        dictgen::InsensitiveStr::Ascii("nsaires"),
        dictgen::InsensitiveStr::Ascii("nsare"),
        dictgen::InsensitiveStr::Ascii("nsarie"),
        dictgen::InsensitiveStr::Ascii("nsarios"),
        dictgen::InsensitiveStr::Ascii("nsiary"),
        dictgen::InsensitiveStr::Ascii("nsiries"),
        dictgen::InsensitiveStr::Ascii("nsories"),
        dictgen::InsensitiveStr::Ascii("nsory"),
        dictgen::InsensitiveStr::Ascii("rportionate"),
        dictgen::InsensitiveStr::Ascii("rsa"),
        dictgen::InsensitiveStr::Ascii("rtion"),
        dictgen::InsensitiveStr::Ascii("snary"),
    ],
    values: &[
        &["despicable"],
        &["dispel"],
        &["dispensaries"],
        &["dispensary"],
        &["dispense"],
        &["dispensed"],
        &["dispenser"],
        &["dispensing"],
        &["dispenser"],
        &["dispensaries"],
        &["dispensaries"],
        &["dispenser"],
        &["dispenser"],
        &["dispensaries"],
        &["dispensary"],
        &["dispensaries"],
        &["dispensaries"],
        &["dispensary"],
        &["disproportionate"],
        &["dispensary"],
        &["dispersion"],
        &["dispensary"],
    ],
    range: 2..=11,
};

static WORD_DISPB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DISPB_CHILDREN),
    value: None,
};

pub static WORD_DISPB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ibute")],
    values: &[&["distribute"]],
    range: 5..=5,
};

static WORD_DISPA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DISPA_CHILDREN),
    value: None,
};

pub static WORD_DISPA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ched"),
        dictgen::InsensitiveStr::Ascii("cth"),
        dictgen::InsensitiveStr::Ascii("ir"),
        dictgen::InsensitiveStr::Ascii("irty"),
        dictgen::InsensitiveStr::Ascii("lcement"),
        dictgen::InsensitiveStr::Ascii("lcements"),
        dictgen::InsensitiveStr::Ascii("ly"),
        dictgen::InsensitiveStr::Ascii("lyable"),
        dictgen::InsensitiveStr::Ascii("lyed"),
        dictgen::InsensitiveStr::Ascii("lyes"),
        dictgen::InsensitiveStr::Ascii("lying"),
        dictgen::InsensitiveStr::Ascii("lys"),
        dictgen::InsensitiveStr::Ascii("pointed"),
        dictgen::InsensitiveStr::Ascii("ringly"),
        dictgen::InsensitiveStr::Ascii("rite"),
        dictgen::InsensitiveStr::Ascii("rtiy"),
        dictgen::InsensitiveStr::Ascii("tcgh"),
        dictgen::InsensitiveStr::Ascii("tchs"),
        dictgen::InsensitiveStr::Ascii("th"),
        dictgen::InsensitiveStr::Ascii("thed"),
        dictgen::InsensitiveStr::Ascii("thes"),
        dictgen::InsensitiveStr::Ascii("thing"),
        dictgen::InsensitiveStr::Ascii("y"),
        dictgen::InsensitiveStr::Ascii("yed"),
        dictgen::InsensitiveStr::Ascii("yes"),
        dictgen::InsensitiveStr::Ascii("ying"),
        dictgen::InsensitiveStr::Ascii("yport"),
        dictgen::InsensitiveStr::Ascii("ys"),
    ],
    values: &[
        &["dispatched"],
        &["dispatch"],
        &["despair"],
        &["disparity"],
        &["displacement"],
        &["displacements"],
        &["display"],
        &["displayable"],
        &["displayed"],
        &["displays"],
        &["displaying"],
        &["displays"],
        &["disappointed"],
        &["disparagingly"],
        &["disparate"],
        &["disparity"],
        &["dispatch"],
        &["dispatches"],
        &["dispatch"],
        &["dispatched"],
        &["dispatches"],
        &["dispatching"],
        &["display"],
        &["displayed"],
        &["displays"],
        &["displaying"],
        &["displayport"],
        &["displays"],
    ],
    range: 1..=8,
};

static WORD_DISO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DISO_CHILDREN),
    value: None,
};

pub static WORD_DISO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("bediance"),
        dictgen::InsensitiveStr::Ascii("bediant"),
        dictgen::InsensitiveStr::Ascii("beidence"),
        dictgen::InsensitiveStr::Ascii("cgraphy"),
        dictgen::InsensitiveStr::Ascii("kay"),
        dictgen::InsensitiveStr::Ascii("llusioned"),
        dictgen::InsensitiveStr::Ascii("lve"),
        dictgen::InsensitiveStr::Ascii("lved"),
        dictgen::InsensitiveStr::Ascii("nnect"),
        dictgen::InsensitiveStr::Ascii("nnected"),
        dictgen::InsensitiveStr::Ascii("ver"),
        dictgen::InsensitiveStr::Ascii("vered"),
        dictgen::InsensitiveStr::Ascii("vering"),
        dictgen::InsensitiveStr::Ascii("very"),
    ],
    values: &[
        &["disobedience"],
        &["disobedient"],
        &["disobedience"],
        &["discography"],
        &["display"],
        &["disillusioned"],
        &["dissolve"],
        &["dissolved"],
        &["disconnect"],
        &["disconnected"],
        &["discover"],
        &["discovered"],
        &["discovering"],
        &["discovery"],
    ],
    range: 3..=9,
};

static WORD_DISN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DISN_CHILDREN),
    value: None,
};

pub static WORD_DISN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("abled"),
        dictgen::InsensitiveStr::Ascii("egage"),
    ],
    values: &[&["disabled"], &["disengage"]],
    range: 5..=5,
};

static WORD_DISM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DISM_CHILDREN),
    value: None,
};

pub static WORD_DISM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("anlting"),
        dictgen::InsensitiveStr::Ascii("antaled"),
        dictgen::InsensitiveStr::Ascii("ante"),
        dictgen::InsensitiveStr::Ascii("antel"),
        dictgen::InsensitiveStr::Ascii("anteld"),
        dictgen::InsensitiveStr::Ascii("anteled"),
        dictgen::InsensitiveStr::Ascii("anting"),
        dictgen::InsensitiveStr::Ascii("antleing"),
        dictgen::InsensitiveStr::Ascii("entled"),
        dictgen::InsensitiveStr::Ascii("isals"),
        dictgen::InsensitiveStr::Ascii("isse"),
    ],
    values: &[
        &["dismantling"],
        &["dismantled"],
        &["dismantle"],
        &["dismantle"],
        &["dismantled"],
        &["dismantled"],
        &["dismantling"],
        &["dismantling"],
        &["dismantled"],
        &["dismissal"],
        &["dismissive"],
    ],
    range: 4..=8,
};

static WORD_DISL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DISL_CHILDREN),
    value: None,
};

pub static WORD_DISL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aimer"),
        dictgen::InsensitiveStr::Ascii("ay"),
        dictgen::InsensitiveStr::Ascii("ayed"),
        dictgen::InsensitiveStr::Ascii("aying"),
        dictgen::InsensitiveStr::Ascii("ays"),
        dictgen::InsensitiveStr::Ascii("caimer"),
        dictgen::InsensitiveStr::Ascii("iks"),
        dictgen::InsensitiveStr::Ascii("ikse"),
        dictgen::InsensitiveStr::Ascii("pay"),
        dictgen::InsensitiveStr::Ascii("payed"),
        dictgen::InsensitiveStr::Ascii("paying"),
        dictgen::InsensitiveStr::Ascii("pays"),
    ],
    values: &[
        &["disclaimer"],
        &["display"],
        &["displayed"],
        &["displaying"],
        &["displays"],
        &["disclaimer"],
        &["dislikes"],
        &["dislikes"],
        &["display"],
        &["displayed"],
        &["displaying"],
        &["displays"],
    ],
    range: 2..=6,
};

static WORD_DISK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DISK_CHILDREN),
    value: None,
};

pub static WORD_DISK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("rete"),
        dictgen::InsensitiveStr::Ascii("retion"),
        dictgen::InsensitiveStr::Ascii("retization"),
        dictgen::InsensitiveStr::Ascii("retize"),
        dictgen::InsensitiveStr::Ascii("retized"),
        dictgen::InsensitiveStr::Ascii("rimination"),
    ],
    values: &[
        &["discrete"],
        &["discretion"],
        &["discretization"],
        &["discretize"],
        &["discretized"],
        &["discrimination"],
    ],
    range: 4..=10,
};

static WORD_DISI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DISI_CHILDREN),
    value: None,
};

pub static WORD_DISI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cples"),
        dictgen::InsensitiveStr::Ascii("cpline"),
        dictgen::InsensitiveStr::Ascii("cplined"),
        dictgen::InsensitiveStr::Ascii("cplines"),
        dictgen::InsensitiveStr::Ascii("gn"),
        dictgen::InsensitiveStr::Ascii("gnated"),
        dictgen::InsensitiveStr::Ascii("llisioned"),
        dictgen::InsensitiveStr::Ascii("llusionned"),
        dictgen::InsensitiveStr::Ascii("llutioned"),
        dictgen::InsensitiveStr::Ascii("ngeneous"),
        dictgen::InsensitiveStr::Ascii("ngenious"),
        dictgen::InsensitiveStr::Ascii("ngenous"),
        dictgen::InsensitiveStr::Ascii("ngenously"),
        dictgen::InsensitiveStr::Ascii("ngenuious"),
        dictgen::InsensitiveStr::Ascii("ngenuos"),
        dictgen::InsensitiveStr::Ascii("nguish"),
        dictgen::InsensitiveStr::Ascii("nteresed"),
        dictgen::InsensitiveStr::Ascii("ntereted"),
        dictgen::InsensitiveStr::Ascii("plined"),
        dictgen::InsensitiveStr::Ascii("red"),
        dictgen::InsensitiveStr::Ascii("tributions"),
    ],
    values: &[
        &["disciples"],
        &["discipline"],
        &["disciplined"],
        &["disciplines"],
        &["design"],
        &["designated"],
        &["disillusioned"],
        &["disillusioned"],
        &["disillusioned"],
        &["disingenuous"],
        &["disingenuous"],
        &["disingenuous"],
        &["disingenuously"],
        &["disingenuous"],
        &["disingenuous"],
        &["distinguish"],
        &["disinterested"],
        &["disinterested"],
        &["disciplined"],
        &["desired"],
        &["distributions"],
    ],
    range: 2..=10,
};

static WORD_DISH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DISH_CHILDREN),
    value: None,
};

pub static WORD_DISH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("arge"),
        dictgen::InsensitiveStr::Ascii("carged"),
        dictgen::InsensitiveStr::Ascii("inored"),
        dictgen::InsensitiveStr::Ascii("oner"),
        dictgen::InsensitiveStr::Ascii("onesy"),
        dictgen::InsensitiveStr::Ascii("onet"),
        dictgen::InsensitiveStr::Ascii("onord"),
    ],
    values: &[
        &["discharge"],
        &["discharged"],
        &["dishonored"],
        &["dishonored"],
        &["dishonesty"],
        &["dishonesty"],
        &["dishonored"],
    ],
    range: 4..=6,
};

static WORD_DISG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DISG_CHILDREN),
    value: None,
};

pub static WORD_DISG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("arded"),
        dictgen::InsensitiveStr::Ascii("areement"),
        dictgen::InsensitiveStr::Ascii("arees"),
        dictgen::InsensitiveStr::Ascii("est"),
        dictgen::InsensitiveStr::Ascii("iuse"),
        dictgen::InsensitiveStr::Ascii("iused"),
        dictgen::InsensitiveStr::Ascii("n"),
        dictgen::InsensitiveStr::Ascii("ned"),
        dictgen::InsensitiveStr::Ascii("ner"),
        dictgen::InsensitiveStr::Ascii("nostic"),
        dictgen::InsensitiveStr::Ascii("nostics"),
        dictgen::InsensitiveStr::Ascii("ns"),
        dictgen::InsensitiveStr::Ascii("racful"),
        dictgen::InsensitiveStr::Ascii("raseful"),
        dictgen::InsensitiveStr::Ascii("rateful"),
        dictgen::InsensitiveStr::Ascii("runtaled"),
        dictgen::InsensitiveStr::Ascii("runted"),
        dictgen::InsensitiveStr::Ascii("runteld"),
        dictgen::InsensitiveStr::Ascii("runteled"),
        dictgen::InsensitiveStr::Ascii("runtld"),
        dictgen::InsensitiveStr::Ascii("uisted"),
        dictgen::InsensitiveStr::Ascii("uisting"),
        dictgen::InsensitiveStr::Ascii("untingly"),
        dictgen::InsensitiveStr::Ascii("usied"),
        dictgen::InsensitiveStr::Ascii("uss"),
        dictgen::InsensitiveStr::Ascii("ustes"),
        dictgen::InsensitiveStr::Ascii("ustigly"),
        dictgen::InsensitiveStr::Ascii("ustingy"),
        dictgen::InsensitiveStr::Ascii("ustinly"),
        dictgen::InsensitiveStr::Ascii("ustiny"),
        dictgen::InsensitiveStr::Ascii("ustos"),
        dictgen::InsensitiveStr::Ascii("ustosa"),
        dictgen::InsensitiveStr::Ascii("ustose"),
        dictgen::InsensitiveStr::Ascii("ustosi"),
        dictgen::InsensitiveStr::Ascii("ustoso"),
        dictgen::InsensitiveStr::Ascii("ustus"),
    ],
    values: &[
        &["discarded", "discarted"],
        &["disagreements"],
        &["disagrees"],
        &["digest"],
        &["disguise"],
        &["disguised"],
        &["design"],
        &["designed"],
        &["designer"],
        &["diagnostic"],
        &["diagnostics"],
        &["designs"],
        &["disgraceful"],
        &["disgraceful"],
        &["disgraceful"],
        &["disgruntled"],
        &["disgruntled"],
        &["disgruntled"],
        &["disgruntled"],
        &["disgruntled"],
        &["disguise"],
        &["disgusting"],
        &["disgustingly"],
        &["disguised"],
        &["disgusts"],
        &["disgusts"],
        &["disgustingly"],
        &["disgustingly"],
        &["disgustingly"],
        &["disgustingly"],
        &["disgusts"],
        &["disgusts"],
        &["disgusts"],
        &["disgusts"],
        &["disgusts"],
        &["disgusts"],
    ],
    range: 1..=8,
};

static WORD_DISF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DISF_CHILDREN),
    value: None,
};

pub static WORD_DISF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("unctional"),
        dictgen::InsensitiveStr::Ascii("unctionality"),
    ],
    values: &[&["dysfunctional"], &["dysfunctionality"]],
    range: 9..=12,
};

static WORD_DISE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DISE_CHILDREN),
    value: None,
};

pub static WORD_DISE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cting"),
        dictgen::InsensitiveStr::Ascii("ction"),
        dictgen::InsensitiveStr::Ascii("lect"),
        dictgen::InsensitiveStr::Ascii("mination"),
        dictgen::InsensitiveStr::Ascii("nchanged"),
        dictgen::InsensitiveStr::Ascii("ncouraged"),
        dictgen::InsensitiveStr::Ascii("ngenuous"),
        dictgen::InsensitiveStr::Ascii("nginuous"),
        dictgen::InsensitiveStr::Ascii("nsitized"),
        dictgen::InsensitiveStr::Ascii("ntry"),
        dictgen::InsensitiveStr::Ascii("rable"),
        dictgen::InsensitiveStr::Ascii("rtation"),
    ],
    values: &[
        &["dissecting"],
        &["dissection"],
        &["deselect"],
        &["dissemination"],
        &["disenchanted"],
        &["discouraged"],
        &["disingenuous"],
        &["disingenuous"],
        &["desensitized"],
        &["dysentery"],
        &["desirable"],
        &["dissertation"],
    ],
    range: 4..=9,
};

static WORD_DISD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DISD_CHILDREN),
    value: None,
};

pub static WORD_DISD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("vantage")],
    values: &[&["disadvantage"]],
    range: 7..=7,
};

static WORD_DISC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_DISC_CHILDREN),
    value: None,
};

static WORD_DISC_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_DISCA_NODE),
    None,
    Some(&WORD_DISCC_NODE),
    None,
    Some(&WORD_DISCE_NODE),
    None,
    None,
    Some(&WORD_DISCH_NODE),
    Some(&WORD_DISCI_NODE),
    None,
    None,
    Some(&WORD_DISCL_NODE),
    None,
    None,
    Some(&WORD_DISCO_NODE),
    Some(&WORD_DISCP_NODE),
    None,
    Some(&WORD_DISCR_NODE),
    None,
    Some(&WORD_DISCT_NODE),
    Some(&WORD_DISCU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_DISCU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DISCU_CHILDREN),
    value: None,
};

pub static WORD_DISCU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("alified"),
        dictgen::InsensitiveStr::Ascii("assed"),
        dictgen::InsensitiveStr::Ascii("sed"),
        dictgen::InsensitiveStr::Ascii("sion"),
        dictgen::InsensitiveStr::Ascii("sions"),
        dictgen::InsensitiveStr::Ascii("sison"),
        dictgen::InsensitiveStr::Ascii("ssin"),
        dictgen::InsensitiveStr::Ascii("ssiong"),
        dictgen::InsensitiveStr::Ascii("sson"),
        dictgen::InsensitiveStr::Ascii("ssons"),
        dictgen::InsensitiveStr::Ascii("sssion"),
        dictgen::InsensitiveStr::Ascii("sting"),
        dictgen::InsensitiveStr::Ascii("stingly"),
        dictgen::InsensitiveStr::Ascii("usion"),
    ],
    values: &[
        &["disqualified"],
        &["discussed"],
        &["discussed"],
        &["discussion"],
        &["discussions"],
        &["discussions"],
        &["discussion"],
        &["discussing"],
        &["discussion"],
        &["discussions"],
        &["discussions"],
        &["discussing", "disgusting"],
        &["disgustingly"],
        &["discussion"],
    ],
    range: 3..=7,
};

static WORD_DISCT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DISCT_CHILDREN),
    value: None,
};

pub static WORD_DISCT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("inction"),
        dictgen::InsensitiveStr::Ascii("inctive"),
        dictgen::InsensitiveStr::Ascii("inguish"),
        dictgen::InsensitiveStr::Ascii("intions"),
        dictgen::InsensitiveStr::Ascii("ionaries"),
        dictgen::InsensitiveStr::Ascii("ionary"),
    ],
    values: &[
        &["distinction"],
        &["distinctive"],
        &["distinguish"],
        &["distinctions"],
        &["dictionaries"],
        &["dictionary"],
    ],
    range: 6..=8,
};

static WORD_DISCR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DISCR_CHILDREN),
    value: None,
};

pub static WORD_DISCR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ace"),
        dictgen::InsensitiveStr::Ascii("aced"),
        dictgen::InsensitiveStr::Ascii("aceful"),
        dictgen::InsensitiveStr::Ascii("acefully"),
        dictgen::InsensitiveStr::Ascii("acefulness"),
        dictgen::InsensitiveStr::Ascii("aces"),
        dictgen::InsensitiveStr::Ascii("acing"),
        dictgen::InsensitiveStr::Ascii("apency"),
        dictgen::InsensitiveStr::Ascii("ards"),
        dictgen::InsensitiveStr::Ascii("ecion"),
        dictgen::InsensitiveStr::Ascii("eddit"),
        dictgen::InsensitiveStr::Ascii("edid"),
        dictgen::InsensitiveStr::Ascii("editied"),
        dictgen::InsensitiveStr::Ascii("editted"),
        dictgen::InsensitiveStr::Ascii("eminates"),
        dictgen::InsensitiveStr::Ascii("epany"),
        dictgen::InsensitiveStr::Ascii("epencies"),
        dictgen::InsensitiveStr::Ascii("epency"),
        dictgen::InsensitiveStr::Ascii("epicies"),
        dictgen::InsensitiveStr::Ascii("esion"),
        dictgen::InsensitiveStr::Ascii("eting"),
        dictgen::InsensitiveStr::Ascii("etited"),
        dictgen::InsensitiveStr::Ascii("eto"),
        dictgen::InsensitiveStr::Ascii("ibe"),
        dictgen::InsensitiveStr::Ascii("ibed"),
        dictgen::InsensitiveStr::Ascii("ibes"),
        dictgen::InsensitiveStr::Ascii("ibing"),
        dictgen::InsensitiveStr::Ascii("imanatory"),
        dictgen::InsensitiveStr::Ascii("imante"),
        dictgen::InsensitiveStr::Ascii("imanted"),
        dictgen::InsensitiveStr::Ascii("imianted"),
        dictgen::InsensitiveStr::Ascii("imiate"),
        dictgen::InsensitiveStr::Ascii("iminacion"),
        dictgen::InsensitiveStr::Ascii("iminante"),
        dictgen::InsensitiveStr::Ascii("iminare"),
        dictgen::InsensitiveStr::Ascii("iminatie"),
        dictgen::InsensitiveStr::Ascii("iminatin"),
        dictgen::InsensitiveStr::Ascii("iminatoire"),
        dictgen::InsensitiveStr::Ascii("iminatorie"),
        dictgen::InsensitiveStr::Ascii("imine"),
        dictgen::InsensitiveStr::Ascii("iminitory"),
        dictgen::InsensitiveStr::Ascii("iminted"),
        dictgen::InsensitiveStr::Ascii("imintor"),
        dictgen::InsensitiveStr::Ascii("iption"),
        dictgen::InsensitiveStr::Ascii("iptions"),
        dictgen::InsensitiveStr::Ascii("iptor"),
        dictgen::InsensitiveStr::Ascii("iptors"),
        dictgen::InsensitiveStr::Ascii("ouage"),
        dictgen::InsensitiveStr::Ascii("ption"),
    ],
    values: &[
        &["disgrace"],
        &["disgraced"],
        &["disgraceful"],
        &["disgracefully"],
        &["disgracefulness"],
        &["disgraces"],
        &["disgracing"],
        &["discrepancy"],
        &["discards"],
        &["discretion"],
        &["discredited"],
        &["discredited"],
        &["discredited"],
        &["discredited"],
        &["discriminates"],
        &["discrepancy"],
        &["discrepancies"],
        &["discrepancy"],
        &["discrepancies"],
        &["discretion"],
        &["discretion"],
        &["discredited"],
        &["discretion"],
        &["describe"],
        &["described"],
        &["describes"],
        &["describing"],
        &["discriminatory"],
        &["discriminate"],
        &["discriminated"],
        &["discriminated"],
        &["discriminate"],
        &["discrimination"],
        &["discriminate"],
        &["discriminate"],
        &["discriminate"],
        &["discrimination"],
        &["discriminate"],
        &["discriminate"],
        &["discriminate"],
        &["discriminatory"],
        &["discriminated"],
        &["discriminator"],
        &["description"],
        &["descriptions"],
        &["descriptor"],
        &["descriptors"],
        &["discourages"],
        &["discretion"],
    ],
    range: 3..=10,
};

static WORD_DISCP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DISCP_CHILDREN),
    value: None,
};

pub static WORD_DISCP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("line")],
    values: &[&["discipline"]],
    range: 4..=4,
};

static WORD_DISCO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_DISCO_CHILDREN),
    value: None,
};

static WORD_DISCO_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_DISCOG_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_DISCOL_NODE),
    None,
    Some(&WORD_DISCON_NODE),
    None,
    None,
    None,
    Some(&WORD_DISCOR_NODE),
    Some(&WORD_DISCOS_NODE),
    Some(&WORD_DISCOT_NODE),
    Some(&WORD_DISCOU_NODE),
    Some(&WORD_DISCOV_NODE),
    None,
    None,
    None,
    None,
];

static WORD_DISCOV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DISCOV_CHILDREN),
    value: None,
};

pub static WORD_DISCOV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("erd"),
        dictgen::InsensitiveStr::Ascii("ere"),
        dictgen::InsensitiveStr::Ascii("ereability"),
        dictgen::InsensitiveStr::Ascii("eres"),
        dictgen::InsensitiveStr::Ascii("eribility"),
        dictgen::InsensitiveStr::Ascii("eryd"),
        dictgen::InsensitiveStr::Ascii("erys"),
        dictgen::InsensitiveStr::Ascii("ey"),
        dictgen::InsensitiveStr::Ascii("r"),
        dictgen::InsensitiveStr::Ascii("red"),
        dictgen::InsensitiveStr::Ascii("ring"),
        dictgen::InsensitiveStr::Ascii("rs"),
    ],
    values: &[
        &["discover"],
        &["discovered"],
        &["discovered"],
        &["discoveries"],
        &["discoverability"],
        &["discovers"],
        &["discoverability"],
        &["discovered"],
        &["discovers"],
        &["discovery"],
        &["discover"],
        &["discovered"],
        &["discovering"],
        &["discovers"],
    ],
    range: 1..=10,
};

static WORD_DISCOU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DISCOU_CHILDREN),
    value: None,
};

pub static WORD_DISCOU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("nd"),
        dictgen::InsensitiveStr::Ascii("ntined"),
        dictgen::InsensitiveStr::Ascii("ranged"),
        dictgen::InsensitiveStr::Ascii("rarged"),
        dictgen::InsensitiveStr::Ascii("rces"),
        dictgen::InsensitiveStr::Ascii("re"),
        dictgen::InsensitiveStr::Ascii("rgae"),
        dictgen::InsensitiveStr::Ascii("rges"),
        dictgen::InsensitiveStr::Ascii("rrage"),
        dictgen::InsensitiveStr::Ascii("rraged"),
    ],
    values: &[
        &["discounted"],
        &["discontinued"],
        &["discouraged"],
        &["discouraged"],
        &["discourse"],
        &["discourse"],
        &["discourages"],
        &["discourages"],
        &["discourage"],
        &["discouraged"],
    ],
    range: 2..=6,
};

static WORD_DISCOT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DISCOT_CHILDREN),
    value: None,
};

pub static WORD_DISCOT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ek"),
        dictgen::InsensitiveStr::Ascii("eque"),
    ],
    values: &[&["discotheque"], &["discotheque"]],
    range: 2..=4,
};

static WORD_DISCOS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DISCOS_CHILDREN),
    value: None,
};

pub static WORD_DISCOS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ure")],
    values: &[&["discourse"]],
    range: 3..=3,
};

static WORD_DISCOR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DISCOR_CHILDREN),
    value: None,
};

pub static WORD_DISCOR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aged"),
        dictgen::InsensitiveStr::Ascii("uage"),
    ],
    values: &[&["discouraged"], &["discourages"]],
    range: 4..=4,
};

static WORD_DISCON_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DISCON_CHILDREN),
    value: None,
};

pub static WORD_DISCON_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ecct"),
        dictgen::InsensitiveStr::Ascii("eccted"),
        dictgen::InsensitiveStr::Ascii("eccting"),
        dictgen::InsensitiveStr::Ascii("ecction"),
        dictgen::InsensitiveStr::Ascii("ecctions"),
        dictgen::InsensitiveStr::Ascii("eccts"),
        dictgen::InsensitiveStr::Ascii("ect"),
        dictgen::InsensitiveStr::Ascii("ected"),
        dictgen::InsensitiveStr::Ascii("ecting"),
        dictgen::InsensitiveStr::Ascii("ection"),
        dictgen::InsensitiveStr::Ascii("ections"),
        dictgen::InsensitiveStr::Ascii("ects"),
        dictgen::InsensitiveStr::Ascii("eect"),
        dictgen::InsensitiveStr::Ascii("eected"),
        dictgen::InsensitiveStr::Ascii("eecting"),
        dictgen::InsensitiveStr::Ascii("eection"),
        dictgen::InsensitiveStr::Ascii("eections"),
        dictgen::InsensitiveStr::Ascii("eects"),
        dictgen::InsensitiveStr::Ascii("enct"),
        dictgen::InsensitiveStr::Ascii("encted"),
        dictgen::InsensitiveStr::Ascii("encting"),
        dictgen::InsensitiveStr::Ascii("enction"),
        dictgen::InsensitiveStr::Ascii("enctions"),
        dictgen::InsensitiveStr::Ascii("encts"),
        dictgen::InsensitiveStr::Ascii("et"),
        dictgen::InsensitiveStr::Ascii("eted"),
        dictgen::InsensitiveStr::Ascii("eting"),
        dictgen::InsensitiveStr::Ascii("etion"),
        dictgen::InsensitiveStr::Ascii("etions"),
        dictgen::InsensitiveStr::Ascii("ets"),
        dictgen::InsensitiveStr::Ascii("ncet"),
        dictgen::InsensitiveStr::Ascii("nec"),
        dictgen::InsensitiveStr::Ascii("neced"),
        dictgen::InsensitiveStr::Ascii("necters"),
        dictgen::InsensitiveStr::Ascii("nectes"),
        dictgen::InsensitiveStr::Ascii("nectme"),
        dictgen::InsensitiveStr::Ascii("nectus"),
        dictgen::InsensitiveStr::Ascii("net"),
        dictgen::InsensitiveStr::Ascii("neted"),
        dictgen::InsensitiveStr::Ascii("neting"),
        dictgen::InsensitiveStr::Ascii("nets"),
        dictgen::InsensitiveStr::Ascii("nnect"),
        dictgen::InsensitiveStr::Ascii("tigious"),
        dictgen::InsensitiveStr::Ascii("tigous"),
        dictgen::InsensitiveStr::Ascii("tiguities"),
        dictgen::InsensitiveStr::Ascii("tiguos"),
        dictgen::InsensitiveStr::Ascii("tined"),
        dictgen::InsensitiveStr::Ascii("tinous"),
        dictgen::InsensitiveStr::Ascii("tinuos"),
        dictgen::InsensitiveStr::Ascii("tinus"),
        dictgen::InsensitiveStr::Ascii("tinuted"),
        dictgen::InsensitiveStr::Ascii("tiued"),
        dictgen::InsensitiveStr::Ascii("tiuned"),
        dictgen::InsensitiveStr::Ascii("tued"),
    ],
    values: &[
        &["disconnect"],
        &["disconnected"],
        &["disconnecting"],
        &["disconnection"],
        &["disconnections"],
        &["disconnects"],
        &["disconnect"],
        &["disconnected"],
        &["disconnecting"],
        &["disconnection"],
        &["disconnections"],
        &["disconnects"],
        &["disconnect"],
        &["disconnected"],
        &["disconnecting"],
        &["disconnection"],
        &["disconnections"],
        &["disconnects"],
        &["disconnect"],
        &["disconnected"],
        &["disconnecting"],
        &["disconnection"],
        &["disconnections"],
        &["disconnects"],
        &["disconnect"],
        &["disconnected"],
        &["disconnecting"],
        &["disconnection"],
        &["disconnections"],
        &["disconnects"],
        &["disconnects"],
        &["disconnect"],
        &["disconnected"],
        &["disconnects"],
        &["disconnects"],
        &["disconnected"],
        &["disconnects"],
        &["disconnect"],
        &["disconnected"],
        &["disconnecting"],
        &["disconnects"],
        &["disconnect"],
        &["discontiguous"],
        &["discontiguous"],
        &["discontinuities"],
        &["discontiguous"],
        &["discontinued"],
        &["discontinuous"],
        &["discontinuous"],
        &["discontinue", "discontinuous"],
        &["discontinued"],
        &["discontinued"],
        &["discontinued"],
        &["discounted"],
    ],
    range: 2..=9,
};

static WORD_DISCOL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DISCOL_CHILDREN),
    value: None,
};

pub static WORD_DISCOL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("sure")],
    values: &[&["disclosure"]],
    range: 4..=4,
};

static WORD_DISCOG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DISCOG_CHILDREN),
    value: None,
};

pub static WORD_DISCOG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("rahy"),
        dictgen::InsensitiveStr::Ascii("rapy"),
        dictgen::InsensitiveStr::Ascii("rophy"),
        dictgen::InsensitiveStr::Ascii("rpahy"),
    ],
    values: &[
        &["discography"],
        &["discography"],
        &["discography"],
        &["discography"],
    ],
    range: 4..=5,
};

static WORD_DISCL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DISCL_CHILDREN),
    value: None,
};

pub static WORD_DISCL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("amer"),
        dictgen::InsensitiveStr::Ascii("amier"),
        dictgen::InsensitiveStr::Ascii("iamer"),
        dictgen::InsensitiveStr::Ascii("ipinary"),
        dictgen::InsensitiveStr::Ascii("ipine"),
        dictgen::InsensitiveStr::Ascii("ipined"),
        dictgen::InsensitiveStr::Ascii("ipines"),
        dictgen::InsensitiveStr::Ascii("osue"),
        dictgen::InsensitiveStr::Ascii("ousre"),
        dictgen::InsensitiveStr::Ascii("soure"),
    ],
    values: &[
        &["disclaimer"],
        &["disclaimer"],
        &["disclaimer"],
        &["disciplinary"],
        &["discipline"],
        &["disciplined"],
        &["disciplines"],
        &["disclosure"],
        &["disclosure"],
        &["disclosure"],
    ],
    range: 4..=7,
};

static WORD_DISCI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DISCI_CHILDREN),
    value: None,
};

pub static WORD_DISCI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("menation"),
        dictgen::InsensitiveStr::Ascii("niplary"),
        dictgen::InsensitiveStr::Ascii("planary"),
        dictgen::InsensitiveStr::Ascii("plen"),
        dictgen::InsensitiveStr::Ascii("plenary"),
        dictgen::InsensitiveStr::Ascii("plened"),
        dictgen::InsensitiveStr::Ascii("plers"),
        dictgen::InsensitiveStr::Ascii("plies"),
        dictgen::InsensitiveStr::Ascii("plinairy"),
        dictgen::InsensitiveStr::Ascii("plinare"),
        dictgen::InsensitiveStr::Ascii("plinas"),
        dictgen::InsensitiveStr::Ascii("plince"),
        dictgen::InsensitiveStr::Ascii("plinera"),
        dictgen::InsensitiveStr::Ascii("plinerad"),
        dictgen::InsensitiveStr::Ascii("plinery"),
        dictgen::InsensitiveStr::Ascii("pliniary"),
        dictgen::InsensitiveStr::Ascii("plins"),
        dictgen::InsensitiveStr::Ascii("prine"),
    ],
    values: &[
        &["dissemination"],
        &["disciplinary"],
        &["disciplinary"],
        &["disciplines"],
        &["disciplinary"],
        &["disciplined"],
        &["disciples"],
        &["disciplines"],
        &["disciplinary"],
        &["discipline"],
        &["disciplines"],
        &["disciplines"],
        &["disciplinary"],
        &["disciplined"],
        &["disciplinary"],
        &["disciplinary"],
        &["disciplines"],
        &["discipline"],
    ],
    range: 4..=8,
};

static WORD_DISCH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DISCH_CHILDREN),
    value: None,
};

pub static WORD_DISCH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ard"),
        dictgen::InsensitiveStr::Ascii("arded"),
        dictgen::InsensitiveStr::Ascii("are"),
    ],
    values: &[
        &["discharged"],
        &["discharged"],
        &["discharged", "discharge"],
    ],
    range: 3..=5,
};

static WORD_DISCE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DISCE_CHILDREN),
    value: None,
};

pub static WORD_DISCE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("pline"),
        dictgen::InsensitiveStr::Ascii("ption"),
        dictgen::InsensitiveStr::Ascii("rnable"),
        dictgen::InsensitiveStr::Ascii("rtation"),
    ],
    values: &[
        &["discipline"],
        &["discretion"],
        &["discernible"],
        &["dissertation"],
    ],
    range: 5..=7,
};

static WORD_DISCC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DISCC_CHILDREN),
    value: None,
};

pub static WORD_DISCC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("onecct"),
        dictgen::InsensitiveStr::Ascii("oneccted"),
        dictgen::InsensitiveStr::Ascii("oneccting"),
        dictgen::InsensitiveStr::Ascii("onecction"),
        dictgen::InsensitiveStr::Ascii("onecctions"),
        dictgen::InsensitiveStr::Ascii("oneccts"),
        dictgen::InsensitiveStr::Ascii("onect"),
        dictgen::InsensitiveStr::Ascii("onected"),
        dictgen::InsensitiveStr::Ascii("onecting"),
        dictgen::InsensitiveStr::Ascii("onection"),
        dictgen::InsensitiveStr::Ascii("onections"),
        dictgen::InsensitiveStr::Ascii("onects"),
        dictgen::InsensitiveStr::Ascii("oneect"),
        dictgen::InsensitiveStr::Ascii("oneected"),
        dictgen::InsensitiveStr::Ascii("oneecting"),
        dictgen::InsensitiveStr::Ascii("oneection"),
        dictgen::InsensitiveStr::Ascii("oneections"),
        dictgen::InsensitiveStr::Ascii("oneects"),
        dictgen::InsensitiveStr::Ascii("onenct"),
        dictgen::InsensitiveStr::Ascii("onencted"),
        dictgen::InsensitiveStr::Ascii("onencting"),
        dictgen::InsensitiveStr::Ascii("onenction"),
        dictgen::InsensitiveStr::Ascii("onenctions"),
        dictgen::InsensitiveStr::Ascii("onencts"),
        dictgen::InsensitiveStr::Ascii("onet"),
        dictgen::InsensitiveStr::Ascii("oneted"),
        dictgen::InsensitiveStr::Ascii("oneting"),
        dictgen::InsensitiveStr::Ascii("onetion"),
        dictgen::InsensitiveStr::Ascii("onetions"),
        dictgen::InsensitiveStr::Ascii("onets"),
        dictgen::InsensitiveStr::Ascii("uss"),
    ],
    values: &[
        &["disconnect"],
        &["disconnected"],
        &["disconnecting"],
        &["disconnection"],
        &["disconnections"],
        &["disconnects"],
        &["disconnect"],
        &["disconnected"],
        &["disconnecting"],
        &["disconnection"],
        &["disconnections"],
        &["disconnects"],
        &["disconnect"],
        &["disconnected"],
        &["disconnecting"],
        &["disconnection"],
        &["disconnections"],
        &["disconnects"],
        &["disconnect"],
        &["disconnected"],
        &["disconnecting"],
        &["disconnection"],
        &["disconnections"],
        &["disconnects"],
        &["disconnect"],
        &["disconnected"],
        &["disconnecting"],
        &["disconnection"],
        &["disconnections"],
        &["disconnects"],
        &["discuss"],
    ],
    range: 3..=10,
};

static WORD_DISCA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DISCA_CHILDREN),
    value: None,
};

pub static WORD_DISCA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("limer"),
        dictgen::InsensitiveStr::Ascii("pline"),
        dictgen::InsensitiveStr::Ascii("red"),
        dictgen::InsensitiveStr::Ascii("reded"),
        dictgen::InsensitiveStr::Ascii("rge"),
    ],
    values: &[
        &["disclaimer"],
        &["discipline"],
        &["discarded"],
        &["discarded"],
        &["discharge"],
    ],
    range: 3..=5,
};

static WORD_DISB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DISB_CHILDREN),
    value: None,
};

pub static WORD_DISB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ale"),
        dictgen::InsensitiveStr::Ascii("aled"),
        dictgen::InsensitiveStr::Ascii("ales"),
        dictgen::InsensitiveStr::Ascii("aling"),
        dictgen::InsensitiveStr::Ascii("eleif"),
        dictgen::InsensitiveStr::Ascii("elif"),
        dictgen::InsensitiveStr::Ascii("elife"),
        dictgen::InsensitiveStr::Ascii("le"),
        dictgen::InsensitiveStr::Ascii("led"),
    ],
    values: &[
        &["disable"],
        &["disabled"],
        &["disables"],
        &["disabling"],
        &["disbelief"],
        &["disbelief"],
        &["disbelief"],
        &["disable"],
        &["disabled"],
    ],
    range: 2..=5,
};

static WORD_DISA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_DISA_CHILDREN),
    value: None,
};

static WORD_DISA_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_DISAA_NODE),
    Some(&WORD_DISAB_NODE),
    None,
    Some(&WORD_DISAD_NODE),
    None,
    None,
    Some(&WORD_DISAG_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_DISAL_NODE),
    Some(&WORD_DISAM_NODE),
    None,
    None,
    Some(&WORD_DISAP_NODE),
    None,
    Some(&WORD_DISAR_NODE),
    Some(&WORD_DISAS_NODE),
    Some(&WORD_DISAT_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_DISAT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DISAT_CHILDREN),
    value: None,
};

pub static WORD_DISAT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("erous"),
        dictgen::InsensitiveStr::Ascii("isfaction"),
        dictgen::InsensitiveStr::Ascii("isfied"),
        dictgen::InsensitiveStr::Ascii("issfied"),
        dictgen::InsensitiveStr::Ascii("rous"),
        dictgen::InsensitiveStr::Ascii("vantage"),
        dictgen::InsensitiveStr::Ascii("vantaged"),
        dictgen::InsensitiveStr::Ascii("vantages"),
    ],
    values: &[
        &["disastrous"],
        &["dissatisfaction"],
        &["dissatisfied"],
        &["dissatisfied"],
        &["disastrous"],
        &["disadvantage"],
        &["disadvantaged"],
        &["disadvantages"],
    ],
    range: 4..=9,
};

static WORD_DISAS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DISAS_CHILDREN),
    value: None,
};

pub static WORD_DISAS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("embler"),
        dictgen::InsensitiveStr::Ascii("pointed"),
        dictgen::InsensitiveStr::Ascii("sebled"),
        dictgen::InsensitiveStr::Ascii("socate"),
        dictgen::InsensitiveStr::Ascii("socation"),
        dictgen::InsensitiveStr::Ascii("ssembler"),
        dictgen::InsensitiveStr::Ascii("terous"),
        dictgen::InsensitiveStr::Ascii("tisfied"),
        dictgen::InsensitiveStr::Ascii("torus"),
        dictgen::InsensitiveStr::Ascii("treous"),
        dictgen::InsensitiveStr::Ascii("trious"),
        dictgen::InsensitiveStr::Ascii("tros"),
        dictgen::InsensitiveStr::Ascii("trosa"),
        dictgen::InsensitiveStr::Ascii("trose"),
        dictgen::InsensitiveStr::Ascii("trosi"),
        dictgen::InsensitiveStr::Ascii("troso"),
        dictgen::InsensitiveStr::Ascii("truous"),
    ],
    values: &[
        &["disassembler"],
        &["disappointed"],
        &["disassembled"],
        &["disassociate"],
        &["disassociation"],
        &["disassembler"],
        &["disastrous"],
        &["dissatisfied"],
        &["disastrous"],
        &["disastrous"],
        &["disastrous"],
        &["disastrous"],
        &["disastrous"],
        &["disastrous"],
        &["disastrous"],
        &["disastrous"],
        &["disastrous"],
    ],
    range: 4..=8,
};

static WORD_DISAR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DISAR_CHILDREN),
    value: None,
};

pub static WORD_DISAR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("d"),
        dictgen::InsensitiveStr::Ascii("iable"),
    ],
    values: &[&["discard"], &["desirable"]],
    range: 1..=5,
};

static WORD_DISAP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DISAP_CHILDREN),
    value: None,
};

pub static WORD_DISAP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ait"),
        dictgen::InsensitiveStr::Ascii("aited"),
        dictgen::InsensitiveStr::Ascii("aiting"),
        dictgen::InsensitiveStr::Ascii("aits"),
        dictgen::InsensitiveStr::Ascii("at"),
        dictgen::InsensitiveStr::Ascii("ated"),
        dictgen::InsensitiveStr::Ascii("ating"),
        dictgen::InsensitiveStr::Ascii("ats"),
        dictgen::InsensitiveStr::Ascii("ear"),
        dictgen::InsensitiveStr::Ascii("eard"),
        dictgen::InsensitiveStr::Ascii("eared"),
        dictgen::InsensitiveStr::Ascii("earing"),
        dictgen::InsensitiveStr::Ascii("ears"),
        dictgen::InsensitiveStr::Ascii("line"),
        dictgen::InsensitiveStr::Ascii("oint"),
        dictgen::InsensitiveStr::Ascii("ointed"),
        dictgen::InsensitiveStr::Ascii("ointing"),
        dictgen::InsensitiveStr::Ascii("pared"),
        dictgen::InsensitiveStr::Ascii("pearaing"),
        dictgen::InsensitiveStr::Ascii("peard"),
        dictgen::InsensitiveStr::Ascii("pearence"),
        dictgen::InsensitiveStr::Ascii("pearnace"),
        dictgen::InsensitiveStr::Ascii("pearnce"),
        dictgen::InsensitiveStr::Ascii("pearred"),
        dictgen::InsensitiveStr::Ascii("pearring"),
        dictgen::InsensitiveStr::Ascii("per"),
        dictgen::InsensitiveStr::Ascii("peraing"),
        dictgen::InsensitiveStr::Ascii("perar"),
        dictgen::InsensitiveStr::Ascii("perarance"),
        dictgen::InsensitiveStr::Ascii("perared"),
        dictgen::InsensitiveStr::Ascii("perars"),
        dictgen::InsensitiveStr::Ascii("peread"),
        dictgen::InsensitiveStr::Ascii("pered"),
        dictgen::InsensitiveStr::Ascii("pering"),
        dictgen::InsensitiveStr::Ascii("pers"),
        dictgen::InsensitiveStr::Ascii("piont"),
        dictgen::InsensitiveStr::Ascii("pline"),
        dictgen::InsensitiveStr::Ascii("plined"),
        dictgen::InsensitiveStr::Ascii("plines"),
        dictgen::InsensitiveStr::Ascii("plining"),
        dictgen::InsensitiveStr::Ascii("plins"),
        dictgen::InsensitiveStr::Ascii("porval"),
        dictgen::InsensitiveStr::Ascii("porve"),
        dictgen::InsensitiveStr::Ascii("porved"),
        dictgen::InsensitiveStr::Ascii("porves"),
        dictgen::InsensitiveStr::Ascii("porving"),
        dictgen::InsensitiveStr::Ascii("prouval"),
        dictgen::InsensitiveStr::Ascii("prouve"),
        dictgen::InsensitiveStr::Ascii("prouved"),
        dictgen::InsensitiveStr::Ascii("prouves"),
        dictgen::InsensitiveStr::Ascii("prouving"),
        dictgen::InsensitiveStr::Ascii("provel"),
        dictgen::InsensitiveStr::Ascii("rity"),
        dictgen::InsensitiveStr::Ascii("roval"),
    ],
    values: &[
        &["dissipate"],
        &["dissipated"],
        &["dissipating"],
        &["dissipates"],
        &["dissipate"],
        &["dissipated"],
        &["dissipating"],
        &["dissipates"],
        &["disappear"],
        &["disappeared"],
        &["disappeared"],
        &["disappearing"],
        &["disappears"],
        &["discipline"],
        &["disappoint"],
        &["disappointed"],
        &["disappointing"],
        &["disappeared"],
        &["disappearing"],
        &["disappeared"],
        &["disappearance"],
        &["disappearance"],
        &["disappearance"],
        &["disappeared"],
        &["disappearing"],
        &["disappear"],
        &["disappearing"],
        &["disappear"],
        &["disappearance"],
        &["disappeared"],
        &["disappears"],
        &["disappeared"],
        &["disappeared"],
        &["disappearing"],
        &["disappears"],
        &["disappoint"],
        &["discipline"],
        &["disciplined"],
        &["disciplines"],
        &["disciplining"],
        &["disciplines"],
        &["disapproval"],
        &["disapprove"],
        &["disapproved"],
        &["disapproves"],
        &["disapproving"],
        &["disapproval"],
        &["disapprove"],
        &["disapproved"],
        &["disapproves"],
        &["disapproving"],
        &["disapproval"],
        &["disparity"],
        &["disapproval"],
    ],
    range: 2..=9,
};

static WORD_DISAM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DISAM_CHILDREN),
    value: None,
};

pub static WORD_DISAM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("bigouate"),
        dictgen::InsensitiveStr::Ascii("biguaiton"),
        dictgen::InsensitiveStr::Ascii("biguiation"),
    ],
    values: &[&["disambiguate"], &["disambiguation"], &["disambiguation"]],
    range: 8..=10,
};

static WORD_DISAL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DISAL_CHILDREN),
    value: None,
};

pub static WORD_DISAL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("b"),
        dictgen::InsensitiveStr::Ascii("be"),
        dictgen::InsensitiveStr::Ascii("bed"),
        dictgen::InsensitiveStr::Ascii("bes"),
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("lusioned"),
        dictgen::InsensitiveStr::Ascii("ow"),
    ],
    values: &[
        &["disable"],
        &["disable"],
        &["disabled"],
        &["disables"],
        &["disable"],
        &["disabled"],
        &["disillusioned"],
        &["disallow"],
    ],
    range: 1..=8,
};

static WORD_DISAG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DISAG_CHILDREN),
    value: None,
};

pub static WORD_DISAG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("red"),
        dictgen::InsensitiveStr::Ascii("reeed"),
        dictgen::InsensitiveStr::Ascii("reemet"),
        dictgen::InsensitiveStr::Ascii("reemtn"),
        dictgen::InsensitiveStr::Ascii("remeent"),
        dictgen::InsensitiveStr::Ascii("res"),
        dictgen::InsensitiveStr::Ascii("ress"),
    ],
    values: &[
        &["disagreed"],
        &["disagreed"],
        &["disagreements"],
        &["disagreements"],
        &["disagreements"],
        &["disagrees"],
        &["disagrees"],
    ],
    range: 3..=7,
};

static WORD_DISAD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DISAD_CHILDREN),
    value: None,
};

pub static WORD_DISAD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("vandage"),
        dictgen::InsensitiveStr::Ascii("vandages"),
        dictgen::InsensitiveStr::Ascii("vantadge"),
        dictgen::InsensitiveStr::Ascii("vanteged"),
        dictgen::InsensitiveStr::Ascii("vanteges"),
        dictgen::InsensitiveStr::Ascii("vantge"),
        dictgen::InsensitiveStr::Ascii("vantged"),
        dictgen::InsensitiveStr::Ascii("vantges"),
        dictgen::InsensitiveStr::Ascii("vatange"),
        dictgen::InsensitiveStr::Ascii("vatanges"),
        dictgen::InsensitiveStr::Ascii("ventage"),
        dictgen::InsensitiveStr::Ascii("ventaged"),
        dictgen::InsensitiveStr::Ascii("ventages"),
    ],
    values: &[
        &["disadvantaged"],
        &["disadvantaged"],
        &["disadvantaged", "disadvantage"],
        &["disadvantaged"],
        &["disadvantages"],
        &["disadvantage"],
        &["disadvantaged"],
        &["disadvantages"],
        &["disadvantage"],
        &["disadvantages"],
        &["disadvantage"],
        &["disadvantaged"],
        &["disadvantages"],
    ],
    range: 6..=8,
};

static WORD_DISAB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DISAB_CHILDREN),
    value: None,
};

pub static WORD_DISAB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("eld"),
        dictgen::InsensitiveStr::Ascii("eling"),
        dictgen::InsensitiveStr::Ascii("els"),
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("ilitiles"),
        dictgen::InsensitiveStr::Ascii("ilitily"),
        dictgen::InsensitiveStr::Ascii("iltities"),
        dictgen::InsensitiveStr::Ascii("iltitiy"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("l"),
        dictgen::InsensitiveStr::Ascii("lle"),
    ],
    values: &[
        &["disable"],
        &["disabled"],
        &["disabled"],
        &["disabling"],
        &["disables"],
        &["disables"],
        &["disabilities"],
        &["disability"],
        &["disabilities"],
        &["disability"],
        &["disabling"],
        &["disable"],
        &["disable"],
    ],
    range: 1..=8,
};

static WORD_DISAA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DISAA_CHILDREN),
    value: None,
};

pub static WORD_DISAA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("point"),
        dictgen::InsensitiveStr::Ascii("pointed"),
    ],
    values: &[&["disappoint"], &["disappointed"]],
    range: 5..=7,
};

static WORD_DIR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_DIR_CHILDREN),
    value: None,
};

static WORD_DIR_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    Some(&WORD_DIRB_NODE),
    Some(&WORD_DIRC_NODE),
    None,
    Some(&WORD_DIRE_NODE),
    Some(&WORD_DIRF_NODE),
    None,
    None,
    Some(&WORD_DIRI_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_DIRR_NODE),
    None,
    Some(&WORD_DIRT_NODE),
    None,
    Some(&WORD_DIRV_NODE),
    None,
    None,
    None,
    None,
];

static WORD_DIRV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DIRV_CHILDREN),
    value: None,
};

pub static WORD_DIRV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("er"),
        dictgen::InsensitiveStr::Ascii("ers"),
    ],
    values: &[&["driver"], &["drivers"]],
    range: 2..=3,
};

static WORD_DIRT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DIRT_CHILDREN),
    value: None,
};

pub static WORD_DIRT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ectory"),
        dictgen::InsensitiveStr::Ascii("yed"),
        dictgen::InsensitiveStr::Ascii("yness"),
    ],
    values: &[&["directory"], &["dirtied"], &["dirtiness"]],
    range: 3..=6,
};

static WORD_DIRR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DIRR_CHILDREN),
    value: None,
};

pub static WORD_DIRR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ectly")],
    values: &[&["directly"]],
    range: 5..=5,
};

static WORD_DIRI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DIRI_CHILDREN),
    value: None,
};

pub static WORD_DIRI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ved")],
    values: &[&["derived"]],
    range: 3..=3,
};

static WORD_DIRF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DIRF_CHILDREN),
    value: None,
};

pub static WORD_DIRF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ting")],
    values: &[&["drifting"]],
    range: 4..=4,
};

static WORD_DIRE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_DIRE_CHILDREN),
    value: None,
};

static WORD_DIRE_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    Some(&WORD_DIREC_NODE),
    None,
    Some(&WORD_DIREE_NODE),
    None,
    Some(&WORD_DIREG_NODE),
    None,
    None,
    None,
    Some(&WORD_DIREK_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_DIRER_NODE),
    None,
    Some(&WORD_DIRET_NODE),
    None,
    Some(&WORD_DIREV_NODE),
    None,
    None,
    None,
    None,
];

static WORD_DIREV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DIREV_CHILDREN),
    value: None,
};

pub static WORD_DIREV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ctory")],
    values: &[&["directory"]],
    range: 5..=5,
};

static WORD_DIRET_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DIRET_CHILDREN),
    value: None,
};

pub static WORD_DIRET_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cx"),
        dictgen::InsensitiveStr::Ascii("ive"),
        dictgen::InsensitiveStr::Ascii("ly"),
        dictgen::InsensitiveStr::Ascii("ories"),
        dictgen::InsensitiveStr::Ascii("ory"),
    ],
    values: &[
        &["directx"],
        &["directive"],
        &["directly"],
        &["directories"],
        &["directory"],
    ],
    range: 2..=5,
};

static WORD_DIRER_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DIRER_CHILDREN),
    value: None,
};

pub static WORD_DIRER_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ctor"),
        dictgen::InsensitiveStr::Ascii("ctories"),
        dictgen::InsensitiveStr::Ascii("ctors"),
        dictgen::InsensitiveStr::Ascii("ctory"),
    ],
    values: &[
        &["director"],
        &["directories"],
        &["directors"],
        &["directory"],
    ],
    range: 4..=7,
};

static WORD_DIREK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DIREK_CHILDREN),
    value: None,
};

pub static WORD_DIREK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("tional"),
        dictgen::InsensitiveStr::Ascii("tly"),
    ],
    values: &[&["directional"], &["directly"]],
    range: 3..=6,
};

static WORD_DIREG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DIREG_CHILDREN),
    value: None,
};

pub static WORD_DIREG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ard")],
    values: &[&["disregard"]],
    range: 3..=3,
};

static WORD_DIREE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DIREE_CHILDREN),
    value: None,
};

pub static WORD_DIREE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ctly")],
    values: &[&["directly"]],
    range: 4..=4,
};

static WORD_DIREC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_DIREC_CHILDREN),
    value: None,
};

static WORD_DIREC_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    Some(&WORD_DIRECC_NODE),
    Some(&WORD_DIRECD_NODE),
    Some(&WORD_DIRECE_NODE),
    None,
    None,
    None,
    Some(&WORD_DIRECI_NODE),
    None,
    None,
    Some(&WORD_DIRECL_NODE),
    None,
    None,
    Some(&WORD_DIRECO_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_DIRECT_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_DIRECT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DIRECT_CHILDREN),
    value: None,
};

pub static WORD_DIRECT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("d"),
        dictgen::InsensitiveStr::Ascii("ely"),
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("gories"),
        dictgen::InsensitiveStr::Ascii("gory"),
        dictgen::InsensitiveStr::Ascii("in"),
        dictgen::InsensitiveStr::Ascii("inla"),
        dictgen::InsensitiveStr::Ascii("iona"),
        dictgen::InsensitiveStr::Ascii("ionl"),
        dictgen::InsensitiveStr::Ascii("ionnal"),
        dictgen::InsensitiveStr::Ascii("iories"),
        dictgen::InsensitiveStr::Ascii("iory"),
        dictgen::InsensitiveStr::Ascii("ivos"),
        dictgen::InsensitiveStr::Ascii("ix"),
        dictgen::InsensitiveStr::Ascii("oies"),
        dictgen::InsensitiveStr::Ascii("on"),
        dictgen::InsensitiveStr::Ascii("oories"),
        dictgen::InsensitiveStr::Ascii("oory"),
        dictgen::InsensitiveStr::Ascii("ores"),
        dictgen::InsensitiveStr::Ascii("orguy"),
        dictgen::InsensitiveStr::Ascii("oriei"),
        dictgen::InsensitiveStr::Ascii("orios"),
        dictgen::InsensitiveStr::Ascii("oris"),
        dictgen::InsensitiveStr::Ascii("ort"),
        dictgen::InsensitiveStr::Ascii("orty"),
        dictgen::InsensitiveStr::Ascii("orys"),
        dictgen::InsensitiveStr::Ascii("os"),
        dictgen::InsensitiveStr::Ascii("oty"),
        dictgen::InsensitiveStr::Ascii("ove"),
        dictgen::InsensitiveStr::Ascii("oves"),
        dictgen::InsensitiveStr::Ascii("oy"),
        dictgen::InsensitiveStr::Ascii("pries"),
        dictgen::InsensitiveStr::Ascii("pry"),
        dictgen::InsensitiveStr::Ascii("ries"),
        dictgen::InsensitiveStr::Ascii("rive"),
        dictgen::InsensitiveStr::Ascii("rives"),
        dictgen::InsensitiveStr::Ascii("rly"),
        dictgen::InsensitiveStr::Ascii("roies"),
        dictgen::InsensitiveStr::Ascii("rories"),
        dictgen::InsensitiveStr::Ascii("rory"),
        dictgen::InsensitiveStr::Ascii("roy"),
        dictgen::InsensitiveStr::Ascii("rx"),
        dictgen::InsensitiveStr::Ascii("ry"),
        dictgen::InsensitiveStr::Ascii("sion"),
        dictgen::InsensitiveStr::Ascii("sions"),
        dictgen::InsensitiveStr::Ascii("song"),
        dictgen::InsensitiveStr::Ascii("tories"),
        dictgen::InsensitiveStr::Ascii("tory"),
        dictgen::InsensitiveStr::Ascii("y"),
    ],
    values: &[
        &["directed"],
        &["directly"],
        &["directs"],
        &["directories"],
        &["directory"],
        &["directions", "directing", "direction"],
        &["directional"],
        &["directional", "directions"],
        &["directional"],
        &["directional"],
        &["directories"],
        &["directory"],
        &["directions"],
        &["directx"],
        &["directories"],
        &["direction"],
        &["directories"],
        &["directory"],
        &["directors", "directories"],
        &["directory"],
        &["directories"],
        &["directors"],
        &["directories"],
        &["directory"],
        &["directory"],
        &["directors", "directories"],
        &["directors"],
        &["directory"],
        &["directive"],
        &["directives"],
        &["directory"],
        &["directories"],
        &["directory"],
        &["directories"],
        &["directive"],
        &["directives"],
        &["directly"],
        &["directories"],
        &["directories"],
        &["directory"],
        &["directory"],
        &["directx"],
        &["directory"],
        &["direction"],
        &["directions"],
        &["directions"],
        &["directories"],
        &["directory"],
        &["directly"],
    ],
    range: 1..=6,
};

static WORD_DIRECO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DIRECO_CHILDREN),
    value: None,
};

pub static WORD_DIRECO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ries"),
        dictgen::InsensitiveStr::Ascii("ry"),
        dictgen::InsensitiveStr::Ascii("tories"),
        dictgen::InsensitiveStr::Ascii("tory"),
        dictgen::InsensitiveStr::Ascii("tries"),
        dictgen::InsensitiveStr::Ascii("try"),
        dictgen::InsensitiveStr::Ascii("ty"),
    ],
    values: &[
        &["directories"],
        &["directory"],
        &["directories"],
        &["directory"],
        &["directories"],
        &["directory"],
        &["directory"],
    ],
    range: 2..=6,
};

static WORD_DIRECL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DIRECL_CHILDREN),
    value: None,
};

pub static WORD_DIRECL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ty"),
        dictgen::InsensitiveStr::Ascii("y"),
    ],
    values: &[&["directly"], &["directly"]],
    range: 1..=2,
};

static WORD_DIRECI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DIRECI_CHILDREN),
    value: None,
};

pub static WORD_DIRECI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("on"),
        dictgen::InsensitiveStr::Ascii("ons"),
        dictgen::InsensitiveStr::Ascii("ton"),
        dictgen::InsensitiveStr::Ascii("tonal"),
        dictgen::InsensitiveStr::Ascii("tons"),
        dictgen::InsensitiveStr::Ascii("tve"),
        dictgen::InsensitiveStr::Ascii("tves"),
    ],
    values: &[
        &["direction"],
        &["directions"],
        &["direction"],
        &["directional"],
        &["directions"],
        &["directive"],
        &["directives"],
    ],
    range: 2..=5,
};

static WORD_DIRECE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DIRECE_CHILDREN),
    value: None,
};

pub static WORD_DIRECE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("tories"),
        dictgen::InsensitiveStr::Ascii("tory"),
    ],
    values: &[&["directories"], &["directory"]],
    range: 4..=6,
};

static WORD_DIRECD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DIRECD_CHILDREN),
    value: None,
};

pub static WORD_DIRECD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ories"),
        dictgen::InsensitiveStr::Ascii("ory"),
        dictgen::InsensitiveStr::Ascii("orys"),
    ],
    values: &[&["directories"], &["directory"], &["directories"]],
    range: 3..=5,
};

static WORD_DIRECC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DIRECC_CHILDREN),
    value: None,
};

pub static WORD_DIRECC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ion"),
        dictgen::InsensitiveStr::Ascii("ional"),
        dictgen::InsensitiveStr::Ascii("tly"),
        dictgen::InsensitiveStr::Ascii("tory"),
        dictgen::InsensitiveStr::Ascii("torys"),
        dictgen::InsensitiveStr::Ascii("tries"),
    ],
    values: &[
        &["direction"],
        &["directional"],
        &["directly"],
        &["directory"],
        &["directories"],
        &["directories"],
    ],
    range: 3..=5,
};

static WORD_DIRC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DIRC_CHILDREN),
    value: None,
};

pub static WORD_DIRC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("et"),
        dictgen::InsensitiveStr::Ascii("etories"),
        dictgen::InsensitiveStr::Ascii("etory"),
        dictgen::InsensitiveStr::Ascii("tly"),
        dictgen::InsensitiveStr::Ascii("tories"),
        dictgen::InsensitiveStr::Ascii("tory"),
    ],
    values: &[
        &["direct"],
        &["directories"],
        &["directory"],
        &["directly"],
        &["directories"],
        &["directory"],
    ],
    range: 2..=7,
};

static WORD_DIRB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DIRB_CHILDREN),
    value: None,
};

pub static WORD_DIRB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ble")],
    values: &[&["dribble"]],
    range: 3..=3,
};

static WORD_DIP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DIP_CHILDREN),
    value: None,
};

pub static WORD_DIP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ections"),
        dictgen::InsensitiveStr::Ascii("htong"),
        dictgen::InsensitiveStr::Ascii("htongs"),
        dictgen::InsensitiveStr::Ascii("lacement"),
        dictgen::InsensitiveStr::Ascii("lay"),
        dictgen::InsensitiveStr::Ascii("layed"),
        dictgen::InsensitiveStr::Ascii("laying"),
        dictgen::InsensitiveStr::Ascii("lays"),
        dictgen::InsensitiveStr::Ascii("limatic"),
        dictgen::InsensitiveStr::Ascii("lomacia"),
        dictgen::InsensitiveStr::Ascii("lomancy"),
        dictgen::InsensitiveStr::Ascii("lomatisch"),
        dictgen::InsensitiveStr::Ascii("lomma"),
        dictgen::InsensitiveStr::Ascii("olma"),
        dictgen::InsensitiveStr::Ascii("olmatic"),
        dictgen::InsensitiveStr::Ascii("ose"),
        dictgen::InsensitiveStr::Ascii("osed"),
        dictgen::InsensitiveStr::Ascii("osing"),
        dictgen::InsensitiveStr::Ascii("osition"),
        dictgen::InsensitiveStr::Ascii("theria"),
        dictgen::InsensitiveStr::Ascii("thong"),
        dictgen::InsensitiveStr::Ascii("thongs"),
    ],
    values: &[
        &["depictions"],
        &["diphthong"],
        &["diphthongs"],
        &["displacement"],
        &["display"],
        &["displayed"],
        &["displaying"],
        &["displays"],
        &["diplomatic"],
        &["diplomatic"],
        &["diplomacy"],
        &["diplomatic"],
        &["diploma"],
        &["diploma"],
        &["diplomatic"],
        &["dispose", "depose"],
        &["disposed", "deposed"],
        &["disposing", "deposing"],
        &["disposition"],
        &["diphtheria"],
        &["diphthong"],
        &["diphthongs"],
    ],
    range: 3..=9,
};

static WORD_DIO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DIO_CHILDREN),
    value: None,
};

pub static WORD_DIO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ng"),
        dictgen::InsensitiveStr::Ascii("nsaur"),
        dictgen::InsensitiveStr::Ascii("nsaurs"),
        dictgen::InsensitiveStr::Ascii("reha"),
        dictgen::InsensitiveStr::Ascii("sese"),
    ],
    values: &[
        &["doing"],
        &["dinosaur"],
        &["dinosaurs"],
        &["diarrhea"],
        &["diocese"],
    ],
    range: 2..=6,
};

static WORD_DIN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DIN_CHILDREN),
    value: None,
};

pub static WORD_DIN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("amic"),
        dictgen::InsensitiveStr::Ascii("amically"),
        dictgen::InsensitiveStr::Ascii("amicaly"),
        dictgen::InsensitiveStr::Ascii("amiclly"),
        dictgen::InsensitiveStr::Ascii("amicly"),
        dictgen::InsensitiveStr::Ascii("asour"),
        dictgen::InsensitiveStr::Ascii("asours"),
        dictgen::InsensitiveStr::Ascii("gee"),
        dictgen::InsensitiveStr::Ascii("gees"),
        dictgen::InsensitiveStr::Ascii("ghys"),
        dictgen::InsensitiveStr::Ascii("gity"),
        dictgen::InsensitiveStr::Ascii("maic"),
        dictgen::InsensitiveStr::Ascii("osar"),
        dictgen::InsensitiveStr::Ascii("osaures"),
        dictgen::InsensitiveStr::Ascii("osaurios"),
        dictgen::InsensitiveStr::Ascii("osaurus"),
        dictgen::InsensitiveStr::Ascii("osaus"),
        dictgen::InsensitiveStr::Ascii("osuar"),
        dictgen::InsensitiveStr::Ascii("osuars"),
        dictgen::InsensitiveStr::Ascii("soaur"),
        dictgen::InsensitiveStr::Ascii("soaurs"),
        dictgen::InsensitiveStr::Ascii("teractively"),
    ],
    values: &[
        &["dynamic"],
        &["dynamically"],
        &["dynamically"],
        &["dynamically"],
        &["dynamically"],
        &["dinosaur"],
        &["dinosaurs"],
        &["dinghy"],
        &["dinghies"],
        &["dinghies"],
        &["dignity"],
        &["dynamic"],
        &["dinosaur"],
        &["dinosaurs"],
        &["dinosaurs"],
        &["dinosaurs"],
        &["dinosaurs"],
        &["dinosaur"],
        &["dinosaurs"],
        &["dinosaur"],
        &["dinosaurs"],
        &["interactively"],
    ],
    range: 3..=11,
};

static WORD_DIM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DIM_CHILDREN),
    value: None,
};

pub static WORD_DIM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("and"),
        dictgen::InsensitiveStr::Ascii("ands"),
        dictgen::InsensitiveStr::Ascii("ansion"),
        dictgen::InsensitiveStr::Ascii("ansional"),
        dictgen::InsensitiveStr::Ascii("ansions"),
        dictgen::InsensitiveStr::Ascii("aond"),
        dictgen::InsensitiveStr::Ascii("aonds"),
        dictgen::InsensitiveStr::Ascii("emsions"),
        dictgen::InsensitiveStr::Ascii("enion"),
        dictgen::InsensitiveStr::Ascii("enional"),
        dictgen::InsensitiveStr::Ascii("enionalities"),
        dictgen::InsensitiveStr::Ascii("enionality"),
        dictgen::InsensitiveStr::Ascii("enions"),
        dictgen::InsensitiveStr::Ascii("enionsal"),
        dictgen::InsensitiveStr::Ascii("enionsalities"),
        dictgen::InsensitiveStr::Ascii("enionsality"),
        dictgen::InsensitiveStr::Ascii("enison"),
        dictgen::InsensitiveStr::Ascii("ensinal"),
        dictgen::InsensitiveStr::Ascii("ensinoal"),
        dictgen::InsensitiveStr::Ascii("ensinos"),
        dictgen::InsensitiveStr::Ascii("ensionaility"),
        dictgen::InsensitiveStr::Ascii("ensionals"),
        dictgen::InsensitiveStr::Ascii("ensiones"),
        dictgen::InsensitiveStr::Ascii("ensionnal"),
        dictgen::InsensitiveStr::Ascii("ensionsal"),
        dictgen::InsensitiveStr::Ascii("ensonal"),
        dictgen::InsensitiveStr::Ascii("enstion"),
        dictgen::InsensitiveStr::Ascii("enstions"),
        dictgen::InsensitiveStr::Ascii("ention"),
        dictgen::InsensitiveStr::Ascii("entional"),
        dictgen::InsensitiveStr::Ascii("entionnal"),
        dictgen::InsensitiveStr::Ascii("entionnals"),
        dictgen::InsensitiveStr::Ascii("entions"),
        dictgen::InsensitiveStr::Ascii("esions"),
        dictgen::InsensitiveStr::Ascii("esnion"),
        dictgen::InsensitiveStr::Ascii("esnional"),
        dictgen::InsensitiveStr::Ascii("esnions"),
        dictgen::InsensitiveStr::Ascii("ineshes"),
        dictgen::InsensitiveStr::Ascii("inisheds"),
        dictgen::InsensitiveStr::Ascii("inishs"),
        dictgen::InsensitiveStr::Ascii("inising"),
        dictgen::InsensitiveStr::Ascii("insh"),
        dictgen::InsensitiveStr::Ascii("inshed"),
        dictgen::InsensitiveStr::Ascii("insihing"),
        dictgen::InsensitiveStr::Ascii("inuitive"),
        dictgen::InsensitiveStr::Ascii("inushing"),
        dictgen::InsensitiveStr::Ascii("issed"),
        dictgen::InsensitiveStr::Ascii("mension"),
        dictgen::InsensitiveStr::Ascii("mensioned"),
        dictgen::InsensitiveStr::Ascii("mensioning"),
        dictgen::InsensitiveStr::Ascii("mensions"),
        dictgen::InsensitiveStr::Ascii("nension"),
        dictgen::InsensitiveStr::Ascii("nention"),
        dictgen::InsensitiveStr::Ascii("ond"),
        dictgen::InsensitiveStr::Ascii("onds"),
        dictgen::InsensitiveStr::Ascii("unitive"),
    ],
    values: &[
        &["demand", "diamond"],
        &["demands", "diamonds"],
        &["dimension"],
        &["dimensional"],
        &["dimensions"],
        &["diamond"],
        &["diamonds"],
        &["dimensions"],
        &["dimension", "dominion"],
        &["dimensional"],
        &["dimensionalities"],
        &["dimensionality"],
        &["dimensions"],
        &["dimensional"],
        &["dimensionalities"],
        &["dimensionality"],
        &["dimension"],
        &["dimensional"],
        &["dimensional"],
        &["dimensions"],
        &["dimensionality"],
        &["dimensions"],
        &["dimensions"],
        &["dimensional"],
        &["dimensional"],
        &["dimensional"],
        &["dimension"],
        &["dimensions"],
        &["dimension"],
        &["dimensional"],
        &["dimensional"],
        &["dimensional"],
        &["dimensions"],
        &["dimensions"],
        &["dimension"],
        &["dimensional"],
        &["dimensions"],
        &["diminishes"],
        &["diminishes"],
        &["diminishes"],
        &["diminishing"],
        &["diminish"],
        &["diminished"],
        &["diminishing"],
        &["diminutive"],
        &["diminishing"],
        &["dismissed"],
        &["dimension"],
        &["dimensioned"],
        &["dimensioning"],
        &["dimensions"],
        &["dimension"],
        &["dimension"],
        &["diamond"],
        &["diamonds"],
        &["diminutive"],
    ],
    range: 3..=13,
};

static WORD_DIL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DIL_CHILDREN),
    value: None,
};

pub static WORD_DIL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ema"),
        dictgen::InsensitiveStr::Ascii("emas"),
        dictgen::InsensitiveStr::Ascii("ineate"),
        dictgen::InsensitiveStr::Ascii("lema"),
        dictgen::InsensitiveStr::Ascii("lemas"),
        dictgen::InsensitiveStr::Ascii("ligence"),
        dictgen::InsensitiveStr::Ascii("ligent"),
        dictgen::InsensitiveStr::Ascii("ligently"),
        dictgen::InsensitiveStr::Ascii("limport"),
        dictgen::InsensitiveStr::Ascii("poma"),
    ],
    values: &[
        &["dilemma"],
        &["dilemmas"],
        &["delineate"],
        &["dilemma"],
        &["dilemmas"],
        &["diligence"],
        &["diligent"],
        &["diligently"],
        &["dllimport"],
        &["diploma"],
    ],
    range: 3..=8,
};

static WORD_DIG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DIG_CHILDREN),
    value: None,
};

pub static WORD_DIG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("anose"),
        dictgen::InsensitiveStr::Ascii("anosed"),
        dictgen::InsensitiveStr::Ascii("anosis"),
        dictgen::InsensitiveStr::Ascii("anostic"),
        dictgen::InsensitiveStr::Ascii("esty"),
        dictgen::InsensitiveStr::Ascii("git"),
        dictgen::InsensitiveStr::Ascii("gital"),
        dictgen::InsensitiveStr::Ascii("gits"),
        dictgen::InsensitiveStr::Ascii("ial"),
        dictgen::InsensitiveStr::Ascii("ist"),
        dictgen::InsensitiveStr::Ascii("itial"),
        dictgen::InsensitiveStr::Ascii("itis"),
        dictgen::InsensitiveStr::Ascii("nitiy"),
        dictgen::InsensitiveStr::Ascii("nostics"),
    ],
    values: &[
        &["diagnose"],
        &["diagnosed"],
        &["diagnosis"],
        &["diagnostic"],
        &["digest"],
        &["digit"],
        &["digital"],
        &["digits"],
        &["digital"],
        &["digits"],
        &["digital"],
        &["digits"],
        &["dignity"],
        &["diagnostics"],
    ],
    range: 3..=7,
};

static WORD_DIF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_DIF_CHILDREN),
    value: None,
};

static WORD_DIF_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    None,
    None,
    Some(&WORD_DIFE_NODE),
    Some(&WORD_DIFF_NODE),
    None,
    None,
    Some(&WORD_DIFI_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_DIFR_NODE),
    None,
    None,
    Some(&WORD_DIFU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_DIFU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DIFU_CHILDREN),
    value: None,
};

pub static WORD_DIFU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("se"),
        dictgen::InsensitiveStr::Ascii("sed"),
        dictgen::InsensitiveStr::Ascii("ses"),
        dictgen::InsensitiveStr::Ascii("ssion"),
        dictgen::InsensitiveStr::Ascii("ssive"),
    ],
    values: &[
        &["diffuse", "defuse"],
        &["diffused", "defused"],
        &["diffuses", "defused"],
        &["diffusion"],
        &["diffusive"],
    ],
    range: 2..=5,
};

static WORD_DIFR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DIFR_CHILDREN),
    value: None,
};

pub static WORD_DIFR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("act"),
        dictgen::InsensitiveStr::Ascii("acted"),
        dictgen::InsensitiveStr::Ascii("action"),
        dictgen::InsensitiveStr::Ascii("active"),
    ],
    values: &[
        &["diffract"],
        &["diffracted"],
        &["diffraction"],
        &["diffractive"],
    ],
    range: 3..=6,
};

static WORD_DIFI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DIFI_CHILDREN),
    value: None,
};

pub static WORD_DIFI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("culties"),
        dictgen::InsensitiveStr::Ascii("culty"),
        dictgen::InsensitiveStr::Ascii("ne"),
        dictgen::InsensitiveStr::Ascii("ned"),
        dictgen::InsensitiveStr::Ascii("nes"),
        dictgen::InsensitiveStr::Ascii("ning"),
        dictgen::InsensitiveStr::Ascii("nition"),
        dictgen::InsensitiveStr::Ascii("nitions"),
    ],
    values: &[
        &["difficulties"],
        &["difficulty"],
        &["define", "divine"],
        &["defined", "divined"],
        &["defines", "divines"],
        &["defining", "divining"],
        &["definition"],
        &["definitions"],
    ],
    range: 2..=7,
};

static WORD_DIFF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_DIFF_CHILDREN),
    value: None,
};

static WORD_DIFF_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    Some(&WORD_DIFFC_NODE),
    None,
    Some(&WORD_DIFFE_NODE),
    Some(&WORD_DIFFF_NODE),
    None,
    None,
    Some(&WORD_DIFFI_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_DIFFR_NODE),
    None,
    None,
    Some(&WORD_DIFFU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_DIFFU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DIFFU_CHILDREN),
    value: None,
};

pub static WORD_DIFFU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cult"),
        dictgen::InsensitiveStr::Ascii("culties"),
        dictgen::InsensitiveStr::Ascii("culty"),
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("lt"),
        dictgen::InsensitiveStr::Ascii("ssion"),
        dictgen::InsensitiveStr::Ascii("ssive"),
    ],
    values: &[
        &["difficult"],
        &["difficulties"],
        &["difficulty"],
        &["defuse", "diffuse"],
        &["difficult"],
        &["diffusion"],
        &["diffusive"],
    ],
    range: 2..=7,
};

static WORD_DIFFR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DIFFR_CHILDREN),
    value: None,
};

pub static WORD_DIFFR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eences"),
        dictgen::InsensitiveStr::Ascii("eent"),
        dictgen::InsensitiveStr::Ascii("eents"),
        dictgen::InsensitiveStr::Ascii("ence"),
        dictgen::InsensitiveStr::Ascii("ences"),
        dictgen::InsensitiveStr::Ascii("ent"),
        dictgen::InsensitiveStr::Ascii("ential"),
        dictgen::InsensitiveStr::Ascii("entiate"),
        dictgen::InsensitiveStr::Ascii("entiated"),
        dictgen::InsensitiveStr::Ascii("ently"),
        dictgen::InsensitiveStr::Ascii("ents"),
        dictgen::InsensitiveStr::Ascii("erence"),
        dictgen::InsensitiveStr::Ascii("erences"),
    ],
    values: &[
        &["differences"],
        &["different"],
        &["different", "difference"],
        &["difference"],
        &["differences"],
        &["different"],
        &["differential"],
        &["differentiate"],
        &["differentiated"],
        &["differently"],
        &["different", "difference"],
        &["difference"],
        &["differences"],
    ],
    range: 3..=8,
};

static WORD_DIFFI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DIFFI_CHILDREN),
    value: None,
};

pub static WORD_DIFFI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cault"),
        dictgen::InsensitiveStr::Ascii("caulties"),
        dictgen::InsensitiveStr::Ascii("caulty"),
        dictgen::InsensitiveStr::Ascii("culites"),
        dictgen::InsensitiveStr::Ascii("culity"),
        dictgen::InsensitiveStr::Ascii("culte"),
        dictgen::InsensitiveStr::Ascii("cultes"),
        dictgen::InsensitiveStr::Ascii("cults"),
        dictgen::InsensitiveStr::Ascii("culy"),
        dictgen::InsensitiveStr::Ascii("cut"),
        dictgen::InsensitiveStr::Ascii("cutl"),
        dictgen::InsensitiveStr::Ascii("cutlies"),
        dictgen::InsensitiveStr::Ascii("cutly"),
        dictgen::InsensitiveStr::Ascii("rentiate"),
    ],
    values: &[
        &["difficult"],
        &["difficulties"],
        &["difficulty"],
        &["difficulties"],
        &["difficulty"],
        &["difficulties"],
        &["difficulties"],
        &["difficulties", "difficult"],
        &["difficulty"],
        &["difficulty"],
        &["difficult"],
        &["difficulties"],
        &["difficulty"],
        &["differentiate"],
    ],
    range: 3..=8,
};

static WORD_DIFFF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DIFFF_CHILDREN),
    value: None,
};

pub static WORD_DIFFF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ered"),
        dictgen::InsensitiveStr::Ascii("erence"),
        dictgen::InsensitiveStr::Ascii("erences"),
        dictgen::InsensitiveStr::Ascii("erent"),
        dictgen::InsensitiveStr::Ascii("erently"),
        dictgen::InsensitiveStr::Ascii("ers"),
    ],
    values: &[
        &["differed"],
        &["difference"],
        &["differences"],
        &["different"],
        &["differently"],
        &["differs"],
    ],
    range: 3..=7,
};

static WORD_DIFFE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_DIFFE_CHILDREN),
    value: None,
};

static WORD_DIFFE_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    None,
    None,
    Some(&WORD_DIFFEE_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_DIFFEN_NODE),
    None,
    None,
    None,
    Some(&WORD_DIFFER_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_DIFFER_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_DIFFER_CHILDREN),
    value: None,
};

static WORD_DIFFER_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_DIFFERA_NODE),
    None,
    None,
    None,
    Some(&WORD_DIFFERE_NODE),
    None,
    None,
    None,
    Some(&WORD_DIFFERI_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_DIFFERN_NODE),
    None,
    None,
    None,
    Some(&WORD_DIFFERR_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_DIFFERR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DIFFERR_CHILDREN),
    value: None,
};

pub static WORD_DIFFERR_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("ed"),
            dictgen::InsensitiveStr::Ascii("ence"),
            dictgen::InsensitiveStr::Ascii("ences"),
            dictgen::InsensitiveStr::Ascii("ent"),
            dictgen::InsensitiveStr::Ascii("ently"),
        ],
        values: &[
            &["differed"],
            &["difference"],
            &["differences"],
            &["different"],
            &["differently"],
        ],
        range: 2..=5,
    };

static WORD_DIFFERN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DIFFERN_CHILDREN),
    value: None,
};

pub static WORD_DIFFERN_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("ce"),
            dictgen::InsensitiveStr::Ascii("ces"),
            dictgen::InsensitiveStr::Ascii("ciate"),
            dictgen::InsensitiveStr::Ascii("ec"),
            dictgen::InsensitiveStr::Ascii("ece"),
            dictgen::InsensitiveStr::Ascii("eces"),
            dictgen::InsensitiveStr::Ascii("ecs"),
            dictgen::InsensitiveStr::Ascii("ence"),
            dictgen::InsensitiveStr::Ascii("ences"),
            dictgen::InsensitiveStr::Ascii("encing"),
            dictgen::InsensitiveStr::Ascii("ent"),
            dictgen::InsensitiveStr::Ascii("et"),
            dictgen::InsensitiveStr::Ascii("etial"),
            dictgen::InsensitiveStr::Ascii("etiate"),
            dictgen::InsensitiveStr::Ascii("etiated"),
            dictgen::InsensitiveStr::Ascii("etly"),
            dictgen::InsensitiveStr::Ascii("t"),
            dictgen::InsensitiveStr::Ascii("tiable"),
            dictgen::InsensitiveStr::Ascii("tial"),
            dictgen::InsensitiveStr::Ascii("tials"),
            dictgen::InsensitiveStr::Ascii("tiate"),
            dictgen::InsensitiveStr::Ascii("tiated"),
            dictgen::InsensitiveStr::Ascii("tiates"),
            dictgen::InsensitiveStr::Ascii("tiating"),
            dictgen::InsensitiveStr::Ascii("tly"),
            dictgen::InsensitiveStr::Ascii("ty"),
        ],
        values: &[
            &["difference"],
            &["differences"],
            &["differentiate"],
            &["difference"],
            &["difference"],
            &["differences"],
            &["differences"],
            &["difference"],
            &["differences"],
            &["differencing"],
            &["different"],
            &["different"],
            &["differential"],
            &["differentiate"],
            &["differentiated"],
            &["differently"],
            &["different"],
            &["differentiable"],
            &["differential"],
            &["differentials"],
            &["differentiate"],
            &["differentiated"],
            &["differentiates"],
            &["differentiating"],
            &["differently"],
            &["different", "differently"],
        ],
        range: 1..=7,
    };

static WORD_DIFFERI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DIFFERI_CHILDREN),
    value: None,
};

pub static WORD_DIFFERI_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("entation"),
            dictgen::InsensitiveStr::Ascii("ntiate"),
        ],
        values: &[&["differentiation"], &["differentiate"]],
        range: 6..=8,
    };

static WORD_DIFFERE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DIFFERE_CHILDREN),
    value: None,
};

pub static WORD_DIFFERE_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("ce"),
            dictgen::InsensitiveStr::Ascii("ct"),
            dictgen::InsensitiveStr::Ascii("n"),
            dictgen::InsensitiveStr::Ascii("ncess"),
            dictgen::InsensitiveStr::Ascii("ncial"),
            dictgen::InsensitiveStr::Ascii("nciate"),
            dictgen::InsensitiveStr::Ascii("nciated"),
            dictgen::InsensitiveStr::Ascii("nciates"),
            dictgen::InsensitiveStr::Ascii("nciating"),
            dictgen::InsensitiveStr::Ascii("nciation"),
            dictgen::InsensitiveStr::Ascii("nciations"),
            dictgen::InsensitiveStr::Ascii("ncies"),
            dictgen::InsensitiveStr::Ascii("nct"),
            dictgen::InsensitiveStr::Ascii("nd"),
            dictgen::InsensitiveStr::Ascii("ne"),
            dictgen::InsensitiveStr::Ascii("nes"),
            dictgen::InsensitiveStr::Ascii("nly"),
            dictgen::InsensitiveStr::Ascii("ns"),
            dictgen::InsensitiveStr::Ascii("nse"),
            dictgen::InsensitiveStr::Ascii("ntal"),
            dictgen::InsensitiveStr::Ascii("ntate"),
            dictgen::InsensitiveStr::Ascii("nte"),
            dictgen::InsensitiveStr::Ascii("ntes"),
            dictgen::InsensitiveStr::Ascii("ntiantion"),
            dictgen::InsensitiveStr::Ascii("ntiatiations"),
            dictgen::InsensitiveStr::Ascii("ntiatiors"),
            dictgen::InsensitiveStr::Ascii("ntiaton"),
            dictgen::InsensitiveStr::Ascii("ntitation"),
            dictgen::InsensitiveStr::Ascii("ntl"),
            dictgen::InsensitiveStr::Ascii("nts"),
            dictgen::InsensitiveStr::Ascii("nty"),
            dictgen::InsensitiveStr::Ascii("ny"),
            dictgen::InsensitiveStr::Ascii("rnt"),
            dictgen::InsensitiveStr::Ascii("s"),
            dictgen::InsensitiveStr::Ascii("t"),
            dictgen::InsensitiveStr::Ascii("tnt"),
        ],
        values: &[
            &["difference"],
            &["different"],
            &["different"],
            &["differences"],
            &["differential"],
            &["differentiate"],
            &["differentiated"],
            &["differentiates"],
            &["differentiating"],
            &["differentiation"],
            &["differentiation"],
            &["differences"],
            &["different"],
            &["different"],
            &["differences", "difference"],
            &["differences"],
            &["differently"],
            &["differences", "difference"],
            &["differences", "difference"],
            &["differential"],
            &["differentiate"],
            &["difference"],
            &["differences", "difference", "different"],
            &["differentiation"],
            &["differentiations"],
            &["differentiation"],
            &["differentiation"],
            &["differentiation"],
            &["differential", "differently"],
            &["different", "difference"],
            &["differently"],
            &["differently"],
            &["different"],
            &["differs"],
            &["different"],
            &["different"],
        ],
        range: 1..=12,
    };

static WORD_DIFFERA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DIFFERA_CHILDREN),
    value: None,
};

pub static WORD_DIFFERA_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("nce"),
            dictgen::InsensitiveStr::Ascii("nces"),
            dictgen::InsensitiveStr::Ascii("nt"),
            dictgen::InsensitiveStr::Ascii("ntiate"),
            dictgen::InsensitiveStr::Ascii("ntiation"),
            dictgen::InsensitiveStr::Ascii("ntiator"),
            dictgen::InsensitiveStr::Ascii("ntion"),
            dictgen::InsensitiveStr::Ascii("ntly"),
            dictgen::InsensitiveStr::Ascii("te"),
        ],
        values: &[
            &["difference"],
            &["differences"],
            &["different"],
            &["differentiate"],
            &["differentiation"],
            &["differentiator"],
            &["differentiation"],
            &["differently"],
            &["differentiate"],
        ],
        range: 2..=8,
    };

static WORD_DIFFEN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DIFFEN_CHILDREN),
    value: None,
};

pub static WORD_DIFFEN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ce"),
        dictgen::InsensitiveStr::Ascii("et"),
        dictgen::InsensitiveStr::Ascii("rence"),
        dictgen::InsensitiveStr::Ascii("rences"),
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("tiating"),
    ],
    values: &[
        &["difference"],
        &["different"],
        &["difference"],
        &["differences"],
        &["different"],
        &["differentiating"],
    ],
    range: 1..=7,
};

static WORD_DIFFEE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DIFFEE_CHILDREN),
    value: None,
};

pub static WORD_DIFFEE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("nt")],
    values: &[&["different"]],
    range: 2..=2,
};

static WORD_DIFFC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DIFFC_CHILDREN),
    value: None,
};

pub static WORD_DIFFC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ult"),
        dictgen::InsensitiveStr::Ascii("ulties"),
        dictgen::InsensitiveStr::Ascii("ulty"),
    ],
    values: &[&["difficult"], &["difficulties"], &["difficulty"]],
    range: 3..=6,
};

static WORD_DIFE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DIFE_CHILDREN),
    value: None,
};

pub static WORD_DIFE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("nitly"),
        dictgen::InsensitiveStr::Ascii("rence"),
        dictgen::InsensitiveStr::Ascii("rences"),
        dictgen::InsensitiveStr::Ascii("rent"),
        dictgen::InsensitiveStr::Ascii("rentiate"),
        dictgen::InsensitiveStr::Ascii("rentiated"),
        dictgen::InsensitiveStr::Ascii("rentiates"),
        dictgen::InsensitiveStr::Ascii("rentiating"),
        dictgen::InsensitiveStr::Ascii("rently"),
        dictgen::InsensitiveStr::Ascii("rrent"),
    ],
    values: &[
        &["definitely"],
        &["difference"],
        &["differences"],
        &["different"],
        &["differentiate"],
        &["differentiated"],
        &["differentiates"],
        &["differentiating"],
        &["differently"],
        &["different"],
    ],
    range: 4..=10,
};

static WORD_DIE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DIE_CHILDREN),
    value: None,
};

pub static WORD_DIE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("a"),
        dictgen::InsensitiveStr::Ascii("ct"),
        dictgen::InsensitiveStr::Ascii("ctly"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("lectirc"),
        dictgen::InsensitiveStr::Ascii("lectircs"),
        dictgen::InsensitiveStr::Ascii("msion"),
        dictgen::InsensitiveStr::Ascii("ties"),
        dictgen::InsensitiveStr::Ascii("ty"),
    ],
    values: &[
        &["idea", "die"],
        &["direct"],
        &["directly"],
        &["dying", "dyeing"],
        &["dielectric"],
        &["dielectrics"],
        &["dimension"],
        &["deities"],
        &["deity"],
    ],
    range: 1..=8,
};

static WORD_DID_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DID_CHILDREN),
    value: None,
};

pub static WORD_DID_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("i"),
        dictgen::InsensitiveStr::Ascii("sapointed"),
    ],
    values: &[&["did"], &["disappointed"]],
    range: 1..=9,
};

static WORD_DIC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_DIC_CHILDREN),
    value: None,
};

static WORD_DIC_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_DICA_NODE),
    None,
    None,
    None,
    Some(&WORD_DICE_NODE),
    None,
    None,
    Some(&WORD_DICH_NODE),
    Some(&WORD_DICI_NODE),
    None,
    Some(&WORD_DICK_NODE),
    Some(&WORD_DICL_NODE),
    None,
    None,
    Some(&WORD_DICO_NODE),
    None,
    None,
    Some(&WORD_DICR_NODE),
    Some(&WORD_DICS_NODE),
    Some(&WORD_DICT_NODE),
    Some(&WORD_DICU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_DICU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DICU_CHILDREN),
    value: None,
};

pub static WORD_DICU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ssed"),
        dictgen::InsensitiveStr::Ascii("ssions"),
    ],
    values: &[&["discussed"], &["discussions"]],
    range: 4..=6,
};

static WORD_DICT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DICT_CHILDREN),
    value: None,
};

pub static WORD_DICT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("adorship"),
        dictgen::InsensitiveStr::Ascii("aionaries"),
        dictgen::InsensitiveStr::Ascii("aionary"),
        dictgen::InsensitiveStr::Ascii("arorship"),
        dictgen::InsensitiveStr::Ascii("aters"),
        dictgen::InsensitiveStr::Ascii("ateurs"),
        dictgen::InsensitiveStr::Ascii("atorhip"),
        dictgen::InsensitiveStr::Ascii("atorshop"),
        dictgen::InsensitiveStr::Ascii("ats"),
        dictgen::InsensitiveStr::Ascii("inary"),
        dictgen::InsensitiveStr::Ascii("ioanries"),
        dictgen::InsensitiveStr::Ascii("ioanry"),
        dictgen::InsensitiveStr::Ascii("ionaire"),
        dictgen::InsensitiveStr::Ascii("ionaires"),
        dictgen::InsensitiveStr::Ascii("ionairy"),
        dictgen::InsensitiveStr::Ascii("ionare"),
        dictgen::InsensitiveStr::Ascii("ionarys"),
        dictgen::InsensitiveStr::Ascii("ionay"),
        dictgen::InsensitiveStr::Ascii("ionnaries"),
        dictgen::InsensitiveStr::Ascii("ionnary"),
        dictgen::InsensitiveStr::Ascii("ionries"),
        dictgen::InsensitiveStr::Ascii("ionry"),
        dictgen::InsensitiveStr::Ascii("oinaries"),
        dictgen::InsensitiveStr::Ascii("oinary"),
        dictgen::InsensitiveStr::Ascii("onaries"),
        dictgen::InsensitiveStr::Ascii("onary"),
        dictgen::InsensitiveStr::Ascii("rionaries"),
        dictgen::InsensitiveStr::Ascii("rionary"),
    ],
    values: &[
        &["dictatorship"],
        &["dictionaries"],
        &["dictionary"],
        &["dictatorship"],
        &["dictates"],
        &["dictates"],
        &["dictatorship"],
        &["dictatorship"],
        &["dictates"],
        &["dictionary"],
        &["dictionaries"],
        &["dictionary"],
        &["dictionaries"],
        &["dictionaries"],
        &["dictionary"],
        &["dictionaries"],
        &["dictionaries"],
        &["dictionary"],
        &["dictionaries"],
        &["dictionary"],
        &["dictionaries"],
        &["dictionary"],
        &["dictionaries"],
        &["dictionary"],
        &["dictionaries"],
        &["dictionary"],
        &["dictionaries"],
        &["dictionary"],
    ],
    range: 3..=9,
};

static WORD_DICS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DICS_CHILDREN),
    value: None,
};

pub static WORD_DICS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("riminated")],
    values: &[&["discriminated"]],
    range: 9..=9,
};

static WORD_DICR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DICR_CHILDREN),
    value: None,
};

pub static WORD_DICR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ectory"),
        dictgen::InsensitiveStr::Ascii("ete"),
        dictgen::InsensitiveStr::Ascii("etion"),
        dictgen::InsensitiveStr::Ascii("etionary"),
        dictgen::InsensitiveStr::Ascii("iminate"),
        dictgen::InsensitiveStr::Ascii("iminated"),
        dictgen::InsensitiveStr::Ascii("iminates"),
        dictgen::InsensitiveStr::Ascii("iminating"),
        dictgen::InsensitiveStr::Ascii("iminator"),
        dictgen::InsensitiveStr::Ascii("iminators"),
    ],
    values: &[
        &["directory"],
        &["discrete"],
        &["discretion"],
        &["discretionary"],
        &["discriminate"],
        &["discriminated"],
        &["discriminates"],
        &["discriminating"],
        &["discriminator"],
        &["discriminators"],
    ],
    range: 3..=9,
};

static WORD_DICO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DICO_CHILDREN),
    value: None,
};

pub static WORD_DICO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("nnected"),
        dictgen::InsensitiveStr::Ascii("nnection"),
        dictgen::InsensitiveStr::Ascii("nnects"),
        dictgen::InsensitiveStr::Ascii("tomies"),
        dictgen::InsensitiveStr::Ascii("tomy"),
        dictgen::InsensitiveStr::Ascii("ver"),
        dictgen::InsensitiveStr::Ascii("vered"),
        dictgen::InsensitiveStr::Ascii("vering"),
        dictgen::InsensitiveStr::Ascii("vers"),
        dictgen::InsensitiveStr::Ascii("very"),
    ],
    values: &[
        &["disconnected"],
        &["disconnection"],
        &["disconnects"],
        &["dichotomies"],
        &["dichotomy"],
        &["discover"],
        &["discovered"],
        &["discovering"],
        &["discovers"],
        &["discovery"],
    ],
    range: 3..=8,
};

static WORD_DICL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DICL_CHILDREN),
    value: None,
};

pub static WORD_DICL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ine")],
    values: &[&["decline"]],
    range: 3..=3,
};

static WORD_DICK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DICK_CHILDREN),
    value: None,
};

pub static WORD_DICK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("isch"),
        dictgen::InsensitiveStr::Ascii("sih"),
    ],
    values: &[&["dickish"], &["dickish"]],
    range: 3..=4,
};

static WORD_DICI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DICI_CHILDREN),
    value: None,
};

pub static WORD_DICI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("de"),
        dictgen::InsensitiveStr::Ascii("ded"),
        dictgen::InsensitiveStr::Ascii("des"),
        dictgen::InsensitiveStr::Ascii("ding"),
        dictgen::InsensitiveStr::Ascii("onaries"),
        dictgen::InsensitiveStr::Ascii("onary"),
        dictgen::InsensitiveStr::Ascii("pline"),
        dictgen::InsensitiveStr::Ascii("sion"),
        dictgen::InsensitiveStr::Ascii("sions"),
        dictgen::InsensitiveStr::Ascii("tonaries"),
        dictgen::InsensitiveStr::Ascii("tonary"),
    ],
    values: &[
        &["decide"],
        &["decided"],
        &["decides"],
        &["deciding"],
        &["dictionaries"],
        &["dictionary"],
        &["discipline"],
        &["decision"],
        &["decisions"],
        &["dictionaries"],
        &["dictionary"],
    ],
    range: 2..=8,
};

static WORD_DICH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DICH_CHILDREN),
    value: None,
};

pub static WORD_DICH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("omoty"),
        dictgen::InsensitiveStr::Ascii("otomoy"),
        dictgen::InsensitiveStr::Ascii("tomy"),
    ],
    values: &[&["dichotomy"], &["dichotomy"], &["dichotomy"]],
    range: 4..=6,
};

static WORD_DICE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DICE_CHILDREN),
    value: None,
};

pub static WORD_DICE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("rgence")],
    values: &[&["divergence"]],
    range: 6..=6,
};

static WORD_DICA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DICA_CHILDREN),
    value: None,
};

pub static WORD_DICA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("rd"),
        dictgen::InsensitiveStr::Ascii("rded"),
        dictgen::InsensitiveStr::Ascii("rding"),
        dictgen::InsensitiveStr::Ascii("rds"),
        dictgen::InsensitiveStr::Ascii("tes"),
        dictgen::InsensitiveStr::Ascii("tionaries"),
        dictgen::InsensitiveStr::Ascii("tionary"),
    ],
    values: &[
        &["discard"],
        &["discarded"],
        &["discarding"],
        &["discards"],
        &["dictates"],
        &["dictionaries"],
        &["dictionary"],
    ],
    range: 2..=9,
};

static WORD_DIA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_DIA_CHILDREN),
    value: None,
};

static WORD_DIA_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    Some(&WORD_DIAB_NODE),
    Some(&WORD_DIAC_NODE),
    None,
    None,
    None,
    Some(&WORD_DIAG_NODE),
    Some(&WORD_DIAH_NODE),
    None,
    None,
    None,
    Some(&WORD_DIAL_NODE),
    Some(&WORD_DIAM_NODE),
    Some(&WORD_DIAN_NODE),
    None,
    Some(&WORD_DIAP_NODE),
    None,
    Some(&WORD_DIAR_NODE),
    Some(&WORD_DIAS_NODE),
    Some(&WORD_DIAT_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_DIAT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DIAT_CHILDREN),
    value: None,
};

pub static WORD_DIAT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ance"),
        dictgen::InsensitiveStr::Ascii("ancing"),
    ],
    values: &[&["distance"], &["distancing"]],
    range: 4..=6,
};

static WORD_DIAS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DIAS_CHILDREN),
    value: None,
};

pub static WORD_DIAS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ble"),
        dictgen::InsensitiveStr::Ascii("bled"),
        dictgen::InsensitiveStr::Ascii("bles"),
        dictgen::InsensitiveStr::Ascii("bling"),
        dictgen::InsensitiveStr::Ascii("pra"),
        dictgen::InsensitiveStr::Ascii("spointed"),
        dictgen::InsensitiveStr::Ascii("ter"),
    ],
    values: &[
        &["disable"],
        &["disabled"],
        &["disables"],
        &["disabling"],
        &["diaspora"],
        &["disappointed"],
        &["disaster"],
    ],
    range: 3..=8,
};

static WORD_DIAR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DIAR_CHILDREN),
    value: None,
};

pub static WORD_DIAR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("am"),
        dictgen::InsensitiveStr::Ascii("ea"),
        dictgen::InsensitiveStr::Ascii("esis"),
        dictgen::InsensitiveStr::Ascii("hea"),
        dictgen::InsensitiveStr::Ascii("reah"),
        dictgen::InsensitiveStr::Ascii("reha"),
        dictgen::InsensitiveStr::Ascii("rheoa"),
    ],
    values: &[
        &["diagram", "diorama"],
        &["diarrhea"],
        &["diaeresis"],
        &["diarrhea"],
        &["diarrhea"],
        &["diarrhea"],
        &["diarrhea"],
    ],
    range: 2..=5,
};

static WORD_DIAP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DIAP_CHILDREN),
    value: None,
};

pub static WORD_DIAP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("lay"),
        dictgen::InsensitiveStr::Ascii("lays"),
        dictgen::InsensitiveStr::Ascii("peares"),
    ],
    values: &[&["display"], &["displays"], &["disappears"]],
    range: 3..=6,
};

static WORD_DIAN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DIAN_CHILDREN),
    value: None,
};

pub static WORD_DIAN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("gose"),
        dictgen::InsensitiveStr::Ascii("ostic"),
        dictgen::InsensitiveStr::Ascii("ostics"),
    ],
    values: &[&["diagnose"], &["diagnostic"], &["diagnostics"]],
    range: 4..=6,
};

static WORD_DIAM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DIAM_CHILDREN),
    value: None,
};

pub static WORD_DIAM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ater"),
        dictgen::InsensitiveStr::Ascii("aters"),
        dictgen::InsensitiveStr::Ascii("on"),
        dictgen::InsensitiveStr::Ascii("ons"),
        dictgen::InsensitiveStr::Ascii("ter"),
        dictgen::InsensitiveStr::Ascii("ters"),
    ],
    values: &[
        &["diameter"],
        &["diameters"],
        &["diamond"],
        &["diamonds"],
        &["diameter"],
        &["diameters"],
    ],
    range: 2..=5,
};

static WORD_DIAL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DIAL_CHILDREN),
    value: None,
};

pub static WORD_DIAL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aog"),
        dictgen::InsensitiveStr::Ascii("ate"),
        dictgen::InsensitiveStr::Ascii("ecs"),
        dictgen::InsensitiveStr::Ascii("ectes"),
        dictgen::InsensitiveStr::Ascii("ectos"),
        dictgen::InsensitiveStr::Ascii("etcs"),
        dictgen::InsensitiveStr::Ascii("go"),
        dictgen::InsensitiveStr::Ascii("gos"),
        dictgen::InsensitiveStr::Ascii("goue"),
        dictgen::InsensitiveStr::Ascii("ig"),
        dictgen::InsensitiveStr::Ascii("igs"),
        dictgen::InsensitiveStr::Ascii("oge"),
        dictgen::InsensitiveStr::Ascii("ouge"),
        dictgen::InsensitiveStr::Ascii("ouges"),
    ],
    values: &[
        &["dialog"],
        &["dilate"],
        &["dialects"],
        &["dialects"],
        &["dialects"],
        &["dialects"],
        &["dialog"],
        &["dialogs"],
        &["dialogue"],
        &["dialog"],
        &["dialogs"],
        &["dialogue", "dialog"],
        &["dialogue"],
        &["dialogues"],
    ],
    range: 2..=5,
};

static WORD_DIAH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DIAH_CHILDREN),
    value: None,
};

pub static WORD_DIAH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("rrea")],
    values: &[&["diarrhea"]],
    range: 4..=4,
};

static WORD_DIAG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DIAG_CHILDREN),
    value: None,
};

pub static WORD_DIAG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("anol"),
        dictgen::InsensitiveStr::Ascii("nistic"),
        dictgen::InsensitiveStr::Ascii("noal"),
        dictgen::InsensitiveStr::Ascii("noals"),
        dictgen::InsensitiveStr::Ascii("noes"),
        dictgen::InsensitiveStr::Ascii("nol"),
        dictgen::InsensitiveStr::Ascii("nosi"),
        dictgen::InsensitiveStr::Ascii("nosics"),
        dictgen::InsensitiveStr::Ascii("nosied"),
        dictgen::InsensitiveStr::Ascii("nosies"),
        dictgen::InsensitiveStr::Ascii("nositc"),
        dictgen::InsensitiveStr::Ascii("nositcs"),
        dictgen::InsensitiveStr::Ascii("nositic"),
        dictgen::InsensitiveStr::Ascii("nossed"),
        dictgen::InsensitiveStr::Ascii("nosted"),
        dictgen::InsensitiveStr::Ascii("notic"),
        dictgen::InsensitiveStr::Ascii("notics"),
        dictgen::InsensitiveStr::Ascii("nxostic"),
        dictgen::InsensitiveStr::Ascii("onaal"),
        dictgen::InsensitiveStr::Ascii("onale"),
        dictgen::InsensitiveStr::Ascii("onales"),
        dictgen::InsensitiveStr::Ascii("onse"),
        dictgen::InsensitiveStr::Ascii("onsed"),
        dictgen::InsensitiveStr::Ascii("onsis"),
        dictgen::InsensitiveStr::Ascii("onstic"),
        dictgen::InsensitiveStr::Ascii("onstics"),
        dictgen::InsensitiveStr::Ascii("ramas"),
        dictgen::InsensitiveStr::Ascii("ramm"),
        dictgen::InsensitiveStr::Ascii("ramms"),
    ],
    values: &[
        &["diagonal"],
        &["diagnostic"],
        &["diagonal"],
        &["diagonals"],
        &["diagnose"],
        &["diagonal"],
        &["diagnostic"],
        &["diagnostics"],
        &["diagnose"],
        &["diagnosis"],
        &["diagnostic"],
        &["diagnostic"],
        &["diagnostic"],
        &["diagnose"],
        &["diagnose"],
        &["diagnostic"],
        &["diagnostic", "diagnostics"],
        &["diagnostic"],
        &["diagonal"],
        &["diagonal"],
        &["diagonals"],
        &["diagnose"],
        &["diagnosed"],
        &["diagnosis"],
        &["diagnostic"],
        &["diagnostic"],
        &["diagrams"],
        &["diagram"],
        &["diagrams"],
    ],
    range: 3..=7,
};

static WORD_DIAC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DIAC_CHILDREN),
    value: None,
};

pub static WORD_DIAC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("iritc"),
        dictgen::InsensitiveStr::Ascii("iritcs"),
    ],
    values: &[&["diacritic"], &["diacritics"]],
    range: 5..=6,
};

static WORD_DIAB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DIAB_CHILDREN),
    value: None,
};

pub static WORD_DIAB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("etees"),
        dictgen::InsensitiveStr::Ascii("ets"),
        dictgen::InsensitiveStr::Ascii("le"),
        dictgen::InsensitiveStr::Ascii("led"),
        dictgen::InsensitiveStr::Ascii("ler"),
        dictgen::InsensitiveStr::Ascii("lers"),
        dictgen::InsensitiveStr::Ascii("les"),
        dictgen::InsensitiveStr::Ascii("lical"),
        dictgen::InsensitiveStr::Ascii("ling"),
    ],
    values: &[
        &["diabetes"],
        &["diabetes"],
        &["disable"],
        &["disabled"],
        &["disabler"],
        &["disablers"],
        &["disables"],
        &["diabolical"],
        &["disabling"],
    ],
    range: 2..=5,
};

static WORD_DG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DG_CHILDREN),
    value: None,
};

pub static WORD_DG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("etttext")],
    values: &[&["dgettext"]],
    range: 7..=7,
};

static WORD_DF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DF_CHILDREN),
    value: None,
};

pub static WORD_DF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ine"),
        dictgen::InsensitiveStr::Ascii("ined"),
        dictgen::InsensitiveStr::Ascii("ines"),
        dictgen::InsensitiveStr::Ascii("inition"),
        dictgen::InsensitiveStr::Ascii("initions"),
    ],
    values: &[
        &["define"],
        &["defined"],
        &["defines"],
        &["definition"],
        &["definitions"],
    ],
    range: 3..=8,
};

static WORD_DE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_DE_CHILDREN),
    value: None,
};

static WORD_DE_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_DEA_NODE),
    Some(&WORD_DEB_NODE),
    Some(&WORD_DEC_NODE),
    Some(&WORD_DED_NODE),
    Some(&WORD_DEE_NODE),
    Some(&WORD_DEF_NODE),
    Some(&WORD_DEG_NODE),
    Some(&WORD_DEH_NODE),
    Some(&WORD_DEI_NODE),
    None,
    Some(&WORD_DEK_NODE),
    Some(&WORD_DEL_NODE),
    Some(&WORD_DEM_NODE),
    Some(&WORD_DEN_NODE),
    Some(&WORD_DEO_NODE),
    Some(&WORD_DEP_NODE),
    Some(&WORD_DEQ_NODE),
    Some(&WORD_DER_NODE),
    Some(&WORD_DES_NODE),
    Some(&WORD_DET_NODE),
    Some(&WORD_DEU_NODE),
    Some(&WORD_DEV_NODE),
    Some(&WORD_DEW_NODE),
    None,
    Some(&WORD_DEY_NODE),
    Some(&WORD_DEZ_NODE),
];

static WORD_DEZ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DEZ_CHILDREN),
    value: None,
};

pub static WORD_DEZ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ember"),
        dictgen::InsensitiveStr::Ascii("entralized"),
        dictgen::InsensitiveStr::Ascii("ert"),
        dictgen::InsensitiveStr::Ascii("ibel"),
        dictgen::InsensitiveStr::Ascii("ine"),
        dictgen::InsensitiveStr::Ascii("inens"),
    ],
    values: &[
        &["december"],
        &["decentralized"],
        &["dessert"],
        &["decibel"],
        &["design"],
        &["denizens"],
    ],
    range: 3..=10,
};

static WORD_DEY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DEY_CHILDREN),
    value: None,
};

pub static WORD_DEY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("hdrated"),
        dictgen::InsensitiveStr::Ascii("hdration"),
    ],
    values: &[&["dehydrated"], &["dehydration"]],
    range: 7..=8,
};

static WORD_DEW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DEW_CHILDREN),
    value: None,
};

pub static WORD_DEW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("rapping")],
    values: &[&["unwrapping"]],
    range: 7..=7,
};

static WORD_DEV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_DEV_CHILDREN),
    value: None,
};

static WORD_DEV_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_DEVA_NODE),
    None,
    Some(&WORD_DEVC_NODE),
    None,
    Some(&WORD_DEVE_NODE),
    Some(&WORD_DEVF_NODE),
    None,
    None,
    Some(&WORD_DEVI_NODE),
    None,
    None,
    Some(&WORD_DEVL_NODE),
    None,
    None,
    Some(&WORD_DEVO_NODE),
    None,
    None,
    Some(&WORD_DEVR_NODE),
    None,
    None,
    Some(&WORD_DEVU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_DEVU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DEVU_CHILDREN),
    value: None,
};

pub static WORD_DEVU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ce")],
    values: &[&["device"]],
    range: 2..=2,
};

static WORD_DEVR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DEVR_CHILDREN),
    value: None,
};

pub static WORD_DEVR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("itualisation"),
        dictgen::InsensitiveStr::Ascii("itualization"),
    ],
    values: &[&["devirtualisation"], &["devirtualization"]],
    range: 12..=12,
};

static WORD_DEVO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DEVO_CHILDREN),
    value: None,
};

pub static WORD_DEVO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("lopement"),
        dictgen::InsensitiveStr::Ascii("lopments"),
        dictgen::InsensitiveStr::Ascii("lvendo"),
        dictgen::InsensitiveStr::Ascii("tin"),
        dictgen::InsensitiveStr::Ascii("vle"),
        dictgen::InsensitiveStr::Ascii("vled"),
    ],
    values: &[
        &["development"],
        &["developments"],
        &["devolved"],
        &["devotion"],
        &["devolve"],
        &["devolved"],
    ],
    range: 3..=8,
};

static WORD_DEVL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DEVL_CHILDREN),
    value: None,
};

pub static WORD_DEVL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eop"),
        dictgen::InsensitiveStr::Ascii("eoped"),
        dictgen::InsensitiveStr::Ascii("eoper"),
        dictgen::InsensitiveStr::Ascii("eopers"),
        dictgen::InsensitiveStr::Ascii("eoping"),
        dictgen::InsensitiveStr::Ascii("eopment"),
        dictgen::InsensitiveStr::Ascii("eopper"),
        dictgen::InsensitiveStr::Ascii("eoppers"),
        dictgen::InsensitiveStr::Ascii("op"),
        dictgen::InsensitiveStr::Ascii("oped"),
        dictgen::InsensitiveStr::Ascii("oper"),
        dictgen::InsensitiveStr::Ascii("opers"),
        dictgen::InsensitiveStr::Ascii("oping"),
        dictgen::InsensitiveStr::Ascii("opment"),
        dictgen::InsensitiveStr::Ascii("opments"),
        dictgen::InsensitiveStr::Ascii("opper"),
        dictgen::InsensitiveStr::Ascii("oppers"),
        dictgen::InsensitiveStr::Ascii("ops"),
        dictgen::InsensitiveStr::Ascii("ove"),
        dictgen::InsensitiveStr::Ascii("oved"),
    ],
    values: &[
        &["develop"],
        &["developed"],
        &["developer"],
        &["developers"],
        &["developing"],
        &["development"],
        &["developer"],
        &["developers"],
        &["develop"],
        &["developed"],
        &["developer"],
        &["developers"],
        &["developing"],
        &["development"],
        &["developments"],
        &["developer"],
        &["developers"],
        &["develops"],
        &["devolve"],
        &["devolved"],
    ],
    range: 2..=7,
};

static WORD_DEVI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DEVI_CHILDREN),
    value: None,
};

pub static WORD_DEVI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("alet"),
        dictgen::InsensitiveStr::Ascii("atie"),
        dictgen::InsensitiveStr::Ascii("c"),
        dictgen::InsensitiveStr::Ascii("cde"),
        dictgen::InsensitiveStr::Ascii("cdes"),
        dictgen::InsensitiveStr::Ascii("cec"),
        dictgen::InsensitiveStr::Ascii("cecoordiinates"),
        dictgen::InsensitiveStr::Ascii("ceremoveable"),
        dictgen::InsensitiveStr::Ascii("cesr"),
        dictgen::InsensitiveStr::Ascii("cess"),
        dictgen::InsensitiveStr::Ascii("cest"),
        dictgen::InsensitiveStr::Ascii("de"),
        dictgen::InsensitiveStr::Ascii("ded"),
        dictgen::InsensitiveStr::Ascii("der"),
        dictgen::InsensitiveStr::Ascii("ders"),
        dictgen::InsensitiveStr::Ascii("des"),
        dictgen::InsensitiveStr::Ascii("ding"),
        dictgen::InsensitiveStr::Ascii("ece"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("iate"),
        dictgen::InsensitiveStr::Ascii("iated"),
        dictgen::InsensitiveStr::Ascii("iates"),
        dictgen::InsensitiveStr::Ascii("iating"),
        dictgen::InsensitiveStr::Ascii("iation"),
        dictgen::InsensitiveStr::Ascii("iations"),
        dictgen::InsensitiveStr::Ascii("lers"),
        dictgen::InsensitiveStr::Ascii("ne"),
        dictgen::InsensitiveStr::Ascii("ned"),
        dictgen::InsensitiveStr::Ascii("red"),
        dictgen::InsensitiveStr::Ascii("rtualiation"),
        dictgen::InsensitiveStr::Ascii("rtualied"),
        dictgen::InsensitiveStr::Ascii("rtualisaion"),
        dictgen::InsensitiveStr::Ascii("rtualisaiton"),
        dictgen::InsensitiveStr::Ascii("rtualizaion"),
        dictgen::InsensitiveStr::Ascii("rtualizaiton"),
        dictgen::InsensitiveStr::Ascii("rutalisation"),
        dictgen::InsensitiveStr::Ascii("rutalise"),
        dictgen::InsensitiveStr::Ascii("rutalised"),
        dictgen::InsensitiveStr::Ascii("rutalization"),
        dictgen::InsensitiveStr::Ascii("rutalize"),
        dictgen::InsensitiveStr::Ascii("rutalized"),
        dictgen::InsensitiveStr::Ascii("sible"),
        dictgen::InsensitiveStr::Ascii("sion"),
        dictgen::InsensitiveStr::Ascii("stating"),
        dictgen::InsensitiveStr::Ascii("ve"),
    ],
    values: &[
        &["deviate"],
        &["deviate"],
        &["device"],
        &["device"],
        &["devices"],
        &["device"],
        &["devicecoordinates"],
        &["deviceremovable"],
        &["devices"],
        &["devices"],
        &["devices"],
        &["divide", "device"],
        &["divided"],
        &["divider"],
        &["dividers"],
        &["divides", "devices"],
        &["dividing"],
        &["device"],
        &["device"],
        &["deviate"],
        &["deviated"],
        &["deviates"],
        &["deviating"],
        &["deviation"],
        &["deviations"],
        &["delivers"],
        &["define", "divine"],
        &["defined"],
        &["derived"],
        &["devirtualisation", "devirtualization"],
        &["devirtualised", "devirtualized"],
        &["devirtualisation"],
        &["devirtualisation"],
        &["devirtualization"],
        &["devirtualization"],
        &["devirtualisation"],
        &["devirtualise"],
        &["devirtualised"],
        &["devirtualization"],
        &["devirtualize"],
        &["devirtualized"],
        &["divisible"],
        &["division"],
        &["devastating"],
        &["device"],
    ],
    range: 1..=14,
};

static WORD_DEVF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DEVF_CHILDREN),
    value: None,
};

pub static WORD_DEVF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ine"),
        dictgen::InsensitiveStr::Ascii("ined"),
        dictgen::InsensitiveStr::Ascii("ines"),
    ],
    values: &[&["define"], &["defined"], &["defines"]],
    range: 3..=4,
};

static WORD_DEVE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DEVE_CHILDREN),
    value: None,
};

pub static WORD_DEVE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("lepmont"),
        dictgen::InsensitiveStr::Ascii("lepors"),
        dictgen::InsensitiveStr::Ascii("loeprs"),
        dictgen::InsensitiveStr::Ascii("loers"),
        dictgen::InsensitiveStr::Ascii("loment"),
        dictgen::InsensitiveStr::Ascii("loments"),
        dictgen::InsensitiveStr::Ascii("lompent"),
        dictgen::InsensitiveStr::Ascii("lompental"),
        dictgen::InsensitiveStr::Ascii("lompents"),
        dictgen::InsensitiveStr::Ascii("lope"),
        dictgen::InsensitiveStr::Ascii("lopement"),
        dictgen::InsensitiveStr::Ascii("lopements"),
        dictgen::InsensitiveStr::Ascii("lopemnt"),
        dictgen::InsensitiveStr::Ascii("lopmant"),
        dictgen::InsensitiveStr::Ascii("lopme"),
        dictgen::InsensitiveStr::Ascii("lopmemt"),
        dictgen::InsensitiveStr::Ascii("lopmenet"),
        dictgen::InsensitiveStr::Ascii("lopmently"),
        dictgen::InsensitiveStr::Ascii("lopmentwise"),
        dictgen::InsensitiveStr::Ascii("lopmet"),
        dictgen::InsensitiveStr::Ascii("lopmetn"),
        dictgen::InsensitiveStr::Ascii("lopmetns"),
        dictgen::InsensitiveStr::Ascii("lopmets"),
        dictgen::InsensitiveStr::Ascii("lopmnet"),
        dictgen::InsensitiveStr::Ascii("lopoment"),
        dictgen::InsensitiveStr::Ascii("lopors"),
        dictgen::InsensitiveStr::Ascii("lopp"),
        dictgen::InsensitiveStr::Ascii("loppe"),
        dictgen::InsensitiveStr::Ascii("lopped"),
        dictgen::InsensitiveStr::Ascii("loppement"),
        dictgen::InsensitiveStr::Ascii("lopper"),
        dictgen::InsensitiveStr::Ascii("loppers"),
        dictgen::InsensitiveStr::Ascii("lopping"),
        dictgen::InsensitiveStr::Ascii("loppment"),
        dictgen::InsensitiveStr::Ascii("lopres"),
        dictgen::InsensitiveStr::Ascii("loprs"),
        dictgen::InsensitiveStr::Ascii("lp"),
        dictgen::InsensitiveStr::Ascii("lped"),
        dictgen::InsensitiveStr::Ascii("lper"),
        dictgen::InsensitiveStr::Ascii("lpers"),
        dictgen::InsensitiveStr::Ascii("lping"),
        dictgen::InsensitiveStr::Ascii("lpment"),
        dictgen::InsensitiveStr::Ascii("lpments"),
        dictgen::InsensitiveStr::Ascii("lpoment"),
        dictgen::InsensitiveStr::Ascii("lpoments"),
        dictgen::InsensitiveStr::Ascii("lps"),
        dictgen::InsensitiveStr::Ascii("ls"),
        dictgen::InsensitiveStr::Ascii("olpment"),
        dictgen::InsensitiveStr::Ascii("opers"),
        dictgen::InsensitiveStr::Ascii("ploment"),
        dictgen::InsensitiveStr::Ascii("rloper"),
        dictgen::InsensitiveStr::Ascii("rlopers"),
        dictgen::InsensitiveStr::Ascii("stated"),
        dictgen::InsensitiveStr::Ascii("stating"),
    ],
    values: &[
        &["developments"],
        &["developers"],
        &["developers"],
        &["developers"],
        &["development"],
        &["developments"],
        &["developments", "development"],
        &["developmental"],
        &["developments"],
        &["develop"],
        &["development"],
        &["developments"],
        &["developments"],
        &["developmental"],
        &["development"],
        &["development"],
        &["developments"],
        &["developmental"],
        &["developments"],
        &["developments", "development"],
        &["developments"],
        &["developments"],
        &["developments"],
        &["developments"],
        &["development"],
        &["develops"],
        &["develop"],
        &["develop"],
        &["developed"],
        &["development"],
        &["developer"],
        &["developers"],
        &["developing"],
        &["development"],
        &["develops"],
        &["develops"],
        &["develop"],
        &["developed"],
        &["developer"],
        &["developers"],
        &["developing"],
        &["development"],
        &["developments"],
        &["developments"],
        &["developments"],
        &["develops"],
        &["delves"],
        &["developments", "development"],
        &["developers"],
        &["developments"],
        &["developer"],
        &["developers"],
        &["devastated"],
        &["devastating"],
    ],
    range: 2..=11,
};

static WORD_DEVC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DEVC_CHILDREN),
    value: None,
};

pub static WORD_DEVC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("ent"),
        dictgen::InsensitiveStr::Ascii("ie"),
        dictgen::InsensitiveStr::Ascii("ies"),
    ],
    values: &[&["device"], &["decent"], &["device"], &["devices"]],
    range: 1..=3,
};

static WORD_DEVA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DEVA_CHILDREN),
    value: None,
};

pub static WORD_DEVA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("int"),
        dictgen::InsensitiveStr::Ascii("ite"),
        dictgen::InsensitiveStr::Ascii("staded"),
        dictgen::InsensitiveStr::Ascii("staing"),
        dictgen::InsensitiveStr::Ascii("stanti"),
        dictgen::InsensitiveStr::Ascii("sted"),
        dictgen::InsensitiveStr::Ascii("steted"),
        dictgen::InsensitiveStr::Ascii("tion"),
    ],
    values: &[
        &["deviant"],
        &["deviate"],
        &["devastated"],
        &["devastating"],
        &["devastating"],
        &["devastated"],
        &["devastated"],
        &["deviation"],
    ],
    range: 3..=6,
};

static WORD_DEU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DEU_CHILDREN),
    value: None,
};

pub static WORD_DEU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("bug"),
        dictgen::InsensitiveStr::Ascii("buging"),
        dictgen::InsensitiveStr::Ascii("g"),
        dictgen::InsensitiveStr::Ascii("gging"),
        dictgen::InsensitiveStr::Ascii("ling"),
        dictgen::InsensitiveStr::Ascii("stchland"),
        dictgen::InsensitiveStr::Ascii("tchsland"),
        dictgen::InsensitiveStr::Ascii("tcshland"),
        dictgen::InsensitiveStr::Ascii("tschalnd"),
        dictgen::InsensitiveStr::Ascii("tschand"),
        dictgen::InsensitiveStr::Ascii("tshcland"),
    ],
    values: &[
        &["debug"],
        &["debugging"],
        &["debug"],
        &["debugging"],
        &["dueling"],
        &["deutschland"],
        &["deutschland"],
        &["deutschland"],
        &["deutschland"],
        &["deutschland"],
        &["deutschland"],
    ],
    range: 1..=8,
};

static WORD_DET_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_DET_CHILDREN),
    value: None,
};

static WORD_DET_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_DETA_NODE),
    None,
    Some(&WORD_DETC_NODE),
    None,
    Some(&WORD_DETE_NODE),
    None,
    None,
    None,
    Some(&WORD_DETI_NODE),
    None,
    None,
    None,
    Some(&WORD_DETM_NODE),
    None,
    Some(&WORD_DETO_NODE),
    None,
    None,
    Some(&WORD_DETR_NODE),
    None,
    Some(&WORD_DETT_NODE),
    Some(&WORD_DETU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_DETU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DETU_CHILDREN),
    value: None,
};

pub static WORD_DETU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("r"),
        dictgen::InsensitiveStr::Ascii("rance"),
        dictgen::InsensitiveStr::Ascii("schland"),
    ],
    values: &[&["detour"], &["deterrence"], &["deutschland"]],
    range: 1..=7,
};

static WORD_DETT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DETT_CHILDREN),
    value: None,
};

pub static WORD_DETT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ach"),
        dictgen::InsensitiveStr::Ascii("ached"),
        dictgen::InsensitiveStr::Ascii("aching"),
    ],
    values: &[&["detach"], &["detached"], &["detaching"]],
    range: 3..=6,
};

static WORD_DETR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DETR_CHILDREN),
    value: None,
};

pub static WORD_DETR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("amental"),
        dictgen::InsensitiveStr::Ascii("emental"),
        dictgen::InsensitiveStr::Ascii("emining"),
        dictgen::InsensitiveStr::Ascii("imential"),
        dictgen::InsensitiveStr::Ascii("imentul"),
        dictgen::InsensitiveStr::Ascii("iot"),
        dictgen::InsensitiveStr::Ascii("mination"),
        dictgen::InsensitiveStr::Ascii("mine"),
        dictgen::InsensitiveStr::Ascii("mined"),
        dictgen::InsensitiveStr::Ascii("mines"),
        dictgen::InsensitiveStr::Ascii("mining"),
        dictgen::InsensitiveStr::Ascii("oy"),
        dictgen::InsensitiveStr::Ascii("oyed"),
        dictgen::InsensitiveStr::Ascii("oying"),
        dictgen::InsensitiveStr::Ascii("oys"),
        dictgen::InsensitiveStr::Ascii("ucted"),
    ],
    values: &[
        &["detrimental"],
        &["detrimental"],
        &["determining"],
        &["detrimental"],
        &["detrimental"],
        &["detroit"],
        &["determination"],
        &["determine"],
        &["determined"],
        &["determines"],
        &["determining"],
        &["destroy"],
        &["destroyed"],
        &["destroying"],
        &["destroys"],
        &["destructed"],
    ],
    range: 2..=8,
};

static WORD_DETO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DETO_CHILDREN),
    value: None,
};

pub static WORD_DETO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("rit")],
    values: &[&["detroit"]],
    range: 3..=3,
};

static WORD_DETM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DETM_CHILDREN),
    value: None,
};

pub static WORD_DETM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("atologist")],
    values: &[&["dermatologist"]],
    range: 9..=9,
};

static WORD_DETI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DETI_CHILDREN),
    value: None,
};

pub static WORD_DETI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("al"),
        dictgen::InsensitiveStr::Ascii("aled"),
        dictgen::InsensitiveStr::Ascii("aling"),
        dictgen::InsensitiveStr::Ascii("als"),
        dictgen::InsensitiveStr::Ascii("ls"),
        dictgen::InsensitiveStr::Ascii("nation"),
        dictgen::InsensitiveStr::Ascii("nations"),
    ],
    values: &[
        &["detail"],
        &["detailed"],
        &["detailing"],
        &["details"],
        &["details"],
        &["destination"],
        &["destinations"],
    ],
    range: 2..=7,
};

static WORD_DETE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_DETE_CHILDREN),
    value: None,
};

static WORD_DETE_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    Some(&WORD_DETEC_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_DETEM_NODE),
    None,
    Some(&WORD_DETEO_NODE),
    None,
    None,
    Some(&WORD_DETER_NODE),
    None,
    Some(&WORD_DETET_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_DETET_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DETET_CHILDREN),
    value: Some(&["detect", "delete"]),
};

pub static WORD_DETET_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("ion"),
        dictgen::InsensitiveStr::Ascii("ions"),
        dictgen::InsensitiveStr::Ascii("mine"),
        dictgen::InsensitiveStr::Ascii("s"),
    ],
    values: &[
        &["detected", "deleted"],
        &["deletes", "detects"],
        &["detecting", "deleting"],
        &["detection", "deletion"],
        &["deletions", "detections"],
        &["determine"],
        &["detects", "deletes"],
    ],
    range: 1..=4,
};

static WORD_DETER_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DETER_CHILDREN),
    value: None,
};

pub static WORD_DETER_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ant"),
        dictgen::InsensitiveStr::Ascii("emine"),
        dictgen::InsensitiveStr::Ascii("emined"),
        dictgen::InsensitiveStr::Ascii("iate"),
        dictgen::InsensitiveStr::Ascii("imine"),
        dictgen::InsensitiveStr::Ascii("imined"),
        dictgen::InsensitiveStr::Ascii("ine"),
        dictgen::InsensitiveStr::Ascii("ioriating"),
        dictgen::InsensitiveStr::Ascii("maine"),
        dictgen::InsensitiveStr::Ascii("manism"),
        dictgen::InsensitiveStr::Ascii("men"),
        dictgen::InsensitiveStr::Ascii("menant"),
        dictgen::InsensitiveStr::Ascii("menation"),
        dictgen::InsensitiveStr::Ascii("mening"),
        dictgen::InsensitiveStr::Ascii("menism"),
        dictgen::InsensitiveStr::Ascii("menistic"),
        dictgen::InsensitiveStr::Ascii("miens"),
        dictgen::InsensitiveStr::Ascii("mimnes"),
        dictgen::InsensitiveStr::Ascii("min"),
        dictgen::InsensitiveStr::Ascii("minacion"),
        dictgen::InsensitiveStr::Ascii("minanti"),
        dictgen::InsensitiveStr::Ascii("minare"),
        dictgen::InsensitiveStr::Ascii("minas"),
        dictgen::InsensitiveStr::Ascii("minated"),
        dictgen::InsensitiveStr::Ascii("minato"),
        dictgen::InsensitiveStr::Ascii("minaton"),
        dictgen::InsensitiveStr::Ascii("mind"),
        dictgen::InsensitiveStr::Ascii("minded"),
        dictgen::InsensitiveStr::Ascii("mindes"),
        dictgen::InsensitiveStr::Ascii("minee"),
        dictgen::InsensitiveStr::Ascii("mineing"),
        dictgen::InsensitiveStr::Ascii("ming"),
        dictgen::InsensitiveStr::Ascii("minging"),
        dictgen::InsensitiveStr::Ascii("minig"),
        dictgen::InsensitiveStr::Ascii("minining"),
        dictgen::InsensitiveStr::Ascii("minisic"),
        dictgen::InsensitiveStr::Ascii("minisim"),
        dictgen::InsensitiveStr::Ascii("minisitc"),
        dictgen::InsensitiveStr::Ascii("minisitic"),
        dictgen::InsensitiveStr::Ascii("ministc"),
        dictgen::InsensitiveStr::Ascii("ministinc"),
        dictgen::InsensitiveStr::Ascii("ministisch"),
        dictgen::InsensitiveStr::Ascii("ministische"),
        dictgen::InsensitiveStr::Ascii("minitic"),
        dictgen::InsensitiveStr::Ascii("minne"),
        dictgen::InsensitiveStr::Ascii("mins"),
        dictgen::InsensitiveStr::Ascii("minse"),
        dictgen::InsensitiveStr::Ascii("minsim"),
        dictgen::InsensitiveStr::Ascii("minsitic"),
        dictgen::InsensitiveStr::Ascii("minsm"),
        dictgen::InsensitiveStr::Ascii("minstic"),
        dictgen::InsensitiveStr::Ascii("minstically"),
        dictgen::InsensitiveStr::Ascii("minte"),
        dictgen::InsensitiveStr::Ascii("mintes"),
        dictgen::InsensitiveStr::Ascii("mned"),
        dictgen::InsensitiveStr::Ascii("mnine"),
        dictgen::InsensitiveStr::Ascii("nine"),
    ],
    values: &[
        &["deterrent"],
        &["determine"],
        &["determined"],
        &["deteriorate"],
        &["determine"],
        &["determined"],
        &["determine"],
        &["deteriorating"],
        &["determine"],
        &["determinism"],
        &["determines"],
        &["determinant"],
        &["determination"],
        &["determining"],
        &["determinism"],
        &["deterministic"],
        &["determines"],
        &["determines"],
        &["determine"],
        &["determination"],
        &["determination"],
        &["determine"],
        &["determines"],
        &["determined"],
        &["determination"],
        &["determination"],
        &["determined"],
        &["determine", "determined"],
        &["determined", "determines"],
        &["determine"],
        &["determining"],
        &["determining", "determine"],
        &["determining"],
        &["determining"],
        &["determining"],
        &["deterministic"],
        &["determinism"],
        &["deterministic"],
        &["deterministic"],
        &["deterministic"],
        &["deterministic"],
        &["deterministic"],
        &["deterministic"],
        &["deterministic"],
        &["determine"],
        &["determines"],
        &["determines"],
        &["determinism"],
        &["deterministic"],
        &["determinism"],
        &["deterministic"],
        &["deterministically"],
        &["determine", "determined"],
        &["determines"],
        &["determined"],
        &["determine"],
        &["determine"],
    ],
    range: 3..=11,
};

static WORD_DETEO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DETEO_CHILDREN),
    value: None,
};

pub static WORD_DETEO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("riated")],
    values: &[&["deteriorated"]],
    range: 6..=6,
};

static WORD_DETEM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DETEM_CHILDREN),
    value: None,
};

pub static WORD_DETEM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ine"),
        dictgen::InsensitiveStr::Ascii("ined"),
        dictgen::InsensitiveStr::Ascii("ines"),
        dictgen::InsensitiveStr::Ascii("ining"),
    ],
    values: &[
        &["determine"],
        &["determined"],
        &["determines"],
        &["determining"],
    ],
    range: 3..=5,
};

static WORD_DETEC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DETEC_CHILDREN),
    value: None,
};

pub static WORD_DETEC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("h"),
        dictgen::InsensitiveStr::Ascii("hed"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("ion"),
        dictgen::InsensitiveStr::Ascii("ions"),
        dictgen::InsensitiveStr::Ascii("s"),
        dictgen::InsensitiveStr::Ascii("tarlo"),
        dictgen::InsensitiveStr::Ascii("taron"),
        dictgen::InsensitiveStr::Ascii("tas"),
        dictgen::InsensitiveStr::Ascii("te"),
        dictgen::InsensitiveStr::Ascii("tected"),
        dictgen::InsensitiveStr::Ascii("tes"),
        dictgen::InsensitiveStr::Ascii("tetd"),
        dictgen::InsensitiveStr::Ascii("tie"),
        dictgen::InsensitiveStr::Ascii("tiona"),
        dictgen::InsensitiveStr::Ascii("tionn"),
        dictgen::InsensitiveStr::Ascii("tionns"),
        dictgen::InsensitiveStr::Ascii("tivs"),
        dictgen::InsensitiveStr::Ascii("toare"),
        dictgen::InsensitiveStr::Ascii("tsion"),
        dictgen::InsensitiveStr::Ascii("tsions"),
        dictgen::InsensitiveStr::Ascii("tt"),
    ],
    values: &[
        &["detected"],
        &["detach", "detect"],
        &["detached", "detected"],
        &["detecting"],
        &["detection"],
        &["detections"],
        &["detects", "deters", "detect"],
        &["detector"],
        &["detector"],
        &["detects"],
        &["detected", "detect", "detects"],
        &["detected"],
        &["detects"],
        &["detected"],
        &["detectives"],
        &["detection", "detections"],
        &["detection"],
        &["detections"],
        &["detectives"],
        &["detector"],
        &["detection"],
        &["detections"],
        &["detect"],
    ],
    range: 1..=6,
};

static WORD_DETC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DETC_CHILDREN),
    value: None,
};

pub static WORD_DETC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eting"),
        dictgen::InsensitiveStr::Ascii("etion"),
        dictgen::InsensitiveStr::Ascii("etions"),
        dictgen::InsensitiveStr::Ascii("table"),
        dictgen::InsensitiveStr::Ascii("tion"),
        dictgen::InsensitiveStr::Ascii("tions"),
    ],
    values: &[
        &["detecting"],
        &["detection"],
        &["detections"],
        &["detectable"],
        &["detection"],
        &["detections"],
    ],
    range: 4..=6,
};

static WORD_DETA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DETA_CHILDREN),
    value: None,
};

pub static WORD_DETA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("base"),
        dictgen::InsensitiveStr::Ascii("chs"),
        dictgen::InsensitiveStr::Ascii("hced"),
        dictgen::InsensitiveStr::Ascii("ild"),
        dictgen::InsensitiveStr::Ascii("illed"),
        dictgen::InsensitiveStr::Ascii("is"),
        dictgen::InsensitiveStr::Ascii("lied"),
        dictgen::InsensitiveStr::Ascii("ls"),
        dictgen::InsensitiveStr::Ascii("tch"),
        dictgen::InsensitiveStr::Ascii("tched"),
        dictgen::InsensitiveStr::Ascii("tches"),
        dictgen::InsensitiveStr::Ascii("tching"),
        dictgen::InsensitiveStr::Ascii("ult"),
        dictgen::InsensitiveStr::Ascii("ulted"),
        dictgen::InsensitiveStr::Ascii("ulting"),
        dictgen::InsensitiveStr::Ascii("ults"),
    ],
    values: &[
        &["database"],
        &["detaches"],
        &["detached"],
        &["detailed"],
        &["detailed"],
        &["details"],
        &["detailed"],
        &["details"],
        &["detach"],
        &["detached"],
        &["detaches"],
        &["detaching"],
        &["default"],
        &["defaulted"],
        &["defaulting"],
        &["defaults"],
    ],
    range: 2..=6,
};

static WORD_DES_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_DES_CHILDREN),
    value: None,
};

static WORD_DES_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_DESA_NODE),
    None,
    Some(&WORD_DESC_NODE),
    None,
    Some(&WORD_DESE_NODE),
    None,
    Some(&WORD_DESG_NODE),
    None,
    Some(&WORD_DESI_NODE),
    None,
    Some(&WORD_DESK_NODE),
    Some(&WORD_DESL_NODE),
    None,
    Some(&WORD_DESN_NODE),
    Some(&WORD_DESO_NODE),
    Some(&WORD_DESP_NODE),
    Some(&WORD_DESQ_NODE),
    Some(&WORD_DESR_NODE),
    Some(&WORD_DESS_NODE),
    Some(&WORD_DEST_NODE),
    Some(&WORD_DESU_NODE),
    None,
    None,
    None,
    Some(&WORD_DESY_NODE),
    None,
];

static WORD_DESY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DESY_CHILDREN),
    value: None,
};

pub static WORD_DESY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("chronize"),
        dictgen::InsensitiveStr::Ascii("chronized"),
    ],
    values: &[&["desynchronize"], &["desynchronized"]],
    range: 8..=9,
};

static WORD_DESU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DESU_CHILDREN),
    value: None,
};

pub static WORD_DESU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ction")],
    values: &[&["seduction"]],
    range: 5..=5,
};

static WORD_DEST_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_DEST_CHILDREN),
    value: None,
};

static WORD_DEST_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_DESTA_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_DESTI_NODE),
    None,
    Some(&WORD_DESTK_NODE),
    None,
    None,
    None,
    Some(&WORD_DESTO_NODE),
    None,
    None,
    Some(&WORD_DESTR_NODE),
    None,
    None,
    Some(&WORD_DESTU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_DESTU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DESTU_CHILDREN),
    value: None,
};

pub static WORD_DESTU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ction"),
        dictgen::InsensitiveStr::Ascii("ctive"),
        dictgen::InsensitiveStr::Ascii("ctor"),
        dictgen::InsensitiveStr::Ascii("ctors"),
        dictgen::InsensitiveStr::Ascii("rb"),
        dictgen::InsensitiveStr::Ascii("rbed"),
        dictgen::InsensitiveStr::Ascii("rbing"),
        dictgen::InsensitiveStr::Ascii("rcted"),
        dictgen::InsensitiveStr::Ascii("rtor"),
        dictgen::InsensitiveStr::Ascii("rtors"),
    ],
    values: &[
        &["destruction"],
        &["destructive"],
        &["destructor"],
        &["destructors"],
        &["disturb"],
        &["disturbed"],
        &["disturbing"],
        &["destructed"],
        &["destructor"],
        &["destructors"],
    ],
    range: 2..=5,
};

static WORD_DESTR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DESTR_CHILDREN),
    value: None,
};

pub static WORD_DESTR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("action"),
        dictgen::InsensitiveStr::Ascii("actions"),
        dictgen::InsensitiveStr::Ascii("cut"),
        dictgen::InsensitiveStr::Ascii("cuted"),
        dictgen::InsensitiveStr::Ascii("cutor"),
        dictgen::InsensitiveStr::Ascii("cutors"),
        dictgen::InsensitiveStr::Ascii("ibute"),
        dictgen::InsensitiveStr::Ascii("ibuted"),
        dictgen::InsensitiveStr::Ascii("ibutors"),
        dictgen::InsensitiveStr::Ascii("oi"),
        dictgen::InsensitiveStr::Ascii("oied"),
        dictgen::InsensitiveStr::Ascii("oing"),
        dictgen::InsensitiveStr::Ascii("ois"),
        dictgen::InsensitiveStr::Ascii("os"),
        dictgen::InsensitiveStr::Ascii("ose"),
        dictgen::InsensitiveStr::Ascii("oyd"),
        dictgen::InsensitiveStr::Ascii("oyeds"),
        dictgen::InsensitiveStr::Ascii("oyeer"),
        dictgen::InsensitiveStr::Ascii("oyes"),
        dictgen::InsensitiveStr::Ascii("oyr"),
        dictgen::InsensitiveStr::Ascii("uccion"),
        dictgen::InsensitiveStr::Ascii("ucion"),
        dictgen::InsensitiveStr::Ascii("uciton"),
        dictgen::InsensitiveStr::Ascii("ucive"),
        dictgen::InsensitiveStr::Ascii("uctivo"),
        dictgen::InsensitiveStr::Ascii("ucto"),
        dictgen::InsensitiveStr::Ascii("uctro"),
        dictgen::InsensitiveStr::Ascii("uctros"),
        dictgen::InsensitiveStr::Ascii("uktion"),
        dictgen::InsensitiveStr::Ascii("uktive"),
        dictgen::InsensitiveStr::Ascii("uktor"),
        dictgen::InsensitiveStr::Ascii("uktors"),
        dictgen::InsensitiveStr::Ascii("utor"),
        dictgen::InsensitiveStr::Ascii("utors"),
        dictgen::InsensitiveStr::Ascii("y"),
        dictgen::InsensitiveStr::Ascii("yed"),
        dictgen::InsensitiveStr::Ascii("yer"),
        dictgen::InsensitiveStr::Ascii("ying"),
        dictgen::InsensitiveStr::Ascii("yiong"),
        dictgen::InsensitiveStr::Ascii("yoed"),
        dictgen::InsensitiveStr::Ascii("yoer"),
        dictgen::InsensitiveStr::Ascii("yoing"),
        dictgen::InsensitiveStr::Ascii("yong"),
        dictgen::InsensitiveStr::Ascii("ys"),
    ],
    values: &[
        &["destruction"],
        &["distractions"],
        &["destruct"],
        &["destructed"],
        &["destructor"],
        &["destructors"],
        &["distribute"],
        &["distributed"],
        &["distributors"],
        &["destroy"],
        &["destroyed"],
        &["destroying"],
        &["destroys"],
        &["destroys"],
        &["destroyers"],
        &["destroyed", "destroys"],
        &["destroyers"],
        &["destroyers"],
        &["destroys"],
        &["destroyers"],
        &["destruction"],
        &["destruction"],
        &["destruction"],
        &["destructive"],
        &["destruction"],
        &["destruction"],
        &["destructor"],
        &["destructors"],
        &["destruction"],
        &["destructive"],
        &["destructor"],
        &["destructors"],
        &["destructor"],
        &["destructors"],
        &["destroy"],
        &["destroyed"],
        &["destroyer"],
        &["destroying"],
        &["destroying"],
        &["destroyed"],
        &["destroyer"],
        &["destroying"],
        &["destroying"],
        &["destroys"],
    ],
    range: 1..=7,
};

static WORD_DESTO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DESTO_CHILDREN),
    value: None,
};

pub static WORD_DESTO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("p"),
        dictgen::InsensitiveStr::Ascii("ps"),
        dictgen::InsensitiveStr::Ascii("ried"),
        dictgen::InsensitiveStr::Ascii("rt"),
        dictgen::InsensitiveStr::Ascii("ry"),
        dictgen::InsensitiveStr::Ascii("ryed"),
        dictgen::InsensitiveStr::Ascii("ryer"),
        dictgen::InsensitiveStr::Ascii("ryers"),
        dictgen::InsensitiveStr::Ascii("rying"),
        dictgen::InsensitiveStr::Ascii("rys"),
        dictgen::InsensitiveStr::Ascii("y"),
        dictgen::InsensitiveStr::Ascii("yed"),
        dictgen::InsensitiveStr::Ascii("ys"),
    ],
    values: &[
        &["desktop"],
        &["desktops"],
        &["destroyed"],
        &["distort"],
        &["destroy"],
        &["destroyed"],
        &["destroyer"],
        &["destroyers"],
        &["destroying"],
        &["destroys"],
        &["destroy"],
        &["destroyed"],
        &["destroys"],
    ],
    range: 1..=5,
};

static WORD_DESTK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DESTK_CHILDREN),
    value: None,
};

pub static WORD_DESTK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("op"),
        dictgen::InsensitiveStr::Ascii("ops"),
    ],
    values: &[&["desktop"], &["desktops"]],
    range: 2..=3,
};

static WORD_DESTI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DESTI_CHILDREN),
    value: None,
};

pub static WORD_DESTI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("antion"),
        dictgen::InsensitiveStr::Ascii("antions"),
        dictgen::InsensitiveStr::Ascii("ation"),
        dictgen::InsensitiveStr::Ascii("ations"),
        dictgen::InsensitiveStr::Ascii("naion"),
        dictgen::InsensitiveStr::Ascii("naions"),
        dictgen::InsensitiveStr::Ascii("naiton"),
        dictgen::InsensitiveStr::Ascii("naitons"),
        dictgen::InsensitiveStr::Ascii("narion"),
        dictgen::InsensitiveStr::Ascii("narions"),
        dictgen::InsensitiveStr::Ascii("nataion"),
        dictgen::InsensitiveStr::Ascii("nataions"),
        dictgen::InsensitiveStr::Ascii("natin"),
        dictgen::InsensitiveStr::Ascii("natino"),
        dictgen::InsensitiveStr::Ascii("natinos"),
        dictgen::InsensitiveStr::Ascii("natins"),
        dictgen::InsensitiveStr::Ascii("nationhash"),
        dictgen::InsensitiveStr::Ascii("nato"),
        dictgen::InsensitiveStr::Ascii("naton"),
        dictgen::InsensitiveStr::Ascii("natons"),
        dictgen::InsensitiveStr::Ascii("nction"),
        dictgen::InsensitiveStr::Ascii("nctions"),
        dictgen::InsensitiveStr::Ascii("ney"),
        dictgen::InsensitiveStr::Ascii("nguish"),
        dictgen::InsensitiveStr::Ascii("ntation"),
        dictgen::InsensitiveStr::Ascii("ntations"),
        dictgen::InsensitiveStr::Ascii("nty"),
        dictgen::InsensitiveStr::Ascii("onation"),
        dictgen::InsensitiveStr::Ascii("onations"),
    ],
    values: &[
        &["destinations", "destination"],
        &["destinations"],
        &["destination"],
        &["destinations"],
        &["destination"],
        &["destinations"],
        &["destinations", "destination"],
        &["destinations"],
        &["destination"],
        &["destinations"],
        &["destination"],
        &["destinations"],
        &["destinations", "destination"],
        &["destination"],
        &["destinations"],
        &["destinations"],
        &["destinations"],
        &["destination"],
        &["destination"],
        &["destinations"],
        &["destination"],
        &["destinations"],
        &["destiny"],
        &["distinguish"],
        &["destination"],
        &["destinations"],
        &["destiny"],
        &["destination"],
        &["destinations"],
    ],
    range: 3..=10,
};

static WORD_DESTA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DESTA_CHILDREN),
    value: None,
};

pub static WORD_DESTA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("blized"),
        dictgen::InsensitiveStr::Ascii("nation"),
        dictgen::InsensitiveStr::Ascii("nations"),
    ],
    values: &[&["destabilized"], &["destination"], &["destinations"]],
    range: 6..=7,
};

static WORD_DESS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DESS_CHILDREN),
    value: None,
};

pub static WORD_DESS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cribe"),
        dictgen::InsensitiveStr::Ascii("cribing"),
        dictgen::InsensitiveStr::Ascii("cription"),
        dictgen::InsensitiveStr::Ascii("ertation"),
        dictgen::InsensitiveStr::Ascii("icate"),
        dictgen::InsensitiveStr::Ascii("icated"),
        dictgen::InsensitiveStr::Ascii("ication"),
        dictgen::InsensitiveStr::Ascii("igned"),
        dictgen::InsensitiveStr::Ascii("tructor"),
    ],
    values: &[
        &["describe"],
        &["describing"],
        &["description"],
        &["dissertation"],
        &["desiccate"],
        &["desiccated"],
        &["desiccation"],
        &["designed"],
        &["destructor"],
    ],
    range: 5..=8,
};

static WORD_DESR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DESR_CHILDREN),
    value: None,
};

pub static WORD_DESR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ciption"),
        dictgen::InsensitiveStr::Ascii("ciptions"),
        dictgen::InsensitiveStr::Ascii("egarding"),
        dictgen::InsensitiveStr::Ascii("iable"),
        dictgen::InsensitiveStr::Ascii("ibe"),
        dictgen::InsensitiveStr::Ascii("ibed"),
        dictgen::InsensitiveStr::Ascii("ibes"),
        dictgen::InsensitiveStr::Ascii("ibing"),
        dictgen::InsensitiveStr::Ascii("iption"),
        dictgen::InsensitiveStr::Ascii("iptions"),
        dictgen::InsensitiveStr::Ascii("iptor"),
        dictgen::InsensitiveStr::Ascii("iptors"),
        dictgen::InsensitiveStr::Ascii("ire"),
        dictgen::InsensitiveStr::Ascii("ired"),
        dictgen::InsensitiveStr::Ascii("oyer"),
    ],
    values: &[
        &["description"],
        &["descriptions"],
        &["disregarding"],
        &["desirable"],
        &["describe"],
        &["described"],
        &["describes"],
        &["describing"],
        &["description"],
        &["descriptions"],
        &["descriptor"],
        &["descriptors"],
        &["desire"],
        &["desired"],
        &["destroyer"],
    ],
    range: 3..=8,
};

static WORD_DESQ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DESQ_CHILDREN),
    value: None,
};

pub static WORD_DESQ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ualified")],
    values: &[&["disqualified"]],
    range: 8..=8,
};

static WORD_DESP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DESP_CHILDREN),
    value: None,
};

pub static WORD_DESP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("arate"),
        dictgen::InsensitiveStr::Ascii("arately"),
        dictgen::InsensitiveStr::Ascii("aration"),
        dictgen::InsensitiveStr::Ascii("ciable"),
        dictgen::InsensitiveStr::Ascii("ectively"),
        dictgen::InsensitiveStr::Ascii("ensaries"),
        dictgen::InsensitiveStr::Ascii("eratedly"),
        dictgen::InsensitiveStr::Ascii("eratelly"),
        dictgen::InsensitiveStr::Ascii("erating"),
        dictgen::InsensitiveStr::Ascii("eratley"),
        dictgen::InsensitiveStr::Ascii("eratly"),
        dictgen::InsensitiveStr::Ascii("erato"),
        dictgen::InsensitiveStr::Ascii("eretly"),
        dictgen::InsensitiveStr::Ascii("icaple"),
        dictgen::InsensitiveStr::Ascii("icible"),
        dictgen::InsensitiveStr::Ascii("ict"),
        dictgen::InsensitiveStr::Ascii("ide"),
        dictgen::InsensitiveStr::Ascii("ides"),
        dictgen::InsensitiveStr::Ascii("ies"),
        dictgen::InsensitiveStr::Ascii("irately"),
        dictgen::InsensitiveStr::Ascii("iration"),
        dictgen::InsensitiveStr::Ascii("iste"),
        dictgen::InsensitiveStr::Ascii("lay"),
        dictgen::InsensitiveStr::Ascii("layed"),
        dictgen::InsensitiveStr::Ascii("lays"),
        dictgen::InsensitiveStr::Ascii("oited"),
        dictgen::InsensitiveStr::Ascii("osit"),
        dictgen::InsensitiveStr::Ascii("osition"),
    ],
    values: &[
        &["desperate", "disparate"],
        &["desperately"],
        &["desperation"],
        &["despicable"],
        &["respectively"],
        &["dispensaries"],
        &["desperately"],
        &["desperately"],
        &["desperation"],
        &["desperately"],
        &["desperately"],
        &["desperation"],
        &["desperately"],
        &["despicable"],
        &["despicable"],
        &["depict"],
        &["despised"],
        &["despised"],
        &["despise"],
        &["desperately"],
        &["desperation"],
        &["despise"],
        &["display"],
        &["displayed"],
        &["displays"],
        &["deposited"],
        &["deposit", "deposition"],
        &["disposition"],
    ],
    range: 3..=8,
};

static WORD_DESO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DESO_CHILDREN),
    value: None,
};

pub static WORD_DESO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("gn"),
        dictgen::InsensitiveStr::Ascii("gned"),
        dictgen::InsensitiveStr::Ascii("gner"),
        dictgen::InsensitiveStr::Ascii("gning"),
        dictgen::InsensitiveStr::Ascii("gns"),
        dictgen::InsensitiveStr::Ascii("lve"),
        dictgen::InsensitiveStr::Ascii("mnd"),
        dictgen::InsensitiveStr::Ascii("rder"),
        dictgen::InsensitiveStr::Ascii("riented"),
    ],
    values: &[
        &["design"],
        &["designed"],
        &["designer"],
        &["designing"],
        &["designs"],
        &["dissolve"],
        &["desmond"],
        &["disorder"],
        &["disoriented"],
    ],
    range: 2..=7,
};

static WORD_DESN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DESN_CHILDREN),
    value: None,
};

pub static WORD_DESN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("ely"),
        dictgen::InsensitiveStr::Ascii("ity"),
        dictgen::InsensitiveStr::Ascii("se"),
    ],
    values: &[
        &["dense"],
        &["densely"],
        &["density", "destiny"],
        &["dense"],
    ],
    range: 1..=3,
};

static WORD_DESL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DESL_CHILDREN),
    value: None,
};

pub static WORD_DESL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ected"),
        dictgen::InsensitiveStr::Ascii("ects"),
        dictgen::InsensitiveStr::Ascii("top"),
        dictgen::InsensitiveStr::Ascii("tops"),
    ],
    values: &[&["deselected"], &["deselects"], &["desktop"], &["desktops"]],
    range: 3..=5,
};

static WORD_DESK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DESK_CHILDREN),
    value: None,
};

pub static WORD_DESK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("op"),
        dictgen::InsensitiveStr::Ascii("ops"),
        dictgen::InsensitiveStr::Ascii("tiop"),
        dictgen::InsensitiveStr::Ascii("topbsd"),
        dictgen::InsensitiveStr::Ascii("topos"),
        dictgen::InsensitiveStr::Ascii("ys"),
    ],
    values: &[
        &["desktop"],
        &["desktops"],
        &["desktop"],
        &["desktops"],
        &["desktops"],
        &["disguise"],
    ],
    range: 2..=6,
};

static WORD_DESI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DESI_CHILDREN),
    value: None,
};

pub static WORD_DESI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ar"),
        dictgen::InsensitiveStr::Ascii("cate"),
        dictgen::InsensitiveStr::Ascii("cion"),
        dictgen::InsensitiveStr::Ascii("cions"),
        dictgen::InsensitiveStr::Ascii("cive"),
        dictgen::InsensitiveStr::Ascii("de"),
        dictgen::InsensitiveStr::Ascii("ded"),
        dictgen::InsensitiveStr::Ascii("des"),
        dictgen::InsensitiveStr::Ascii("g"),
        dictgen::InsensitiveStr::Ascii("gern"),
        dictgen::InsensitiveStr::Ascii("gining"),
        dictgen::InsensitiveStr::Ascii("gnacion"),
        dictgen::InsensitiveStr::Ascii("gnad"),
        dictgen::InsensitiveStr::Ascii("gnade"),
        dictgen::InsensitiveStr::Ascii("gnato"),
        dictgen::InsensitiveStr::Ascii("gnd"),
        dictgen::InsensitiveStr::Ascii("gnes"),
        dictgen::InsensitiveStr::Ascii("gnet"),
        dictgen::InsensitiveStr::Ascii("gnstion"),
        dictgen::InsensitiveStr::Ascii("llusioned"),
        dictgen::InsensitiveStr::Ascii("nation"),
        dictgen::InsensitiveStr::Ascii("nations"),
        dictgen::InsensitiveStr::Ascii("ne"),
        dictgen::InsensitiveStr::Ascii("ng"),
        dictgen::InsensitiveStr::Ascii("ngable"),
        dictgen::InsensitiveStr::Ascii("ngage"),
        dictgen::InsensitiveStr::Ascii("ngation"),
        dictgen::InsensitiveStr::Ascii("nged"),
        dictgen::InsensitiveStr::Ascii("nger"),
        dictgen::InsensitiveStr::Ascii("ngers"),
        dictgen::InsensitiveStr::Ascii("nging"),
        dictgen::InsensitiveStr::Ascii("ngn"),
        dictgen::InsensitiveStr::Ascii("ngned"),
        dictgen::InsensitiveStr::Ascii("ngner"),
        dictgen::InsensitiveStr::Ascii("ngning"),
        dictgen::InsensitiveStr::Ascii("ngns"),
        dictgen::InsensitiveStr::Ascii("ngs"),
        dictgen::InsensitiveStr::Ascii("ntaiton"),
        dictgen::InsensitiveStr::Ascii("ntaitons"),
        dictgen::InsensitiveStr::Ascii("ntation"),
        dictgen::InsensitiveStr::Ascii("ntations"),
        dictgen::InsensitiveStr::Ascii("ntegrated"),
        dictgen::InsensitiveStr::Ascii("ntegration"),
        dictgen::InsensitiveStr::Ascii("nterested"),
        dictgen::InsensitiveStr::Ascii("nty"),
        dictgen::InsensitiveStr::Ascii("pite"),
        dictgen::InsensitiveStr::Ascii("reable"),
        dictgen::InsensitiveStr::Ascii("sion"),
        dictgen::InsensitiveStr::Ascii("sions"),
        dictgen::InsensitiveStr::Ascii("table"),
        dictgen::InsensitiveStr::Ascii("tination"),
        dictgen::InsensitiveStr::Ascii("tinations"),
        dictgen::InsensitiveStr::Ascii("tion"),
        dictgen::InsensitiveStr::Ascii("tions"),
        dictgen::InsensitiveStr::Ascii("tnation"),
        dictgen::InsensitiveStr::Ascii("tnations"),
        dictgen::InsensitiveStr::Ascii("tned"),
        dictgen::InsensitiveStr::Ascii("tny"),
    ],
    values: &[
        &["desire"],
        &["desiccate"],
        &["decision"],
        &["decisions"],
        &["decisive"],
        &["decide"],
        &["decided"],
        &["decides"],
        &["design"],
        &["designer"],
        &["designing"],
        &["designation"],
        &["designated"],
        &["designated"],
        &["designation"],
        &["designed"],
        &["designs"],
        &["designated"],
        &["designation"],
        &["disillusioned"],
        &["destination"],
        &["destinations"],
        &["design"],
        &["design"],
        &["designable"],
        &["disengage"],
        &["designation"],
        &["designed"],
        &["designer"],
        &["designers"],
        &["designing"],
        &["design"],
        &["designed"],
        &["designer"],
        &["designing"],
        &["designs"],
        &["designs"],
        &["destination"],
        &["destinations"],
        &["destination"],
        &["destinations"],
        &["disintegrated"],
        &["disintegration"],
        &["disinterested"],
        &["density", "destiny"],
        &["despite"],
        &["desirable"],
        &["decision"],
        &["decisions"],
        &["desirable"],
        &["destination"],
        &["destinations"],
        &["decision"],
        &["decisions"],
        &["destination"],
        &["destinations"],
        &["destined"],
        &["destiny"],
    ],
    range: 1..=10,
};

static WORD_DESG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DESG_CHILDREN),
    value: None,
};

pub static WORD_DESG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("in"),
        dictgen::InsensitiveStr::Ascii("inated"),
        dictgen::InsensitiveStr::Ascii("ination"),
        dictgen::InsensitiveStr::Ascii("inations"),
        dictgen::InsensitiveStr::Ascii("ined"),
        dictgen::InsensitiveStr::Ascii("iner"),
        dictgen::InsensitiveStr::Ascii("iners"),
        dictgen::InsensitiveStr::Ascii("ining"),
        dictgen::InsensitiveStr::Ascii("ins"),
        dictgen::InsensitiveStr::Ascii("ustingly"),
    ],
    values: &[
        &["design"],
        &["designated"],
        &["designation"],
        &["destinations"],
        &["designed"],
        &["designer"],
        &["designers"],
        &["designing"],
        &["designs"],
        &["disgustingly"],
    ],
    range: 2..=8,
};

static WORD_DESE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DESE_CHILDREN),
    value: None,
};

pub static WORD_DESE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("lct"),
        dictgen::InsensitiveStr::Ascii("lctable"),
        dictgen::InsensitiveStr::Ascii("lctables"),
        dictgen::InsensitiveStr::Ascii("lcted"),
        dictgen::InsensitiveStr::Ascii("lcting"),
        dictgen::InsensitiveStr::Ascii("ncitized"),
        dictgen::InsensitiveStr::Ascii("nsatized"),
        dictgen::InsensitiveStr::Ascii("nsitied"),
        dictgen::InsensitiveStr::Ascii("nsitived"),
        dictgen::InsensitiveStr::Ascii("nsitzed"),
        dictgen::InsensitiveStr::Ascii("ntisize"),
        dictgen::InsensitiveStr::Ascii("ntisized"),
        dictgen::InsensitiveStr::Ascii("ntitized"),
        dictgen::InsensitiveStr::Ascii("ntizised"),
        dictgen::InsensitiveStr::Ascii("ntralized"),
        dictgen::InsensitiveStr::Ascii("pears"),
        dictgen::InsensitiveStr::Ascii("railise"),
        dictgen::InsensitiveStr::Ascii("railize"),
        dictgen::InsensitiveStr::Ascii("ralization"),
        dictgen::InsensitiveStr::Ascii("ralized"),
        dictgen::InsensitiveStr::Ascii("rialisazion"),
        dictgen::InsensitiveStr::Ascii("rializaed"),
        dictgen::InsensitiveStr::Ascii("rializazion"),
        dictgen::InsensitiveStr::Ascii("rialsiation"),
        dictgen::InsensitiveStr::Ascii("rialsie"),
        dictgen::InsensitiveStr::Ascii("rialsied"),
        dictgen::InsensitiveStr::Ascii("rialsies"),
        dictgen::InsensitiveStr::Ascii("rialsing"),
        dictgen::InsensitiveStr::Ascii("rialze"),
        dictgen::InsensitiveStr::Ascii("rialzed"),
        dictgen::InsensitiveStr::Ascii("rialzes"),
        dictgen::InsensitiveStr::Ascii("rialziation"),
        dictgen::InsensitiveStr::Ascii("rialzie"),
        dictgen::InsensitiveStr::Ascii("rialzied"),
        dictgen::InsensitiveStr::Ascii("rialzies"),
        dictgen::InsensitiveStr::Ascii("rialzing"),
    ],
    values: &[
        &["deselect"],
        &["deselectable"],
        &["deselectable"],
        &["deselected"],
        &["deselecting"],
        &["desensitized"],
        &["desensitized"],
        &["desensitized"],
        &["desensitized"],
        &["desensitized"],
        &["desensitized"],
        &["desensitized"],
        &["desensitized"],
        &["desensitised"],
        &["decentralized"],
        &["disappears"],
        &["deserialise"],
        &["deserialize"],
        &["deserialization"],
        &["deserialized"],
        &["deserialisation"],
        &["deserialized"],
        &["deserialization"],
        &["deserialisation"],
        &["deserialise"],
        &["deserialised"],
        &["deserialises"],
        &["deserialising"],
        &["deserialize"],
        &["deserialized"],
        &["deserializes"],
        &["deserialization"],
        &["deserialize"],
        &["deserialized"],
        &["deserializes"],
        &["deserializing"],
    ],
    range: 3..=11,
};

static WORD_DESC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_DESC_CHILDREN),
    value: None,
};

static WORD_DESC_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_DESCA_NODE),
    None,
    Some(&WORD_DESCC_NODE),
    None,
    Some(&WORD_DESCE_NODE),
    None,
    None,
    None,
    Some(&WORD_DESCI_NODE),
    None,
    Some(&WORD_DESCK_NODE),
    None,
    None,
    None,
    Some(&WORD_DESCO_NODE),
    Some(&WORD_DESCP_NODE),
    None,
    Some(&WORD_DESCR_NODE),
    None,
    Some(&WORD_DESCT_NODE),
    Some(&WORD_DESCU_NODE),
    Some(&WORD_DESCV_NODE),
    None,
    None,
    None,
    None,
];

static WORD_DESCV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DESCV_CHILDREN),
    value: None,
};

pub static WORD_DESCV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ription"),
        dictgen::InsensitiveStr::Ascii("riptions"),
    ],
    values: &[&["description"], &["descriptions"]],
    range: 7..=8,
};

static WORD_DESCU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DESCU_CHILDREN),
    value: None,
};

pub static WORD_DESCU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ss")],
    values: &[&["discuss"]],
    range: 2..=2,
};

static WORD_DESCT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DESCT_CHILDREN),
    value: None,
};

pub static WORD_DESCT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("iption"),
        dictgen::InsensitiveStr::Ascii("iptions"),
        dictgen::InsensitiveStr::Ascii("iptor"),
        dictgen::InsensitiveStr::Ascii("iptors"),
        dictgen::InsensitiveStr::Ascii("op"),
        dictgen::InsensitiveStr::Ascii("ructed"),
        dictgen::InsensitiveStr::Ascii("ruction"),
        dictgen::InsensitiveStr::Ascii("ructive"),
        dictgen::InsensitiveStr::Ascii("ructor"),
        dictgen::InsensitiveStr::Ascii("ructors"),
    ],
    values: &[
        &["description"],
        &["descriptions"],
        &["descriptor"],
        &["descriptors"],
        &["desktop"],
        &["destructed"],
        &["destruction"],
        &["destructive"],
        &["destructor"],
        &["destructors"],
    ],
    range: 2..=7,
};

static WORD_DESCR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_DESCR_CHILDREN),
    value: None,
};

static WORD_DESCR_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    None,
    None,
    Some(&WORD_DESCRE_NODE),
    None,
    None,
    None,
    Some(&WORD_DESCRI_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_DESCRP_NODE),
    None,
    None,
    None,
    Some(&WORD_DESCRT_NODE),
    Some(&WORD_DESCRU_NODE),
    None,
    None,
    None,
    Some(&WORD_DESCRY_NODE),
    None,
];

static WORD_DESCRY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DESCRY_CHILDREN),
    value: None,
};

pub static WORD_DESCRY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("be"),
        dictgen::InsensitiveStr::Ascii("bing"),
        dictgen::InsensitiveStr::Ascii("ption"),
        dictgen::InsensitiveStr::Ascii("ptions"),
    ],
    values: &[
        &["describe"],
        &["describing"],
        &["description"],
        &["descriptions"],
    ],
    range: 2..=6,
};

static WORD_DESCRU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DESCRU_CHILDREN),
    value: None,
};

pub static WORD_DESCRU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("tor")],
    values: &[&["destructor"]],
    range: 3..=3,
};

static WORD_DESCRT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DESCRT_CHILDREN),
    value: None,
};

pub static WORD_DESCRT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("iption"),
        dictgen::InsensitiveStr::Ascii("iptions"),
    ],
    values: &[&["description"], &["descriptions"]],
    range: 6..=7,
};

static WORD_DESCRP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DESCRP_CHILDREN),
    value: None,
};

pub static WORD_DESCRP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ition"),
        dictgen::InsensitiveStr::Ascii("tion"),
        dictgen::InsensitiveStr::Ascii("tions"),
        dictgen::InsensitiveStr::Ascii("tor"),
        dictgen::InsensitiveStr::Ascii("tors"),
    ],
    values: &[
        &["descriptions"],
        &["description"],
        &["descriptions"],
        &["descriptor"],
        &["descriptors"],
    ],
    range: 3..=5,
};

static WORD_DESCRI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_DESCRI_CHILDREN),
    value: None,
};

static WORD_DESCRI_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    Some(&WORD_DESCRIB_NODE),
    Some(&WORD_DESCRIC_NODE),
    None,
    Some(&WORD_DESCRIE_NODE),
    None,
    None,
    None,
    Some(&WORD_DESCRII_NODE),
    None,
    None,
    None,
    Some(&WORD_DESCRIM_NODE),
    None,
    Some(&WORD_DESCRIO_NODE),
    Some(&WORD_DESCRIP_NODE),
    None,
    None,
    Some(&WORD_DESCRIS_NODE),
    Some(&WORD_DESCRIT_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_DESCRIT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DESCRIT_CHILDREN),
    value: None,
};

pub static WORD_DESCRIT_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("ion"),
            dictgen::InsensitiveStr::Ascii("or"),
            dictgen::InsensitiveStr::Ascii("ors"),
            dictgen::InsensitiveStr::Ascii("pion"),
            dictgen::InsensitiveStr::Ascii("pions"),
            dictgen::InsensitiveStr::Ascii("piton"),
            dictgen::InsensitiveStr::Ascii("pitons"),
            dictgen::InsensitiveStr::Ascii("por"),
            dictgen::InsensitiveStr::Ascii("pors"),
            dictgen::InsensitiveStr::Ascii("pr"),
            dictgen::InsensitiveStr::Ascii("pro"),
            dictgen::InsensitiveStr::Ascii("pros"),
            dictgen::InsensitiveStr::Ascii("prs"),
            dictgen::InsensitiveStr::Ascii("ption"),
            dictgen::InsensitiveStr::Ascii("ptions"),
            dictgen::InsensitiveStr::Ascii("ptive"),
            dictgen::InsensitiveStr::Ascii("ptor"),
            dictgen::InsensitiveStr::Ascii("ptors"),
        ],
        values: &[
            &["description"],
            &["descriptor"],
            &["descriptors"],
            &["descriptions", "description"],
            &["descriptions"],
            &["description"],
            &["descriptions"],
            &["descriptor"],
            &["descriptors"],
            &["descriptor"],
            &["descriptor"],
            &["descriptors"],
            &["descriptors"],
            &["description"],
            &["descriptions"],
            &["descriptive"],
            &["descriptor"],
            &["descriptors"],
        ],
        range: 2..=6,
    };

static WORD_DESCRIS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DESCRIS_CHILDREN),
    value: None,
};

pub static WORD_DESCRIS_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[dictgen::InsensitiveStr::Ascii("e")],
        values: &[&["describes"]],
        range: 1..=1,
    };

static WORD_DESCRIP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DESCRIP_CHILDREN),
    value: None,
};

pub static WORD_DESCRIP_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("cion"),
            dictgen::InsensitiveStr::Ascii("e"),
            dictgen::InsensitiveStr::Ascii("ed"),
            dictgen::InsensitiveStr::Ascii("es"),
            dictgen::InsensitiveStr::Ascii("ing"),
            dictgen::InsensitiveStr::Ascii("ition"),
            dictgen::InsensitiveStr::Ascii("iton"),
            dictgen::InsensitiveStr::Ascii("or"),
            dictgen::InsensitiveStr::Ascii("ors"),
            dictgen::InsensitiveStr::Ascii("otrs"),
            dictgen::InsensitiveStr::Ascii("ter"),
            dictgen::InsensitiveStr::Ascii("ters"),
            dictgen::InsensitiveStr::Ascii("tino"),
            dictgen::InsensitiveStr::Ascii("tio"),
            dictgen::InsensitiveStr::Ascii("tiom"),
            dictgen::InsensitiveStr::Ascii("tionm"),
            dictgen::InsensitiveStr::Ascii("tior"),
            dictgen::InsensitiveStr::Ascii("tiors"),
            dictgen::InsensitiveStr::Ascii("tivos"),
            dictgen::InsensitiveStr::Ascii("to"),
            dictgen::InsensitiveStr::Ascii("toin"),
            dictgen::InsensitiveStr::Ascii("toins"),
            dictgen::InsensitiveStr::Ascii("ton"),
            dictgen::InsensitiveStr::Ascii("tons"),
            dictgen::InsensitiveStr::Ascii("tot"),
            dictgen::InsensitiveStr::Ascii("toy"),
            dictgen::InsensitiveStr::Ascii("tuve"),
        ],
        values: &[
            &["description"],
            &["describe"],
            &["described"],
            &["describes"],
            &["describing"],
            &["description"],
            &["descriptions"],
            &["descriptor"],
            &["descriptors"],
            &["descriptors"],
            &["descriptor"],
            &["descriptors"],
            &["description"],
            &["description"],
            &["description"],
            &["description"],
            &["descriptor"],
            &["descriptors"],
            &["descriptions"],
            &["descriptor"],
            &["descriptions", "description"],
            &["descriptions"],
            &["description"],
            &["descriptions"],
            &["descriptor"],
            &["descriptor"],
            &["descriptive"],
        ],
        range: 1..=5,
    };

static WORD_DESCRIO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DESCRIO_CHILDREN),
    value: None,
};

pub static WORD_DESCRIO_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("nt"),
            dictgen::InsensitiveStr::Ascii("tor"),
        ],
        values: &[&["description"], &["descriptor"]],
        range: 2..=3,
    };

static WORD_DESCRIM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DESCRIM_CHILDREN),
    value: None,
};

pub static WORD_DESCRIM_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("inant"),
            dictgen::InsensitiveStr::Ascii("inate"),
            dictgen::InsensitiveStr::Ascii("inated"),
            dictgen::InsensitiveStr::Ascii("inates"),
            dictgen::InsensitiveStr::Ascii("inating"),
        ],
        values: &[
            &["discriminant"],
            &["discriminate"],
            &["discriminated"],
            &["discriminates"],
            &["discriminating"],
        ],
        range: 5..=7,
    };

static WORD_DESCRII_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DESCRII_CHILDREN),
    value: None,
};

pub static WORD_DESCRII_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[dictgen::InsensitiveStr::Ascii("bes")],
        values: &[&["describes"]],
        range: 3..=3,
    };

static WORD_DESCRIE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DESCRIE_CHILDREN),
    value: Some(&["describe"]),
};

pub static WORD_DESCRIE_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[],
        values: &[],
        range: 0..=0,
    };

static WORD_DESCRIC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DESCRIC_CHILDREN),
    value: None,
};

pub static WORD_DESCRIC_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("e"),
            dictgen::InsensitiveStr::Ascii("ed"),
            dictgen::InsensitiveStr::Ascii("es"),
            dictgen::InsensitiveStr::Ascii("ing"),
        ],
        values: &[
            &["describe"],
            &["described"],
            &["describes"],
            &["describing"],
        ],
        range: 1..=3,
    };

static WORD_DESCRIB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DESCRIB_CHILDREN),
    value: Some(&["describe"]),
};

pub static WORD_DESCRIB_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("bed"),
            dictgen::InsensitiveStr::Ascii("ibg"),
            dictgen::InsensitiveStr::Ascii("iste"),
            dictgen::InsensitiveStr::Ascii("ng"),
            dictgen::InsensitiveStr::Ascii("s"),
            dictgen::InsensitiveStr::Ascii("tion"),
            dictgen::InsensitiveStr::Ascii("tions"),
        ],
        values: &[
            &["described"],
            &["describing"],
            &["describes"],
            &["describing"],
            &["describe", "describes"],
            &["description"],
            &["descriptions"],
        ],
        range: 1..=5,
    };

static WORD_DESCRE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DESCRE_CHILDREN),
    value: None,
};

pub static WORD_DESCRE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ase"),
        dictgen::InsensitiveStr::Ascii("ased"),
        dictgen::InsensitiveStr::Ascii("ases"),
        dictgen::InsensitiveStr::Ascii("asing"),
        dictgen::InsensitiveStr::Ascii("menting"),
        dictgen::InsensitiveStr::Ascii("pancy"),
        dictgen::InsensitiveStr::Ascii("te"),
    ],
    values: &[
        &["decrease"],
        &["decreased"],
        &["decreases"],
        &["decreasing"],
        &["decrementing"],
        &["discrepancy"],
        &["discrete"],
    ],
    range: 2..=7,
};

static WORD_DESCP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DESCP_CHILDREN),
    value: None,
};

pub static WORD_DESCP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("rition")],
    values: &[&["descriptions"]],
    range: 6..=6,
};

static WORD_DESCO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DESCO_CHILDREN),
    value: None,
};

pub static WORD_DESCO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("nstructed"),
        dictgen::InsensitiveStr::Ascii("ver"),
        dictgen::InsensitiveStr::Ascii("vered"),
        dictgen::InsensitiveStr::Ascii("vering"),
        dictgen::InsensitiveStr::Ascii("very"),
    ],
    values: &[
        &["deconstructed"],
        &["discover"],
        &["discovered"],
        &["discovering"],
        &["discovery"],
    ],
    range: 3..=9,
};

static WORD_DESCK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DESCK_CHILDREN),
    value: None,
};

pub static WORD_DESCK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("top"),
        dictgen::InsensitiveStr::Ascii("tops"),
    ],
    values: &[&["desktop"], &["desktops"]],
    range: 3..=4,
};

static WORD_DESCI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DESCI_CHILDREN),
    value: None,
};

pub static WORD_DESCI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("be"),
        dictgen::InsensitiveStr::Ascii("bed"),
        dictgen::InsensitiveStr::Ascii("bes"),
        dictgen::InsensitiveStr::Ascii("bing"),
        dictgen::InsensitiveStr::Ascii("de"),
        dictgen::InsensitiveStr::Ascii("ded"),
        dictgen::InsensitiveStr::Ascii("des"),
        dictgen::InsensitiveStr::Ascii("ding"),
        dictgen::InsensitiveStr::Ascii("minate"),
        dictgen::InsensitiveStr::Ascii("on"),
        dictgen::InsensitiveStr::Ascii("pable"),
        dictgen::InsensitiveStr::Ascii("ption"),
        dictgen::InsensitiveStr::Ascii("ptions"),
        dictgen::InsensitiveStr::Ascii("ptor"),
        dictgen::InsensitiveStr::Ascii("ptors"),
        dictgen::InsensitiveStr::Ascii("rbe"),
        dictgen::InsensitiveStr::Ascii("rbes"),
        dictgen::InsensitiveStr::Ascii("ribe"),
        dictgen::InsensitiveStr::Ascii("ribed"),
        dictgen::InsensitiveStr::Ascii("ribes"),
        dictgen::InsensitiveStr::Ascii("ribing"),
        dictgen::InsensitiveStr::Ascii("ription"),
        dictgen::InsensitiveStr::Ascii("riptions"),
        dictgen::InsensitiveStr::Ascii("rption"),
        dictgen::InsensitiveStr::Ascii("rptor"),
        dictgen::InsensitiveStr::Ascii("sion"),
        dictgen::InsensitiveStr::Ascii("sions"),
        dictgen::InsensitiveStr::Ascii("ze"),
        dictgen::InsensitiveStr::Ascii("zed"),
    ],
    values: &[
        &["describe"],
        &["described"],
        &["describes"],
        &["describing"],
        &["decide"],
        &["decided"],
        &["decides"],
        &["deciding"],
        &["discriminate", "disseminate", "decimate"],
        &["decision"],
        &["despicable"],
        &["description"],
        &["descriptions"],
        &["descriptor"],
        &["descriptors"],
        &["describe"],
        &["describes"],
        &["describe"],
        &["described"],
        &["describes"],
        &["describing"],
        &["description"],
        &["descriptions"],
        &["descriptions", "description"],
        &["descriptor"],
        &["decision"],
        &["decisions"],
        &["disguise"],
        &["disguised"],
    ],
    range: 2..=8,
};

static WORD_DESCE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DESCE_CHILDREN),
    value: None,
};

pub static WORD_DESCE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ncing"),
        dictgen::InsensitiveStr::Ascii("ndands"),
        dictgen::InsensitiveStr::Ascii("ndat"),
        dictgen::InsensitiveStr::Ascii("ndats"),
        dictgen::InsensitiveStr::Ascii("ndend"),
        dictgen::InsensitiveStr::Ascii("ndends"),
        dictgen::InsensitiveStr::Ascii("ndenta"),
        dictgen::InsensitiveStr::Ascii("ned"),
        dictgen::InsensitiveStr::Ascii("ntants"),
        dictgen::InsensitiveStr::Ascii("ntences"),
        dictgen::InsensitiveStr::Ascii("nting"),
        dictgen::InsensitiveStr::Ascii("rning"),
    ],
    values: &[
        &["descending"],
        &["descendants"],
        &["descendant"],
        &["descendants"],
        &["descended", "descendent"],
        &["descended"],
        &["descendents"],
        &["descend"],
        &["descendants"],
        &["descendents"],
        &["descending"],
        &["descending"],
    ],
    range: 3..=7,
};

static WORD_DESCC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DESCC_CHILDREN),
    value: None,
};

pub static WORD_DESCC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("hedules"),
        dictgen::InsensitiveStr::Ascii("ription"),
    ],
    values: &[&["deschedules"], &["description"]],
    range: 7..=7,
};

static WORD_DESCA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DESCA_CHILDREN),
    value: None,
};

pub static WORD_DESCA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("llocate"),
        dictgen::InsensitiveStr::Ascii("llocated"),
        dictgen::InsensitiveStr::Ascii("ndant"),
        dictgen::InsensitiveStr::Ascii("ndants"),
    ],
    values: &[
        &["deallocate"],
        &["deallocated"],
        &["descendant"],
        &["descendants"],
    ],
    range: 5..=8,
};

static WORD_DESA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DESA_CHILDREN),
    value: None,
};

pub static WORD_DESA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ctivate"),
        dictgen::InsensitiveStr::Ascii("ctivated"),
        dictgen::InsensitiveStr::Ascii("llocate"),
        dictgen::InsensitiveStr::Ascii("llocated"),
        dictgen::InsensitiveStr::Ascii("llocates"),
        dictgen::InsensitiveStr::Ascii("ster"),
    ],
    values: &[
        &["deactivate"],
        &["deactivated"],
        &["deallocate"],
        &["deallocated"],
        &["deallocates"],
        &["disaster"],
    ],
    range: 4..=8,
};

static WORD_DER_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_DER_CHILDREN),
    value: None,
};

static WORD_DER_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_DERA_NODE),
    None,
    None,
    None,
    Some(&WORD_DERE_NODE),
    Some(&WORD_DERF_NODE),
    Some(&WORD_DERG_NODE),
    None,
    Some(&WORD_DERI_NODE),
    None,
    None,
    None,
    Some(&WORD_DERM_NODE),
    None,
    Some(&WORD_DERO_NODE),
    Some(&WORD_DERP_NODE),
    None,
    Some(&WORD_DERR_NODE),
    None,
    Some(&WORD_DERT_NODE),
    Some(&WORD_DERU_NODE),
    Some(&WORD_DERV_NODE),
    None,
    None,
    Some(&WORD_DERY_NODE),
    None,
];

static WORD_DERY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DERY_CHILDREN),
    value: None,
};

pub static WORD_DERY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("pt"),
        dictgen::InsensitiveStr::Ascii("pted"),
        dictgen::InsensitiveStr::Ascii("ption"),
    ],
    values: &[&["decrypt"], &["decrypted"], &["decryption"]],
    range: 2..=5,
};

static WORD_DERV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DERV_CHILDREN),
    value: None,
};

pub static WORD_DERV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("iative"),
        dictgen::InsensitiveStr::Ascii("iatives"),
        dictgen::InsensitiveStr::Ascii("ie"),
        dictgen::InsensitiveStr::Ascii("ied"),
        dictgen::InsensitiveStr::Ascii("ies"),
        dictgen::InsensitiveStr::Ascii("ived"),
    ],
    values: &[
        &["derivative"],
        &["derivatives"],
        &["derive"],
        &["derived"],
        &["derives"],
        &["derived"],
    ],
    range: 2..=7,
};

static WORD_DERU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DERU_CHILDREN),
    value: None,
};

pub static WORD_DERU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("gulation")],
    values: &[&["deregulation"]],
    range: 8..=8,
};

static WORD_DERT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DERT_CHILDREN),
    value: None,
};

pub static WORD_DERT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ermine"),
        dictgen::InsensitiveStr::Ascii("erming"),
        dictgen::InsensitiveStr::Ascii("h"),
    ],
    values: &[&["determine"], &["determining"], &["dearth"]],
    range: 1..=6,
};

static WORD_DERR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DERR_CHILDREN),
    value: None,
};

pub static WORD_DERR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ivatives"),
        dictgen::InsensitiveStr::Ascii("ive"),
        dictgen::InsensitiveStr::Ascii("ived"),
    ],
    values: &[&["derivatives"], &["derive"], &["derived"]],
    range: 3..=8,
};

static WORD_DERP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DERP_CHILDREN),
    value: None,
};

pub static WORD_DERP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("atologist"),
        dictgen::InsensitiveStr::Ascii("ivation"),
        dictgen::InsensitiveStr::Ascii("recated"),
    ],
    values: &[&["dermatologist"], &["deprivation"], &["deprecated"]],
    range: 7..=9,
};

static WORD_DERO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DERO_CHILDREN),
    value: None,
};

pub static WORD_DERO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("gatary"),
        dictgen::InsensitiveStr::Ascii("gatery"),
        dictgen::InsensitiveStr::Ascii("getory"),
        dictgen::InsensitiveStr::Ascii("gitory"),
        dictgen::InsensitiveStr::Ascii("gotary"),
        dictgen::InsensitiveStr::Ascii("gotory"),
    ],
    values: &[
        &["derogatory"],
        &["derogatory"],
        &["derogatory"],
        &["derogatory"],
        &["derogatory"],
        &["derogatory"],
    ],
    range: 6..=6,
};

static WORD_DERM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DERM_CHILDREN),
    value: None,
};

pub static WORD_DERM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("atalogist"),
        dictgen::InsensitiveStr::Ascii("atolagist"),
        dictgen::InsensitiveStr::Ascii("atoligist"),
        dictgen::InsensitiveStr::Ascii("atologyst"),
        dictgen::InsensitiveStr::Ascii("etologist"),
        dictgen::InsensitiveStr::Ascii("ine"),
        dictgen::InsensitiveStr::Ascii("ined"),
        dictgen::InsensitiveStr::Ascii("ines"),
        dictgen::InsensitiveStr::Ascii("ining"),
        dictgen::InsensitiveStr::Ascii("itologist"),
    ],
    values: &[
        &["dermatologist"],
        &["dermatologist"],
        &["dermatologist"],
        &["dermatologist"],
        &["dermatologist"],
        &["determine"],
        &["determined"],
        &["determines"],
        &["determining"],
        &["dermatologist"],
    ],
    range: 3..=9,
};

static WORD_DERI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DERI_CHILDREN),
    value: None,
};

pub static WORD_DERI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("air"),
        dictgen::InsensitiveStr::Ascii("ced"),
        dictgen::InsensitiveStr::Ascii("cteries"),
        dictgen::InsensitiveStr::Ascii("ctery"),
        dictgen::InsensitiveStr::Ascii("cteryes"),
        dictgen::InsensitiveStr::Ascii("cterys"),
        dictgen::InsensitiveStr::Ascii("ffed"),
        dictgen::InsensitiveStr::Ascii("vate"),
        dictgen::InsensitiveStr::Ascii("vaties"),
        dictgen::InsensitiveStr::Ascii("vatio"),
        dictgen::InsensitiveStr::Ascii("vativ"),
        dictgen::InsensitiveStr::Ascii("vativos"),
        dictgen::InsensitiveStr::Ascii("vativs"),
        dictgen::InsensitiveStr::Ascii("ver"),
        dictgen::InsensitiveStr::Ascii("viated"),
        dictgen::InsensitiveStr::Ascii("vitave"),
        dictgen::InsensitiveStr::Ascii("vitaves"),
        dictgen::InsensitiveStr::Ascii("vitive"),
        dictgen::InsensitiveStr::Ascii("vitives"),
        dictgen::InsensitiveStr::Ascii("vitivs"),
        dictgen::InsensitiveStr::Ascii("vtive"),
        dictgen::InsensitiveStr::Ascii("vtives"),
    ],
    values: &[
        &["derriere"],
        &["derived"],
        &["directories"],
        &["directory"],
        &["directories"],
        &["directories"],
        &["derived"],
        &["derivative"],
        &["derivatives"],
        &["derivation"],
        &["derivative"],
        &["derivatives"],
        &["derivatives"],
        &["derive", "driver"],
        &["derived"],
        &["derivative"],
        &["derivatives"],
        &["derivative"],
        &["derivatives"],
        &["derivatives"],
        &["derivative"],
        &["derivatives"],
    ],
    range: 3..=7,
};

static WORD_DERG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DERG_CHILDREN),
    value: None,
};

pub static WORD_DERG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eistered"),
        dictgen::InsensitiveStr::Ascii("istration"),
    ],
    values: &[&["deregistered"], &["deregistration"]],
    range: 8..=9,
};

static WORD_DERF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DERF_CHILDREN),
    value: None,
};

pub static WORD_DERF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("erence"),
        dictgen::InsensitiveStr::Ascii("erencing"),
        dictgen::InsensitiveStr::Ascii("ien"),
        dictgen::InsensitiveStr::Ascii("iend"),
        dictgen::InsensitiveStr::Ascii("ine"),
        dictgen::InsensitiveStr::Ascii("ined"),
    ],
    values: &[
        &["deference", "dereference"],
        &["dereferencing"],
        &["define"],
        &["defined"],
        &["define"],
        &["defined"],
    ],
    range: 3..=8,
};

static WORD_DERE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DERE_CHILDREN),
    value: None,
};

pub static WORD_DERE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ctive"),
        dictgen::InsensitiveStr::Ascii("ctory"),
        dictgen::InsensitiveStr::Ascii("fence"),
        dictgen::InsensitiveStr::Ascii("fenced"),
        dictgen::InsensitiveStr::Ascii("fencing"),
        dictgen::InsensitiveStr::Ascii("fenrence"),
        dictgen::InsensitiveStr::Ascii("ferance"),
        dictgen::InsensitiveStr::Ascii("feranced"),
        dictgen::InsensitiveStr::Ascii("ferances"),
        dictgen::InsensitiveStr::Ascii("ferencable"),
        dictgen::InsensitiveStr::Ascii("ferencce"),
        dictgen::InsensitiveStr::Ascii("ferencced"),
        dictgen::InsensitiveStr::Ascii("ferencces"),
        dictgen::InsensitiveStr::Ascii("ferenccing"),
        dictgen::InsensitiveStr::Ascii("fernce"),
        dictgen::InsensitiveStr::Ascii("fernced"),
        dictgen::InsensitiveStr::Ascii("ferncence"),
        dictgen::InsensitiveStr::Ascii("ferncencer"),
        dictgen::InsensitiveStr::Ascii("ferncencers"),
        dictgen::InsensitiveStr::Ascii("ferncences"),
        dictgen::InsensitiveStr::Ascii("ferncer"),
        dictgen::InsensitiveStr::Ascii("ferncers"),
        dictgen::InsensitiveStr::Ascii("fernces"),
        dictgen::InsensitiveStr::Ascii("ferncing"),
        dictgen::InsensitiveStr::Ascii("fernece"),
        dictgen::InsensitiveStr::Ascii("frencable"),
        dictgen::InsensitiveStr::Ascii("frence"),
        dictgen::InsensitiveStr::Ascii("gistartion"),
        dictgen::InsensitiveStr::Ascii("gisted"),
        dictgen::InsensitiveStr::Ascii("gisteres"),
        dictgen::InsensitiveStr::Ascii("gistrated"),
        dictgen::InsensitiveStr::Ascii("gistred"),
        dictgen::InsensitiveStr::Ascii("giter"),
        dictgen::InsensitiveStr::Ascii("giters"),
        dictgen::InsensitiveStr::Ascii("gualtion"),
        dictgen::InsensitiveStr::Ascii("gulaiton"),
        dictgen::InsensitiveStr::Ascii("gulatin"),
        dictgen::InsensitiveStr::Ascii("ivative"),
        dictgen::InsensitiveStr::Ascii("ivatives"),
        dictgen::InsensitiveStr::Ascii("ive"),
        dictgen::InsensitiveStr::Ascii("ived"),
        dictgen::InsensitiveStr::Ascii("ives"),
        dictgen::InsensitiveStr::Ascii("iving"),
        dictgen::InsensitiveStr::Ascii("vative"),
        dictgen::InsensitiveStr::Ascii("vatives"),
    ],
    values: &[
        &["directive"],
        &["directory"],
        &["dereference"],
        &["dereferenced"],
        &["dereferencing"],
        &["dereference"],
        &["dereference"],
        &["dereferenced"],
        &["dereferences"],
        &["dereferenceable"],
        &["dereference"],
        &["dereferenced"],
        &["dereferences"],
        &["dereferencing"],
        &["dereference"],
        &["dereferenced"],
        &["dereference"],
        &["dereferencer"],
        &["dereferencers"],
        &["dereferences"],
        &["dereferencer"],
        &["dereferencers"],
        &["dereferences"],
        &["dereferencing"],
        &["dereference"],
        &["dereferenceable"],
        &["dereference"],
        &["deregistration"],
        &["deregistered"],
        &["deregisters"],
        &["deregistered"],
        &["deregistered"],
        &["deregister"],
        &["deregisters"],
        &["deregulation"],
        &["deregulation"],
        &["deregulation"],
        &["derivative"],
        &["derivatives"],
        &["derive"],
        &["derived"],
        &["derives"],
        &["deriving"],
        &["derivative"],
        &["derivatives"],
    ],
    range: 3..=11,
};

static WORD_DERA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DERA_CHILDREN),
    value: None,
};

pub static WORD_DERA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("geable"),
        dictgen::InsensitiveStr::Ascii("gotory"),
        dictgen::InsensitiveStr::Ascii("m"),
    ],
    values: &[&["dirigible"], &["derogatory"], &["dram", "dream"]],
    range: 1..=6,
};

static WORD_DEQ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DEQ_CHILDREN),
    value: None,
};

pub static WORD_DEQ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ued"),
        dictgen::InsensitiveStr::Ascii("ueing"),
    ],
    values: &[&["dequeued"], &["dequeuing"]],
    range: 3..=5,
};

static WORD_DEP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_DEP_CHILDREN),
    value: None,
};

static WORD_DEP_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_DEPA_NODE),
    None,
    Some(&WORD_DEPC_NODE),
    Some(&WORD_DEPD_NODE),
    Some(&WORD_DEPE_NODE),
    None,
    None,
    None,
    Some(&WORD_DEPI_NODE),
    None,
    None,
    Some(&WORD_DEPL_NODE),
    None,
    Some(&WORD_DEPN_NODE),
    Some(&WORD_DEPO_NODE),
    None,
    None,
    Some(&WORD_DEPR_NODE),
    Some(&WORD_DEPS_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_DEPS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DEPS_CHILDREN),
    value: None,
};

pub static WORD_DEPS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("erate"),
        dictgen::InsensitiveStr::Ascii("erately"),
        dictgen::InsensitiveStr::Ascii("eration"),
        dictgen::InsensitiveStr::Ascii("ise"),
        dictgen::InsensitiveStr::Ascii("oited"),
    ],
    values: &[
        &["desperate"],
        &["desperately"],
        &["desperation"],
        &["despise"],
        &["deposited"],
    ],
    range: 3..=7,
};

static WORD_DEPR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DEPR_CHILDREN),
    value: None,
};

pub static WORD_DEPR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("acated"),
        dictgen::InsensitiveStr::Ascii("acted"),
        dictgen::InsensitiveStr::Ascii("eacte"),
        dictgen::InsensitiveStr::Ascii("eacted"),
        dictgen::InsensitiveStr::Ascii("eacts"),
        dictgen::InsensitiveStr::Ascii("eate"),
        dictgen::InsensitiveStr::Ascii("eated"),
        dictgen::InsensitiveStr::Ascii("eates"),
        dictgen::InsensitiveStr::Ascii("eating"),
        dictgen::InsensitiveStr::Ascii("ecatedf"),
        dictgen::InsensitiveStr::Ascii("eceate"),
        dictgen::InsensitiveStr::Ascii("eceated"),
        dictgen::InsensitiveStr::Ascii("eceating"),
        dictgen::InsensitiveStr::Ascii("eceation"),
        dictgen::InsensitiveStr::Ascii("ectaed"),
        dictgen::InsensitiveStr::Ascii("ectat"),
        dictgen::InsensitiveStr::Ascii("ectate"),
        dictgen::InsensitiveStr::Ascii("ectated"),
        dictgen::InsensitiveStr::Ascii("ectates"),
        dictgen::InsensitiveStr::Ascii("ectating"),
        dictgen::InsensitiveStr::Ascii("ectation"),
        dictgen::InsensitiveStr::Ascii("ectats"),
        dictgen::InsensitiveStr::Ascii("ected"),
        dictgen::InsensitiveStr::Ascii("esse"),
        dictgen::InsensitiveStr::Ascii("essie"),
        dictgen::InsensitiveStr::Ascii("essief"),
        dictgen::InsensitiveStr::Ascii("essies"),
        dictgen::InsensitiveStr::Ascii("essieve"),
        dictgen::InsensitiveStr::Ascii("essin"),
        dictgen::InsensitiveStr::Ascii("esso"),
        dictgen::InsensitiveStr::Ascii("esssion"),
        dictgen::InsensitiveStr::Ascii("etiate"),
        dictgen::InsensitiveStr::Ascii("etiated"),
        dictgen::InsensitiveStr::Ascii("etiates"),
        dictgen::InsensitiveStr::Ascii("etiating"),
        dictgen::InsensitiveStr::Ascii("etiation"),
        dictgen::InsensitiveStr::Ascii("etiats"),
        dictgen::InsensitiveStr::Ascii("evation"),
        dictgen::InsensitiveStr::Ascii("icate"),
        dictgen::InsensitiveStr::Ascii("icated"),
        dictgen::InsensitiveStr::Ascii("icates"),
        dictgen::InsensitiveStr::Ascii("icating"),
        dictgen::InsensitiveStr::Ascii("ication"),
        dictgen::InsensitiveStr::Ascii("ivating"),
        dictgen::InsensitiveStr::Ascii("ivaton"),
        dictgen::InsensitiveStr::Ascii("ivition"),
        dictgen::InsensitiveStr::Ascii("ovation"),
    ],
    values: &[
        &["deprecated"],
        &["deprecated"],
        &["deprecate"],
        &["deprecated"],
        &["deprecates"],
        &["deprecate"],
        &["deprecated"],
        &["deprecates"],
        &["deprecating"],
        &["deprecated"],
        &["deprecate", "depreciate"],
        &["deprecated", "depreciated"],
        &["depreciating", "deprecating"],
        &["depreciation", "deprecation"],
        &["deprecated"],
        &["deprecate"],
        &["deprecate"],
        &["deprecated"],
        &["deprecates"],
        &["deprecating"],
        &["deprecation"],
        &["deprecates"],
        &["deprecated"],
        &["depressive"],
        &["depressive"],
        &["depressive"],
        &["depressive"],
        &["depressive"],
        &["depression"],
        &["depression"],
        &["depression"],
        &["depreciate", "deprecate"],
        &["depreciated", "deprecated"],
        &["depreciates", "deprecates"],
        &["depreciating", "deprecating"],
        &["depreciation", "deprecation"],
        &["depreciates", "deprecates"],
        &["deprivation"],
        &["deprecate"],
        &["deprecated"],
        &["deprecates"],
        &["deprecating"],
        &["deprivation"],
        &["deprivation"],
        &["deprivation"],
        &["deprivation"],
        &["deprivation"],
    ],
    range: 4..=8,
};

static WORD_DEPO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DEPO_CHILDREN),
    value: None,
};

pub static WORD_DEPO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("isted"),
        dictgen::InsensitiveStr::Ascii("lyed"),
        dictgen::InsensitiveStr::Ascii("lying"),
        dictgen::InsensitiveStr::Ascii("lyment"),
        dictgen::InsensitiveStr::Ascii("rarily"),
        dictgen::InsensitiveStr::Ascii("sint"),
        dictgen::InsensitiveStr::Ascii("sitas"),
        dictgen::InsensitiveStr::Ascii("sitd"),
        dictgen::InsensitiveStr::Ascii("siters"),
        dictgen::InsensitiveStr::Ascii("sites"),
        dictgen::InsensitiveStr::Ascii("sitis"),
        dictgen::InsensitiveStr::Ascii("sitos"),
        dictgen::InsensitiveStr::Ascii("stied"),
        dictgen::InsensitiveStr::Ascii("stis"),
        dictgen::InsensitiveStr::Ascii("y"),
        dictgen::InsensitiveStr::Ascii("yed"),
        dictgen::InsensitiveStr::Ascii("ying"),
    ],
    values: &[
        &["deposited"],
        &["deployed"],
        &["deploying"],
        &["deployment"],
        &["temporarily"],
        &["deposing"],
        &["deposits"],
        &["deposited"],
        &["deposits"],
        &["deposits"],
        &["deposits"],
        &["deposits"],
        &["deposited"],
        &["deposits"],
        &["deploy"],
        &["deployed"],
        &["deploying"],
    ],
    range: 1..=6,
};

static WORD_DEPN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DEPN_CHILDREN),
    value: None,
};

pub static WORD_DEPN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("dant"),
        dictgen::InsensitiveStr::Ascii("ds"),
    ],
    values: &[&["dependant"], &["depends"]],
    range: 2..=4,
};

static WORD_DEPL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DEPL_CHILDREN),
    value: None,
};

pub static WORD_DEPL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("acements"),
        dictgen::InsensitiveStr::Ascii("icated"),
        dictgen::InsensitiveStr::Ascii("oied"),
        dictgen::InsensitiveStr::Ascii("oiment"),
        dictgen::InsensitiveStr::Ascii("oiments"),
        dictgen::InsensitiveStr::Ascii("orabel"),
        dictgen::InsensitiveStr::Ascii("orabil"),
        dictgen::InsensitiveStr::Ascii("orabile"),
        dictgen::InsensitiveStr::Ascii("orible"),
        dictgen::InsensitiveStr::Ascii("oyd"),
        dictgen::InsensitiveStr::Ascii("oyement"),
        dictgen::InsensitiveStr::Ascii("oymenet"),
        dictgen::InsensitiveStr::Ascii("oymenets"),
        dictgen::InsensitiveStr::Ascii("oymnet"),
        dictgen::InsensitiveStr::Ascii("y"),
        dictgen::InsensitiveStr::Ascii("ying"),
        dictgen::InsensitiveStr::Ascii("yoing"),
        dictgen::InsensitiveStr::Ascii("yoment"),
    ],
    values: &[
        &["replacements"],
        &["deprecated"],
        &["deployed"],
        &["deployment"],
        &["deployments"],
        &["deplorable"],
        &["deplorable"],
        &["deplorable"],
        &["deplorable"],
        &["deployed", "deploy"],
        &["deployment"],
        &["deployment"],
        &["deployments"],
        &["deployment"],
        &["deploy", "deeply"],
        &["deploying"],
        &["deploying"],
        &["deployment"],
    ],
    range: 1..=8,
};

static WORD_DEPI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DEPI_CHILDREN),
    value: None,
};

pub static WORD_DEPI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("citng"),
        dictgen::InsensitiveStr::Ascii("citon"),
        dictgen::InsensitiveStr::Ascii("citons"),
        dictgen::InsensitiveStr::Ascii("ctes"),
        dictgen::InsensitiveStr::Ascii("ctin"),
        dictgen::InsensitiveStr::Ascii("tcs"),
    ],
    values: &[
        &["depicting"],
        &["depiction"],
        &["depictions"],
        &["depicts"],
        &["depictions"],
        &["depicts"],
    ],
    range: 3..=6,
};

static WORD_DEPE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_DEPE_CHILDREN),
    value: None,
};

static WORD_DEPE_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    Some(&WORD_DEPEC_NODE),
    Some(&WORD_DEPED_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_DEPEL_NODE),
    None,
    Some(&WORD_DEPEN_NODE),
    None,
    None,
    None,
    Some(&WORD_DEPER_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_DEPER_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DEPER_CHILDREN),
    value: None,
};

pub static WORD_DEPER_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cate"),
        dictgen::InsensitiveStr::Ascii("cated"),
        dictgen::InsensitiveStr::Ascii("cation"),
        dictgen::InsensitiveStr::Ascii("ecate"),
        dictgen::InsensitiveStr::Ascii("ecated"),
        dictgen::InsensitiveStr::Ascii("ecates"),
        dictgen::InsensitiveStr::Ascii("ecating"),
        dictgen::InsensitiveStr::Ascii("ecation"),
    ],
    values: &[
        &["deprecate"],
        &["deprecated"],
        &["deprecation"],
        &["deprecate"],
        &["deprecated"],
        &["deprecates"],
        &["deprecating"],
        &["deprecation"],
    ],
    range: 4..=7,
};

static WORD_DEPEN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_DEPEN_CHILDREN),
    value: None,
};

static WORD_DEPEN_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_DEPENA_NODE),
    None,
    Some(&WORD_DEPENC_NODE),
    Some(&WORD_DEPEND_NODE),
    Some(&WORD_DEPENE_NODE),
    None,
    None,
    None,
    Some(&WORD_DEPENI_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_DEPENN_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_DEPENT_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_DEPENT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DEPENT_CHILDREN),
    value: Some(&["depend"]),
};

pub static WORD_DEPENT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[],
    values: &[],
    range: 0..=0,
};

static WORD_DEPENN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DEPENN_CHILDREN),
    value: None,
};

pub static WORD_DEPENN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ding")],
    values: &[&["depending"]],
    range: 4..=4,
};

static WORD_DEPENI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DEPENI_CHILDREN),
    value: None,
};

pub static WORD_DEPENI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ng")],
    values: &[&["depending", "deepening"]],
    range: 2..=2,
};

static WORD_DEPENE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DEPENE_CHILDREN),
    value: None,
};

pub static WORD_DEPENE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("d"),
        dictgen::InsensitiveStr::Ascii("decies"),
        dictgen::InsensitiveStr::Ascii("decy"),
        dictgen::InsensitiveStr::Ascii("dent"),
        dictgen::InsensitiveStr::Ascii("ncies"),
        dictgen::InsensitiveStr::Ascii("ncis"),
        dictgen::InsensitiveStr::Ascii("ncy"),
        dictgen::InsensitiveStr::Ascii("ncys"),
        dictgen::InsensitiveStr::Ascii("nd"),
        dictgen::InsensitiveStr::Ascii("ndecies"),
        dictgen::InsensitiveStr::Ascii("ndecy"),
        dictgen::InsensitiveStr::Ascii("ndence"),
        dictgen::InsensitiveStr::Ascii("ndencies"),
        dictgen::InsensitiveStr::Ascii("ndency"),
        dictgen::InsensitiveStr::Ascii("ndent"),
        dictgen::InsensitiveStr::Ascii("nding"),
        dictgen::InsensitiveStr::Ascii("nt"),
        dictgen::InsensitiveStr::Ascii("ntly"),
    ],
    values: &[
        &["depend"],
        &["dependencies"],
        &["dependency"],
        &["dependent"],
        &["dependencies"],
        &["dependencies"],
        &["dependency"],
        &["dependencies"],
        &["depend"],
        &["dependencies"],
        &["dependency"],
        &["dependence"],
        &["dependencies"],
        &["dependency"],
        &["dependent"],
        &["depending"],
        &["dependent"],
        &["dependently"],
    ],
    range: 1..=8,
};

static WORD_DEPEND_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DEPEND_CHILDREN),
    value: None,
};

pub static WORD_DEPEND_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ancey"),
        dictgen::InsensitiveStr::Ascii("ancies"),
        dictgen::InsensitiveStr::Ascii("ancy"),
        dictgen::InsensitiveStr::Ascii("ancys"),
        dictgen::InsensitiveStr::Ascii("and"),
        dictgen::InsensitiveStr::Ascii("andt"),
        dictgen::InsensitiveStr::Ascii("at"),
        dictgen::InsensitiveStr::Ascii("cies"),
        dictgen::InsensitiveStr::Ascii("cy"),
        dictgen::InsensitiveStr::Ascii("d"),
        dictgen::InsensitiveStr::Ascii("ding"),
        dictgen::InsensitiveStr::Ascii("ece"),
        dictgen::InsensitiveStr::Ascii("ecies"),
        dictgen::InsensitiveStr::Ascii("ecy"),
        dictgen::InsensitiveStr::Ascii("ecys"),
        dictgen::InsensitiveStr::Ascii("edn"),
        dictgen::InsensitiveStr::Ascii("ees"),
        dictgen::InsensitiveStr::Ascii("eing"),
        dictgen::InsensitiveStr::Ascii("enceis"),
        dictgen::InsensitiveStr::Ascii("encey"),
        dictgen::InsensitiveStr::Ascii("encias"),
        dictgen::InsensitiveStr::Ascii("encie"),
        dictgen::InsensitiveStr::Ascii("encied"),
        dictgen::InsensitiveStr::Ascii("enciens"),
        dictgen::InsensitiveStr::Ascii("encis"),
        dictgen::InsensitiveStr::Ascii("encys"),
        dictgen::InsensitiveStr::Ascii("end"),
        dictgen::InsensitiveStr::Ascii("endencies"),
        dictgen::InsensitiveStr::Ascii("endency"),
        dictgen::InsensitiveStr::Ascii("endent"),
        dictgen::InsensitiveStr::Ascii("ends"),
        dictgen::InsensitiveStr::Ascii("ened"),
        dictgen::InsensitiveStr::Ascii("enices"),
        dictgen::InsensitiveStr::Ascii("enies"),
        dictgen::InsensitiveStr::Ascii("ening"),
        dictgen::InsensitiveStr::Ascii("ensies"),
        dictgen::InsensitiveStr::Ascii("enta"),
        dictgen::InsensitiveStr::Ascii("ente"),
        dictgen::InsensitiveStr::Ascii("eny"),
        dictgen::InsensitiveStr::Ascii("et"),
        dictgen::InsensitiveStr::Ascii("ices"),
        dictgen::InsensitiveStr::Ascii("icy"),
        dictgen::InsensitiveStr::Ascii("ig"),
        dictgen::InsensitiveStr::Ascii("ign"),
        dictgen::InsensitiveStr::Ascii("ncies"),
        dictgen::InsensitiveStr::Ascii("ncy"),
        dictgen::InsensitiveStr::Ascii("necy"),
    ],
    values: &[
        &["dependency"],
        &["dependencies"],
        &["dependency"],
        &["dependencies"],
        &["dependant"],
        &["dependant"],
        &["dependant"],
        &["dependencies"],
        &["dependency"],
        &["depended"],
        &["depending"],
        &["dependence"],
        &["dependencies"],
        &["dependency"],
        &["dependencies"],
        &["dependent"],
        &["dependencies"],
        &["depending"],
        &["dependencies"],
        &["dependency"],
        &["dependencies"],
        &["dependence", "dependency"],
        &["dependency"],
        &["dependencies"],
        &["dependencies"],
        &["dependencies"],
        &["dependent", "depended"],
        &["dependencies"],
        &["dependency"],
        &["dependent"],
        &["depended"],
        &["depended"],
        &["dependencies"],
        &["dependencies"],
        &["depending"],
        &["dependencies"],
        &["dependent"],
        &["dependence"],
        &["dependency"],
        &["dependent"],
        &["dependencies"],
        &["dependency"],
        &["depending"],
        &["depending"],
        &["dependencies"],
        &["dependency"],
        &["dependency"],
    ],
    range: 1..=9,
};

static WORD_DEPENC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DEPENC_CHILDREN),
    value: None,
};

pub static WORD_DEPENC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("encies"),
        dictgen::InsensitiveStr::Ascii("ency"),
        dictgen::InsensitiveStr::Ascii("endencies"),
        dictgen::InsensitiveStr::Ascii("endency"),
        dictgen::InsensitiveStr::Ascii("endencys"),
        dictgen::InsensitiveStr::Ascii("ent"),
        dictgen::InsensitiveStr::Ascii("ies"),
        dictgen::InsensitiveStr::Ascii("y"),
    ],
    values: &[
        &["dependencies"],
        &["dependency"],
        &["dependencies"],
        &["dependency"],
        &["dependencies"],
        &["dependent"],
        &["dependencies"],
        &["dependency"],
    ],
    range: 1..=9,
};

static WORD_DEPENA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DEPENA_CHILDREN),
    value: None,
};

pub static WORD_DEPENA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ncy")],
    values: &[&["dependency"]],
    range: 3..=3,
};

static WORD_DEPEL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DEPEL_CHILDREN),
    value: None,
};

pub static WORD_DEPEL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ted")],
    values: &[&["depleted"]],
    range: 3..=3,
};

static WORD_DEPED_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DEPED_CHILDREN),
    value: None,
};

pub static WORD_DEPED_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("encies"),
        dictgen::InsensitiveStr::Ascii("ency"),
        dictgen::InsensitiveStr::Ascii("encys"),
        dictgen::InsensitiveStr::Ascii("ent"),
        dictgen::InsensitiveStr::Ascii("ing"),
    ],
    values: &[
        &["dependencies"],
        &["dependency"],
        &["dependencies"],
        &["dependent"],
        &["depending"],
    ],
    range: 3..=6,
};

static WORD_DEPEC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DEPEC_CHILDREN),
    value: None,
};

pub static WORD_DEPEC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ated"),
        dictgen::InsensitiveStr::Ascii("reated"),
        dictgen::InsensitiveStr::Ascii("tion"),
    ],
    values: &[&["deprecated"], &["deprecated"], &["deception"]],
    range: 4..=6,
};

static WORD_DEPD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DEPD_CHILDREN),
    value: None,
};

pub static WORD_DEPD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("en"),
        dictgen::InsensitiveStr::Ascii("ence"),
        dictgen::InsensitiveStr::Ascii("encencies"),
        dictgen::InsensitiveStr::Ascii("encente"),
        dictgen::InsensitiveStr::Ascii("encentes"),
        dictgen::InsensitiveStr::Ascii("ences"),
        dictgen::InsensitiveStr::Ascii("encies"),
        dictgen::InsensitiveStr::Ascii("ency"),
        dictgen::InsensitiveStr::Ascii("end"),
        dictgen::InsensitiveStr::Ascii("endancies"),
        dictgen::InsensitiveStr::Ascii("endancy"),
        dictgen::InsensitiveStr::Ascii("endant"),
        dictgen::InsensitiveStr::Ascii("endants"),
        dictgen::InsensitiveStr::Ascii("ended"),
        dictgen::InsensitiveStr::Ascii("endence"),
        dictgen::InsensitiveStr::Ascii("endences"),
        dictgen::InsensitiveStr::Ascii("endencies"),
        dictgen::InsensitiveStr::Ascii("endency"),
        dictgen::InsensitiveStr::Ascii("endent"),
        dictgen::InsensitiveStr::Ascii("endents"),
        dictgen::InsensitiveStr::Ascii("endet"),
        dictgen::InsensitiveStr::Ascii("endets"),
        dictgen::InsensitiveStr::Ascii("ending"),
        dictgen::InsensitiveStr::Ascii("ends"),
        dictgen::InsensitiveStr::Ascii("enence"),
        dictgen::InsensitiveStr::Ascii("enences"),
        dictgen::InsensitiveStr::Ascii("enencies"),
        dictgen::InsensitiveStr::Ascii("enency"),
        dictgen::InsensitiveStr::Ascii("enent"),
        dictgen::InsensitiveStr::Ascii("enents"),
        dictgen::InsensitiveStr::Ascii("ening"),
        dictgen::InsensitiveStr::Ascii("enncies"),
        dictgen::InsensitiveStr::Ascii("enncy"),
        dictgen::InsensitiveStr::Ascii("ens"),
        dictgen::InsensitiveStr::Ascii("ent"),
        dictgen::InsensitiveStr::Ascii("ents"),
    ],
    values: &[
        &["depend"],
        &["dependence"],
        &["dependencies"],
        &["dependence"],
        &["dependences"],
        &["dependences"],
        &["dependencies"],
        &["dependency"],
        &["depend"],
        &["dependencies"],
        &["dependency"],
        &["dependant"],
        &["dependants"],
        &["depended"],
        &["dependence"],
        &["dependences"],
        &["dependencies"],
        &["dependency"],
        &["dependent"],
        &["dependents"],
        &["dependent"],
        &["dependents"],
        &["depending"],
        &["depends"],
        &["dependence"],
        &["dependences"],
        &["dependencies"],
        &["dependency"],
        &["dependent"],
        &["dependents"],
        &["depending"],
        &["dependencies"],
        &["dependency"],
        &["depends"],
        &["dependent"],
        &["dependents"],
    ],
    range: 2..=9,
};

static WORD_DEPC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DEPC_CHILDREN),
    value: None,
};

pub static WORD_DEPC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ited"),
        dictgen::InsensitiveStr::Ascii("iting"),
        dictgen::InsensitiveStr::Ascii("ition"),
        dictgen::InsensitiveStr::Ascii("itions"),
        dictgen::InsensitiveStr::Ascii("its"),
        dictgen::InsensitiveStr::Ascii("recated"),
    ],
    values: &[
        &["depicted"],
        &["depicting"],
        &["depiction"],
        &["depictions"],
        &["depicts"],
        &["deprecated"],
    ],
    range: 3..=7,
};

static WORD_DEPA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DEPA_CHILDREN),
    value: None,
};

pub static WORD_DEPA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ndance"),
        dictgen::InsensitiveStr::Ascii("ndancies"),
        dictgen::InsensitiveStr::Ascii("ndancy"),
        dictgen::InsensitiveStr::Ascii("ndent"),
        dictgen::InsensitiveStr::Ascii("rment"),
        dictgen::InsensitiveStr::Ascii("rmental"),
        dictgen::InsensitiveStr::Ascii("rments"),
        dictgen::InsensitiveStr::Ascii("rter"),
        dictgen::InsensitiveStr::Ascii("rtmens"),
        dictgen::InsensitiveStr::Ascii("rtmet"),
        dictgen::InsensitiveStr::Ascii("rtmnet"),
        dictgen::InsensitiveStr::Ascii("rtue"),
    ],
    values: &[
        &["dependance"],
        &["dependencies"],
        &["dependency"],
        &["dependent"],
        &["department"],
        &["departmental"],
        &["departments"],
        &["departure"],
        &["departments"],
        &["departments"],
        &["departments"],
        &["departure"],
    ],
    range: 4..=8,
};

static WORD_DEO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DEO_CHILDREN),
    value: None,
};

pub static WORD_DEO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cde"),
        dictgen::InsensitiveStr::Ascii("cded"),
        dictgen::InsensitiveStr::Ascii("cder"),
        dictgen::InsensitiveStr::Ascii("cders"),
        dictgen::InsensitiveStr::Ascii("cdes"),
        dictgen::InsensitiveStr::Ascii("cding"),
        dictgen::InsensitiveStr::Ascii("cdings"),
        dictgen::InsensitiveStr::Ascii("crations"),
        dictgen::InsensitiveStr::Ascii("crative"),
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("mcracies"),
        dictgen::InsensitiveStr::Ascii("mcrat"),
        dictgen::InsensitiveStr::Ascii("mcratic"),
        dictgen::InsensitiveStr::Ascii("mcrats"),
        dictgen::InsensitiveStr::Ascii("mgraphics"),
        dictgen::InsensitiveStr::Ascii("mnstration"),
        dictgen::InsensitiveStr::Ascii("mpression"),
        dictgen::InsensitiveStr::Ascii("psited"),
        dictgen::InsensitiveStr::Ascii("vtion"),
    ],
    values: &[
        &["decode"],
        &["decoded"],
        &["decoder"],
        &["decoders"],
        &["decodes"],
        &["decoding"],
        &["decodings"],
        &["decorations"],
        &["decorative"],
        &["does"],
        &["democracies"],
        &["democrat"],
        &["democratic"],
        &["democrats"],
        &["demographics"],
        &["demonstrations"],
        &["decompression"],
        &["deposited"],
        &["devotion"],
    ],
    range: 2..=10,
};

static WORD_DEN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DEN_CHILDREN),
    value: None,
};

pub static WORD_DEN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("egerate"),
        dictgen::InsensitiveStr::Ascii("egrating"),
        dictgen::InsensitiveStr::Ascii("eirs"),
        dictgen::InsensitiveStr::Ascii("isty"),
        dictgen::InsensitiveStr::Ascii("omal"),
        dictgen::InsensitiveStr::Ascii("omals"),
        dictgen::InsensitiveStr::Ascii("omenation"),
        dictgen::InsensitiveStr::Ascii("omenations"),
        dictgen::InsensitiveStr::Ascii("omenator"),
        dictgen::InsensitiveStr::Ascii("ominacion"),
        dictgen::InsensitiveStr::Ascii("ominador"),
        dictgen::InsensitiveStr::Ascii("ominar"),
        dictgen::InsensitiveStr::Ascii("ominaron"),
        dictgen::InsensitiveStr::Ascii("ominater"),
        dictgen::InsensitiveStr::Ascii("ominationals"),
        dictgen::InsensitiveStr::Ascii("ominatior"),
        dictgen::InsensitiveStr::Ascii("ominato"),
        dictgen::InsensitiveStr::Ascii("ominaton"),
        dictgen::InsensitiveStr::Ascii("ominatons"),
        dictgen::InsensitiveStr::Ascii("omintor"),
        dictgen::InsensitiveStr::Ascii("omitator"),
        dictgen::InsensitiveStr::Ascii("omitators"),
        dictgen::InsensitiveStr::Ascii("omonation"),
        dictgen::InsensitiveStr::Ascii("omonations"),
        dictgen::InsensitiveStr::Ascii("omonator"),
        dictgen::InsensitiveStr::Ascii("onimator"),
        dictgen::InsensitiveStr::Ascii("seley"),
        dictgen::InsensitiveStr::Ascii("sitity"),
        dictgen::InsensitiveStr::Ascii("sitiy"),
        dictgen::InsensitiveStr::Ascii("sley"),
        dictgen::InsensitiveStr::Ascii("sly"),
        dictgen::InsensitiveStr::Ascii("stiy"),
        dictgen::InsensitiveStr::Ascii("tified"),
        dictgen::InsensitiveStr::Ascii("tifier"),
        dictgen::InsensitiveStr::Ascii("tifiers"),
        dictgen::InsensitiveStr::Ascii("tifies"),
        dictgen::InsensitiveStr::Ascii("tifying"),
        dictgen::InsensitiveStr::Ascii("tistas"),
        dictgen::InsensitiveStr::Ascii("tistes"),
        dictgen::InsensitiveStr::Ascii("yed"),
    ],
    values: &[
        &["degenerate"],
        &["denigrating"],
        &["deniers"],
        &["density"],
        &["denormal"],
        &["denormals"],
        &["denomination"],
        &["denominations"],
        &["denominator"],
        &["denomination"],
        &["denominator"],
        &["denominator"],
        &["denominator"],
        &["denominator"],
        &["denominations"],
        &["denominator"],
        &["denomination"],
        &["denomination"],
        &["denominations"],
        &["denominator"],
        &["denominator"],
        &["denominators"],
        &["denomination"],
        &["denominations"],
        &["denominator"],
        &["denominator"],
        &["densely"],
        &["density"],
        &["density"],
        &["densely"],
        &["densely"],
        &["density"],
        &["identified"],
        &["identifier"],
        &["identifiers"],
        &["identifies"],
        &["identifying"],
        &["dentists"],
        &["dentists"],
        &["denied"],
    ],
    range: 3..=12,
};

static WORD_DEM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_DEM_CHILDREN),
    value: None,
};

static WORD_DEM_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_DEMA_NODE),
    None,
    Some(&WORD_DEMC_NODE),
    None,
    Some(&WORD_DEME_NODE),
    None,
    None,
    None,
    Some(&WORD_DEMI_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_DEMO_NODE),
    None,
    None,
    None,
    Some(&WORD_DEMS_NODE),
    None,
    Some(&WORD_DEMU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_DEMU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DEMU_CHILDREN),
    value: None,
};

pub static WORD_DEMU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("dulator")],
    values: &[&["demodulator"]],
    range: 7..=7,
};

static WORD_DEMS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DEMS_CHILDREN),
    value: None,
};

pub static WORD_DEMS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ond")],
    values: &[&["desmond"]],
    range: 3..=3,
};

static WORD_DEMO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_DEMO_CHILDREN),
    value: None,
};

static WORD_DEMO_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    Some(&WORD_DEMOC_NODE),
    Some(&WORD_DEMOD_NODE),
    None,
    None,
    Some(&WORD_DEMOG_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_DEMOL_NODE),
    None,
    Some(&WORD_DEMON_NODE),
    None,
    None,
    None,
    Some(&WORD_DEMOR_NODE),
    Some(&WORD_DEMOS_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_DEMOS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DEMOS_CHILDREN),
    value: None,
};

pub static WORD_DEMOS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ntrably"),
        dictgen::InsensitiveStr::Ascii("ntrate"),
        dictgen::InsensitiveStr::Ascii("ntrated"),
        dictgen::InsensitiveStr::Ascii("ntrates"),
        dictgen::InsensitiveStr::Ascii("ntrating"),
        dictgen::InsensitiveStr::Ascii("ntration"),
        dictgen::InsensitiveStr::Ascii("ntrations"),
        dictgen::InsensitiveStr::Ascii("trate"),
        dictgen::InsensitiveStr::Ascii("trated"),
        dictgen::InsensitiveStr::Ascii("trates"),
        dictgen::InsensitiveStr::Ascii("trating"),
        dictgen::InsensitiveStr::Ascii("tration"),
    ],
    values: &[
        &["demonstrably"],
        &["demonstrate"],
        &["demonstrated"],
        &["demonstrates"],
        &["demonstrating"],
        &["demonstrations"],
        &["demonstrations"],
        &["demonstrate"],
        &["demonstrated"],
        &["demonstrates"],
        &["demonstrating"],
        &["demonstration"],
    ],
    range: 5..=9,
};

static WORD_DEMOR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DEMOR_CHILDREN),
    value: None,
};

pub static WORD_DEMOR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("cracy")],
    values: &[&["democracy"]],
    range: 5..=5,
};

static WORD_DEMON_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DEMON_CHILDREN),
    value: None,
};

pub static WORD_DEMON_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ination"),
        dictgen::InsensitiveStr::Ascii("inations"),
        dictgen::InsensitiveStr::Ascii("inator"),
        dictgen::InsensitiveStr::Ascii("inators"),
        dictgen::InsensitiveStr::Ascii("ished"),
        dictgen::InsensitiveStr::Ascii("starte"),
        dictgen::InsensitiveStr::Ascii("started"),
        dictgen::InsensitiveStr::Ascii("startes"),
        dictgen::InsensitiveStr::Ascii("starting"),
        dictgen::InsensitiveStr::Ascii("startion"),
        dictgen::InsensitiveStr::Ascii("startions"),
        dictgen::InsensitiveStr::Ascii("state"),
        dictgen::InsensitiveStr::Ascii("states"),
        dictgen::InsensitiveStr::Ascii("strabil"),
        dictgen::InsensitiveStr::Ascii("straby"),
        dictgen::InsensitiveStr::Ascii("straion"),
        dictgen::InsensitiveStr::Ascii("straiton"),
        dictgen::InsensitiveStr::Ascii("straits"),
        dictgen::InsensitiveStr::Ascii("strant"),
        dictgen::InsensitiveStr::Ascii("strants"),
        dictgen::InsensitiveStr::Ascii("stras"),
        dictgen::InsensitiveStr::Ascii("strat"),
        dictgen::InsensitiveStr::Ascii("stratable"),
        dictgen::InsensitiveStr::Ascii("stratably"),
        dictgen::InsensitiveStr::Ascii("stratbly"),
        dictgen::InsensitiveStr::Ascii("stratie"),
        dictgen::InsensitiveStr::Ascii("straties"),
        dictgen::InsensitiveStr::Ascii("stratin"),
        dictgen::InsensitiveStr::Ascii("strationens"),
        dictgen::InsensitiveStr::Ascii("strativno"),
        dictgen::InsensitiveStr::Ascii("strativo"),
        dictgen::InsensitiveStr::Ascii("strativos"),
        dictgen::InsensitiveStr::Ascii("strats"),
        dictgen::InsensitiveStr::Ascii("stre"),
        dictgen::InsensitiveStr::Ascii("strerat"),
    ],
    values: &[
        &["denominations"],
        &["denominations"],
        &["denominator"],
        &["denominators"],
        &["demolished"],
        &["demonstrate"],
        &["demonstrated"],
        &["demonstrates"],
        &["demonstrating"],
        &["demonstration"],
        &["demonstrations"],
        &["demonstrate"],
        &["demonstrates"],
        &["demonstrably"],
        &["demonstrably"],
        &["demonstration"],
        &["demonstrations"],
        &["demonstrates"],
        &["demonstrate"],
        &["demonstrates"],
        &["demonstrates"],
        &["demonstrate"],
        &["demonstrable"],
        &["demonstrably"],
        &["demonstrably"],
        &["demonstrate"],
        &["demonstrate"],
        &["demonstration"],
        &["demonstrations"],
        &["demonstrations"],
        &["demonstration"],
        &["demonstrations"],
        &["demonstrates"],
        &["demonstrate"],
        &["demonstrate"],
    ],
    range: 4..=11,
};

static WORD_DEMOL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DEMOL_CHILDREN),
    value: None,
};

pub static WORD_DEMOL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ation"),
        dictgen::InsensitiveStr::Ascii("icion"),
        dictgen::InsensitiveStr::Ascii("ishon"),
        dictgen::InsensitiveStr::Ascii("ision"),
        dictgen::InsensitiveStr::Ascii("itian"),
        dictgen::InsensitiveStr::Ascii("iting"),
        dictgen::InsensitiveStr::Ascii("ito"),
        dictgen::InsensitiveStr::Ascii("oshed"),
        dictgen::InsensitiveStr::Ascii("ution"),
    ],
    values: &[
        &["demolition"],
        &["demolition"],
        &["demolition"],
        &["demolition"],
        &["demolition"],
        &["demolition"],
        &["demolition"],
        &["demolished"],
        &["demolition"],
    ],
    range: 3..=5,
};

static WORD_DEMOG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DEMOG_CHILDREN),
    value: Some(&["demo"]),
};

pub static WORD_DEMOG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("rahic"),
        dictgen::InsensitiveStr::Ascii("rahpic"),
        dictgen::InsensitiveStr::Ascii("rahpics"),
        dictgen::InsensitiveStr::Ascii("raphical"),
        dictgen::InsensitiveStr::Ascii("raphis"),
        dictgen::InsensitiveStr::Ascii("raphs"),
        dictgen::InsensitiveStr::Ascii("rapic"),
        dictgen::InsensitiveStr::Ascii("rapics"),
        dictgen::InsensitiveStr::Ascii("rpahic"),
        dictgen::InsensitiveStr::Ascii("rpahics"),
    ],
    values: &[
        &["demographic"],
        &["demographic"],
        &["demographics"],
        &["demographic"],
        &["demographics"],
        &["demographics"],
        &["demographic"],
        &["demographics"],
        &["demographic"],
        &["demographics"],
    ],
    range: 5..=8,
};

static WORD_DEMOD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DEMOD_CHILDREN),
    value: None,
};

pub static WORD_DEMOD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ualtor")],
    values: &[&["demodulator"]],
    range: 6..=6,
};

static WORD_DEMOC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DEMOC_CHILDREN),
    value: None,
};

pub static WORD_DEMOC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("arcies"),
        dictgen::InsensitiveStr::Ascii("arcy"),
        dictgen::InsensitiveStr::Ascii("racis"),
        dictgen::InsensitiveStr::Ascii("racize"),
        dictgen::InsensitiveStr::Ascii("racries"),
        dictgen::InsensitiveStr::Ascii("ract"),
        dictgen::InsensitiveStr::Ascii("ractic"),
        dictgen::InsensitiveStr::Ascii("racts"),
        dictgen::InsensitiveStr::Ascii("raphic"),
        dictgen::InsensitiveStr::Ascii("raphics"),
        dictgen::InsensitiveStr::Ascii("rasies"),
        dictgen::InsensitiveStr::Ascii("ratas"),
        dictgen::InsensitiveStr::Ascii("rates"),
        dictgen::InsensitiveStr::Ascii("raticaly"),
        dictgen::InsensitiveStr::Ascii("raticlly"),
        dictgen::InsensitiveStr::Ascii("ratisch"),
        dictgen::InsensitiveStr::Ascii("ray"),
        dictgen::InsensitiveStr::Ascii("razies"),
        dictgen::InsensitiveStr::Ascii("rocies"),
    ],
    values: &[
        &["democracies"],
        &["democracy"],
        &["democracies"],
        &["democracies"],
        &["democracies"],
        &["democrat"],
        &["democratic"],
        &["democrat"],
        &["demographic"],
        &["demographics"],
        &["democracies"],
        &["democrats"],
        &["democrats"],
        &["democratically"],
        &["democratically"],
        &["democratic"],
        &["democracy"],
        &["democracies"],
        &["democracies"],
    ],
    range: 3..=8,
};

static WORD_DEMI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DEMI_CHILDREN),
    value: None,
};

pub static WORD_DEMI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("nsion"),
        dictgen::InsensitiveStr::Ascii("nsional"),
        dictgen::InsensitiveStr::Ascii("nsions"),
        dictgen::InsensitiveStr::Ascii("nstrations"),
    ],
    values: &[
        &["dimension"],
        &["dimensional"],
        &["dimensions"],
        &["demonstrations"],
    ],
    range: 5..=10,
};

static WORD_DEME_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DEME_CHILDREN),
    value: None,
};

pub static WORD_DEME_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("naor"),
        dictgen::InsensitiveStr::Ascii("nor"),
        dictgen::InsensitiveStr::Ascii("nsion"),
        dictgen::InsensitiveStr::Ascii("nsional"),
        dictgen::InsensitiveStr::Ascii("nsions"),
        dictgen::InsensitiveStr::Ascii("nstration"),
        dictgen::InsensitiveStr::Ascii("nstrations"),
        dictgen::InsensitiveStr::Ascii("nta"),
        dictgen::InsensitiveStr::Ascii("ntieva"),
        dictgen::InsensitiveStr::Ascii("sticated"),
    ],
    values: &[
        &["demeanor"],
        &["demeanor"],
        &["dimension"],
        &["dimensional"],
        &["dimensions"],
        &["demonstration"],
        &["demonstrations"],
        &["dementia"],
        &["dementia"],
        &["domesticated"],
    ],
    range: 3..=10,
};

static WORD_DEMC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DEMC_CHILDREN),
    value: None,
};

pub static WORD_DEMC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("orats")],
    values: &[&["democrats"]],
    range: 5..=5,
};

static WORD_DEMA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DEMA_CHILDREN),
    value: None,
};

pub static WORD_DEMA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ind"),
        dictgen::InsensitiveStr::Ascii("ndas"),
        dictgen::InsensitiveStr::Ascii("ndes"),
        dictgen::InsensitiveStr::Ascii("ned"),
    ],
    values: &[
        &["demand"],
        &["demands"],
        &["demands"],
        &["demand", "demeaned"],
    ],
    range: 3..=4,
};

static WORD_DEL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_DEL_CHILDREN),
    value: None,
};

static WORD_DEL_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_DELA_NODE),
    None,
    Some(&WORD_DELC_NODE),
    None,
    Some(&WORD_DELE_NODE),
    Some(&WORD_DELF_NODE),
    Some(&WORD_DELG_NODE),
    None,
    Some(&WORD_DELI_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_DELP_NODE),
    None,
    None,
    None,
    Some(&WORD_DELT_NODE),
    Some(&WORD_DELU_NODE),
    Some(&WORD_DELV_NODE),
    None,
    None,
    Some(&WORD_DELY_NODE),
    None,
];

static WORD_DELY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DELY_CHILDREN),
    value: None,
};

pub static WORD_DELY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("aing")],
    values: &[&["delaying"]],
    range: 4..=4,
};

static WORD_DELV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DELV_CHILDREN),
    value: None,
};

pub static WORD_DELV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ery")],
    values: &[&["delivery"]],
    range: 3..=3,
};

static WORD_DELU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DELU_CHILDREN),
    value: None,
};

pub static WORD_DELU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("sionally"),
        dictgen::InsensitiveStr::Ascii("sionnal"),
        dictgen::InsensitiveStr::Ascii("tional"),
    ],
    values: &[&["delusively"], &["delusional"], &["delusional"]],
    range: 6..=8,
};

static WORD_DELT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DELT_CHILDREN),
    value: Some(&["dealt"]),
};

pub static WORD_DELT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("ion"),
    ],
    values: &[
        &["delete"],
        &["deleted"],
        &["deletes"],
        &["deleting"],
        &["deletion"],
    ],
    range: 1..=3,
};

static WORD_DELP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DELP_CHILDREN),
    value: None,
};

pub static WORD_DELP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eted"),
        dictgen::InsensitiveStr::Ascii("orable"),
        dictgen::InsensitiveStr::Ascii("oy"),
        dictgen::InsensitiveStr::Ascii("oyed"),
        dictgen::InsensitiveStr::Ascii("oying"),
        dictgen::InsensitiveStr::Ascii("oyment"),
        dictgen::InsensitiveStr::Ascii("oys"),
    ],
    values: &[
        &["depleted"],
        &["deplorable"],
        &["deploy"],
        &["deployed"],
        &["deploying"],
        &["deployment"],
        &["deploys"],
    ],
    range: 2..=6,
};

static WORD_DELI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_DELI_CHILDREN),
    value: None,
};

static WORD_DELI_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    Some(&WORD_DELIB_NODE),
    None,
    None,
    Some(&WORD_DELIE_NODE),
    None,
    Some(&WORD_DELIG_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_DELIM_NODE),
    Some(&WORD_DELIN_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_DELIV_NODE),
    None,
    None,
    None,
    None,
];

static WORD_DELIV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DELIV_CHILDREN),
    value: None,
};

pub static WORD_DELIV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ared"),
        dictgen::InsensitiveStr::Ascii("ative"),
        dictgen::InsensitiveStr::Ascii("atives"),
        dictgen::InsensitiveStr::Ascii("erate"),
        dictgen::InsensitiveStr::Ascii("erately"),
        dictgen::InsensitiveStr::Ascii("ere"),
        dictgen::InsensitiveStr::Ascii("erees"),
        dictgen::InsensitiveStr::Ascii("eres"),
        dictgen::InsensitiveStr::Ascii("ermode"),
        dictgen::InsensitiveStr::Ascii("erying"),
        dictgen::InsensitiveStr::Ascii("erys"),
        dictgen::InsensitiveStr::Ascii("iered"),
        dictgen::InsensitiveStr::Ascii("iring"),
    ],
    values: &[
        &["delivered"],
        &["derivative"],
        &["derivatives"],
        &["deliberate"],
        &["deliberately"],
        &["deliveries"],
        &["deliveries"],
        &["delivers"],
        &["deliverymode"],
        &["delivering"],
        &["delivers", "deliveries"],
        &["delivered"],
        &["delivering"],
    ],
    range: 3..=7,
};

static WORD_DELIN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DELIN_CHILDREN),
    value: None,
};

pub static WORD_DELIN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("k")],
    values: &[&["unlink"]],
    range: 1..=1,
};

static WORD_DELIM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DELIM_CHILDREN),
    value: None,
};

pub static WORD_DELIM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eted"),
        dictgen::InsensitiveStr::Ascii("eter"),
        dictgen::InsensitiveStr::Ascii("eters"),
        dictgen::InsensitiveStr::Ascii("iited"),
        dictgen::InsensitiveStr::Ascii("iiter"),
        dictgen::InsensitiveStr::Ascii("iiters"),
        dictgen::InsensitiveStr::Ascii("inated"),
        dictgen::InsensitiveStr::Ascii("itiaion"),
        dictgen::InsensitiveStr::Ascii("itiaions"),
        dictgen::InsensitiveStr::Ascii("itiation"),
        dictgen::InsensitiveStr::Ascii("itiations"),
        dictgen::InsensitiveStr::Ascii("itied"),
        dictgen::InsensitiveStr::Ascii("itier"),
        dictgen::InsensitiveStr::Ascii("itiers"),
        dictgen::InsensitiveStr::Ascii("itiing"),
        dictgen::InsensitiveStr::Ascii("itimg"),
        dictgen::InsensitiveStr::Ascii("ition"),
        dictgen::InsensitiveStr::Ascii("itions"),
        dictgen::InsensitiveStr::Ascii("itis"),
        dictgen::InsensitiveStr::Ascii("ititation"),
        dictgen::InsensitiveStr::Ascii("ititations"),
        dictgen::InsensitiveStr::Ascii("itited"),
        dictgen::InsensitiveStr::Ascii("ititer"),
        dictgen::InsensitiveStr::Ascii("ititers"),
        dictgen::InsensitiveStr::Ascii("ititing"),
        dictgen::InsensitiveStr::Ascii("itor"),
        dictgen::InsensitiveStr::Ascii("itors"),
        dictgen::InsensitiveStr::Ascii("itted"),
        dictgen::InsensitiveStr::Ascii("ma"),
        dictgen::InsensitiveStr::Ascii("ted"),
        dictgen::InsensitiveStr::Ascii("ter"),
        dictgen::InsensitiveStr::Ascii("ters"),
    ],
    values: &[
        &["delimited"],
        &["delimiter"],
        &["delimiters"],
        &["delimited"],
        &["delimiter"],
        &["delimiters"],
        &["delimited"],
        &["delimitation"],
        &["delimitations"],
        &["delimitation"],
        &["delimitations"],
        &["delimited"],
        &["delimiter"],
        &["delimiters"],
        &["delimiting"],
        &["delimiting"],
        &["delimitation"],
        &["delimitations"],
        &["delimits"],
        &["delimitation"],
        &["delimitations"],
        &["delimited"],
        &["delimiter"],
        &["delimiters"],
        &["delimiting"],
        &["delimiter"],
        &["delimiters"],
        &["delimited"],
        &["dilemma"],
        &["delimited"],
        &["delimiter"],
        &["delimiter"],
    ],
    range: 2..=10,
};

static WORD_DELIG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DELIG_CHILDREN),
    value: None,
};

pub static WORD_DELIG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("htlful"),
        dictgen::InsensitiveStr::Ascii("thful"),
    ],
    values: &[&["delightful"], &["delightful"]],
    range: 5..=6,
};

static WORD_DELIE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DELIE_CHILDREN),
    value: None,
};

pub static WORD_DELIE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ver"),
        dictgen::InsensitiveStr::Ascii("vered"),
        dictgen::InsensitiveStr::Ascii("vering"),
        dictgen::InsensitiveStr::Ascii("vers"),
        dictgen::InsensitiveStr::Ascii("very"),
        dictgen::InsensitiveStr::Ascii("vred"),
        dictgen::InsensitiveStr::Ascii("vries"),
        dictgen::InsensitiveStr::Ascii("vry"),
    ],
    values: &[
        &["deliver"],
        &["delivered"],
        &["delivering"],
        &["delivers"],
        &["delivery"],
        &["delivered"],
        &["deliveries"],
        &["delivery"],
    ],
    range: 3..=6,
};

static WORD_DELIB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DELIB_CHILDREN),
    value: None,
};

pub static WORD_DELIB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("arate"),
        dictgen::InsensitiveStr::Ascii("aretely"),
        dictgen::InsensitiveStr::Ascii("erant"),
        dictgen::InsensitiveStr::Ascii("erante"),
        dictgen::InsensitiveStr::Ascii("eratey"),
        dictgen::InsensitiveStr::Ascii("eratley"),
        dictgen::InsensitiveStr::Ascii("eratly"),
        dictgen::InsensitiveStr::Ascii("eretly"),
        dictgen::InsensitiveStr::Ascii("erite"),
        dictgen::InsensitiveStr::Ascii("eritely"),
        dictgen::InsensitiveStr::Ascii("ery"),
        dictgen::InsensitiveStr::Ascii("irate"),
        dictgen::InsensitiveStr::Ascii("irately"),
        dictgen::InsensitiveStr::Ascii("itating"),
        dictgen::InsensitiveStr::Ascii("rate"),
        dictgen::InsensitiveStr::Ascii("rately"),
    ],
    values: &[
        &["deliberate"],
        &["deliberately"],
        &["deliberate"],
        &["deliberate"],
        &["deliberately"],
        &["deliberately"],
        &["deliberately"],
        &["deliberately"],
        &["deliberate"],
        &["deliberately"],
        &["delivery"],
        &["deliberate"],
        &["deliberately"],
        &["debilitating"],
        &["deliberate"],
        &["deliberately"],
    ],
    range: 3..=7,
};

static WORD_DELG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DELG_CHILDREN),
    value: None,
};

pub static WORD_DELG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ate"),
        dictgen::InsensitiveStr::Ascii("ated"),
        dictgen::InsensitiveStr::Ascii("ates"),
        dictgen::InsensitiveStr::Ascii("ating"),
        dictgen::InsensitiveStr::Ascii("ation"),
        dictgen::InsensitiveStr::Ascii("ations"),
        dictgen::InsensitiveStr::Ascii("ator"),
        dictgen::InsensitiveStr::Ascii("ators"),
    ],
    values: &[
        &["delegate"],
        &["delegated"],
        &["delegates"],
        &["delegating"],
        &["delegation"],
        &["delegations"],
        &["delegator"],
        &["delegators"],
    ],
    range: 3..=6,
};

static WORD_DELF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DELF_CHILDREN),
    value: None,
};

pub static WORD_DELF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ation"),
        dictgen::InsensitiveStr::Ascii("ect"),
        dictgen::InsensitiveStr::Ascii("ection"),
    ],
    values: &[&["deflation"], &["deflect"], &["deflection"]],
    range: 3..=6,
};

static WORD_DELE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DELE_CHILDREN),
    value: None,
};

pub static WORD_DELE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("arship"),
        dictgen::InsensitiveStr::Ascii("arships"),
        dictgen::InsensitiveStr::Ascii("ction"),
        dictgen::InsensitiveStr::Ascii("ctions"),
        dictgen::InsensitiveStr::Ascii("gatie"),
        dictgen::InsensitiveStr::Ascii("gaties"),
        dictgen::InsensitiveStr::Ascii("gative"),
        dictgen::InsensitiveStr::Ascii("le"),
        dictgen::InsensitiveStr::Ascii("lete"),
        dictgen::InsensitiveStr::Ascii("leted"),
        dictgen::InsensitiveStr::Ascii("letes"),
        dictgen::InsensitiveStr::Ascii("leting"),
        dictgen::InsensitiveStr::Ascii("lte"),
        dictgen::InsensitiveStr::Ascii("meter"),
        dictgen::InsensitiveStr::Ascii("miter"),
        dictgen::InsensitiveStr::Ascii("pted"),
        dictgen::InsensitiveStr::Ascii("rious"),
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("td"),
        dictgen::InsensitiveStr::Ascii("teable"),
        dictgen::InsensitiveStr::Ascii("teed"),
        dictgen::InsensitiveStr::Ascii("teing"),
        dictgen::InsensitiveStr::Ascii("teion"),
        dictgen::InsensitiveStr::Ascii("teting"),
        dictgen::InsensitiveStr::Ascii("tiong"),
        dictgen::InsensitiveStr::Ascii("ts"),
        dictgen::InsensitiveStr::Ascii("vopment"),
        dictgen::InsensitiveStr::Ascii("vopp"),
    ],
    values: &[
        &["dealership"],
        &["dealerships"],
        &["detection", "deletion", "selection"],
        &["detections", "deletions", "selections"],
        &["delegate"],
        &["delegate"],
        &["delegate"],
        &["delete"],
        &["delete"],
        &["deleted"],
        &["deletes"],
        &["deleting"],
        &["delete"],
        &["delimiter"],
        &["delimiter"],
        &["depleted"],
        &["delirious"],
        &["delete"],
        &["deleted"],
        &["deletable"],
        &["deleted"],
        &["deleting"],
        &["deletion"],
        &["deleting"],
        &["deletion"],
        &["deletes"],
        &["development"],
        &["develop"],
    ],
    range: 1..=7,
};

static WORD_DELC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DELC_CHILDREN),
    value: None,
};

pub static WORD_DELC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aration"),
        dictgen::InsensitiveStr::Ascii("arations"),
        dictgen::InsensitiveStr::Ascii("are"),
        dictgen::InsensitiveStr::Ascii("ared"),
        dictgen::InsensitiveStr::Ascii("ares"),
        dictgen::InsensitiveStr::Ascii("aring"),
        dictgen::InsensitiveStr::Ascii("ining"),
        dictgen::InsensitiveStr::Ascii("laration"),
    ],
    values: &[
        &["declaration"],
        &["declarations"],
        &["declare"],
        &["declared"],
        &["declares"],
        &["declaring"],
        &["declining"],
        &["declaration"],
    ],
    range: 3..=8,
};

static WORD_DELA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DELA_CHILDREN),
    value: None,
};

pub static WORD_DELA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ership"),
        dictgen::InsensitiveStr::Ascii("erships"),
        dictgen::InsensitiveStr::Ascii("gate"),
        dictgen::InsensitiveStr::Ascii("gates"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("loc"),
        dictgen::InsensitiveStr::Ascii("lyed"),
        dictgen::InsensitiveStr::Ascii("pidated"),
        dictgen::InsensitiveStr::Ascii("raction"),
        dictgen::InsensitiveStr::Ascii("ractions"),
        dictgen::InsensitiveStr::Ascii("rations"),
        dictgen::InsensitiveStr::Ascii("re"),
        dictgen::InsensitiveStr::Ascii("red"),
        dictgen::InsensitiveStr::Ascii("res"),
        dictgen::InsensitiveStr::Ascii("ring"),
        dictgen::InsensitiveStr::Ascii("te"),
        dictgen::InsensitiveStr::Ascii("yis"),
    ],
    values: &[
        &["dealership"],
        &["dealerships"],
        &["delegate"],
        &["delegates"],
        &["delaying"],
        &["delalloc"],
        &["delayed"],
        &["dilapidated"],
        &["declaration"],
        &["declarations"],
        &["declarations"],
        &["declare"],
        &["declared"],
        &["declares"],
        &["declaring"],
        &["delete"],
        &["delays"],
    ],
    range: 2..=8,
};

static WORD_DEK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DEK_CHILDREN),
    value: None,
};

pub static WORD_DEK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ete"),
        dictgen::InsensitiveStr::Ascii("eted"),
        dictgen::InsensitiveStr::Ascii("etes"),
        dictgen::InsensitiveStr::Ascii("eting"),
        dictgen::InsensitiveStr::Ascii("laration"),
        dictgen::InsensitiveStr::Ascii("stop"),
        dictgen::InsensitiveStr::Ascii("stops"),
        dictgen::InsensitiveStr::Ascii("top"),
        dictgen::InsensitiveStr::Ascii("tops"),
    ],
    values: &[
        &["delete"],
        &["deleted"],
        &["deletes"],
        &["deleting"],
        &["declaration"],
        &["desktop"],
        &["desktops"],
        &["desktop"],
        &["desktops"],
    ],
    range: 3..=8,
};

static WORD_DEI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DEI_CHILDREN),
    value: None,
};

pub static WORD_DEI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("fnately"),
        dictgen::InsensitiveStr::Ascii("fne"),
        dictgen::InsensitiveStr::Ascii("fned"),
        dictgen::InsensitiveStr::Ascii("fnes"),
        dictgen::InsensitiveStr::Ascii("fnetly"),
        dictgen::InsensitiveStr::Ascii("fning"),
        dictgen::InsensitiveStr::Ascii("fnitly"),
        dictgen::InsensitiveStr::Ascii("miter"),
        dictgen::InsensitiveStr::Ascii("ne"),
        dictgen::InsensitiveStr::Ascii("ned"),
        dictgen::InsensitiveStr::Ascii("ners"),
        dictgen::InsensitiveStr::Ascii("nes"),
        dictgen::InsensitiveStr::Ascii("nitailse"),
        dictgen::InsensitiveStr::Ascii("nitailze"),
        dictgen::InsensitiveStr::Ascii("nitalization"),
        dictgen::InsensitiveStr::Ascii("nitalize"),
        dictgen::InsensitiveStr::Ascii("nitalized"),
        dictgen::InsensitiveStr::Ascii("nitalizes"),
        dictgen::InsensitiveStr::Ascii("nitalizing"),
        dictgen::InsensitiveStr::Ascii("nstantating"),
        dictgen::InsensitiveStr::Ascii("ntialize"),
        dictgen::InsensitiveStr::Ascii("ntialized"),
        dictgen::InsensitiveStr::Ascii("ntializing"),
        dictgen::InsensitiveStr::Ascii("sgn"),
        dictgen::InsensitiveStr::Ascii("sgnated"),
        dictgen::InsensitiveStr::Ascii("sgned"),
        dictgen::InsensitiveStr::Ascii("sgner"),
        dictgen::InsensitiveStr::Ascii("sgners"),
        dictgen::InsensitiveStr::Ascii("sgning"),
        dictgen::InsensitiveStr::Ascii("sgns"),
        dictgen::InsensitiveStr::Ascii("vant"),
        dictgen::InsensitiveStr::Ascii("vative"),
        dictgen::InsensitiveStr::Ascii("vatives"),
        dictgen::InsensitiveStr::Ascii("vce"),
        dictgen::InsensitiveStr::Ascii("vces"),
        dictgen::InsensitiveStr::Ascii("vices"),
    ],
    values: &[
        &["definitely"],
        &["define"],
        &["defined"],
        &["defines"],
        &["definitely"],
        &["defining"],
        &["definitely"],
        &["delimiter"],
        &["define"],
        &["denied", "defined"],
        &["deniers"],
        &["defined", "defines", "denies"],
        &["deinitialise"],
        &["deinitialize"],
        &["deinitialization"],
        &["deinitialize"],
        &["deinitialized"],
        &["deinitializes"],
        &["deinitializing"],
        &["deinstantiating"],
        &["deinitialize"],
        &["deinitialized"],
        &["deinitializing"],
        &["design"],
        &["designated"],
        &["designed"],
        &["designer"],
        &["designers"],
        &["designing"],
        &["designs"],
        &["deviant"],
        &["derivative"],
        &["derivatives"],
        &["device"],
        &["devices"],
        &["devices"],
    ],
    range: 2..=12,
};

static WORD_DEH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DEH_CHILDREN),
    value: None,
};

pub static WORD_DEH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ydraded"),
        dictgen::InsensitiveStr::Ascii("yrdated"),
        dictgen::InsensitiveStr::Ascii("yrdation"),
    ],
    values: &[&["dehydrated"], &["dehydrated"], &["dehydration"]],
    range: 7..=8,
};

static WORD_DEG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DEG_CHILDREN),
    value: None,
};

pub static WORD_DEG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("arde"),
        dictgen::InsensitiveStr::Ascii("arded"),
        dictgen::InsensitiveStr::Ascii("enarate"),
        dictgen::InsensitiveStr::Ascii("enarated"),
        dictgen::InsensitiveStr::Ascii("enarates"),
        dictgen::InsensitiveStr::Ascii("enarating"),
        dictgen::InsensitiveStr::Ascii("enaration"),
        dictgen::InsensitiveStr::Ascii("enerage"),
        dictgen::InsensitiveStr::Ascii("eneraged"),
        dictgen::InsensitiveStr::Ascii("enerages"),
        dictgen::InsensitiveStr::Ascii("eneraging"),
        dictgen::InsensitiveStr::Ascii("enerare"),
        dictgen::InsensitiveStr::Ascii("enere"),
        dictgen::InsensitiveStr::Ascii("enererat"),
        dictgen::InsensitiveStr::Ascii("eneret"),
        dictgen::InsensitiveStr::Ascii("enerite"),
        dictgen::InsensitiveStr::Ascii("enracy"),
        dictgen::InsensitiveStr::Ascii("enrate"),
        dictgen::InsensitiveStr::Ascii("enrated"),
        dictgen::InsensitiveStr::Ascii("enrates"),
        dictgen::InsensitiveStr::Ascii("enratet"),
        dictgen::InsensitiveStr::Ascii("enrating"),
        dictgen::InsensitiveStr::Ascii("enration"),
        dictgen::InsensitiveStr::Ascii("erate"),
        dictgen::InsensitiveStr::Ascii("eree"),
        dictgen::InsensitiveStr::Ascii("nerate"),
        dictgen::InsensitiveStr::Ascii("nerated"),
        dictgen::InsensitiveStr::Ascii("nerates"),
        dictgen::InsensitiveStr::Ascii("oratory"),
        dictgen::InsensitiveStr::Ascii("radacion"),
        dictgen::InsensitiveStr::Ascii("radating"),
        dictgen::InsensitiveStr::Ascii("radato"),
        dictgen::InsensitiveStr::Ascii("radead"),
        dictgen::InsensitiveStr::Ascii("raderad"),
        dictgen::InsensitiveStr::Ascii("rads"),
        dictgen::InsensitiveStr::Ascii("ragation"),
        dictgen::InsensitiveStr::Ascii("raged"),
        dictgen::InsensitiveStr::Ascii("rase"),
        dictgen::InsensitiveStr::Ascii("rassie"),
        dictgen::InsensitiveStr::Ascii("rassse"),
        dictgen::InsensitiveStr::Ascii("rate"),
        dictgen::InsensitiveStr::Ascii("rated"),
        dictgen::InsensitiveStr::Ascii("ration"),
        dictgen::InsensitiveStr::Ascii("redation"),
        dictgen::InsensitiveStr::Ascii("reee"),
        dictgen::InsensitiveStr::Ascii("reeee"),
        dictgen::InsensitiveStr::Ascii("reeees"),
        dictgen::InsensitiveStr::Ascii("reees"),
        dictgen::InsensitiveStr::Ascii("res"),
        dictgen::InsensitiveStr::Ascii("ress"),
        dictgen::InsensitiveStr::Ascii("ridation"),
    ],
    values: &[
        &["degrade"],
        &["degraded"],
        &["degenerate"],
        &["degenerated"],
        &["degenerates"],
        &["degenerating"],
        &["degeneration"],
        &["degenerate"],
        &["degenerated"],
        &["degenerates"],
        &["degenerating"],
        &["degenerate"],
        &["degenerate"],
        &["degenerate"],
        &["degenerate"],
        &["degenerate"],
        &["degeneracy"],
        &["degenerate"],
        &["degenerated"],
        &["degenerates"],
        &["degenerated"],
        &["degenerating"],
        &["degeneration"],
        &["degenerate"],
        &["degree"],
        &["degenerate"],
        &["degenerated"],
        &["degenerates"],
        &["derogatory"],
        &["degradation"],
        &["degradation"],
        &["degradation"],
        &["degraded"],
        &["degraded"],
        &["degrades"],
        &["degradation"],
        &["degrade"],
        &["degrasse"],
        &["degrasse"],
        &["degrasse"],
        &["degrade"],
        &["degrade"],
        &["degradation"],
        &["degradation"],
        &["degree"],
        &["degree"],
        &["degrees"],
        &["degrees"],
        &["degrees", "digress"],
        &["degrees", "digress"],
        &["degradation"],
    ],
    range: 3..=9,
};

static WORD_DEF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_DEF_CHILDREN),
    value: None,
};

static WORD_DEF_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_DEFA_NODE),
    None,
    None,
    None,
    Some(&WORD_DEFE_NODE),
    Some(&WORD_DEFF_NODE),
    None,
    None,
    Some(&WORD_DEFI_NODE),
    None,
    None,
    Some(&WORD_DEFL_NODE),
    None,
    Some(&WORD_DEFN_NODE),
    Some(&WORD_DEFO_NODE),
    None,
    Some(&WORD_DEFQ_NODE),
    Some(&WORD_DEFR_NODE),
    None,
    None,
    Some(&WORD_DEFU_NODE),
    None,
    None,
    None,
    Some(&WORD_DEFY_NODE),
    None,
];

static WORD_DEFY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DEFY_CHILDREN),
    value: None,
};

pub static WORD_DEFY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ning")],
    values: &[&["defining"]],
    range: 4..=4,
};

static WORD_DEFU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DEFU_CHILDREN),
    value: None,
};

pub static WORD_DEFU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("alt"),
        dictgen::InsensitiveStr::Ascii("altdict"),
        dictgen::InsensitiveStr::Ascii("alts"),
        dictgen::InsensitiveStr::Ascii("lt"),
        dictgen::InsensitiveStr::Ascii("lted"),
        dictgen::InsensitiveStr::Ascii("lting"),
        dictgen::InsensitiveStr::Ascii("lts"),
    ],
    values: &[
        &["default"],
        &["defaultdict"],
        &["defaults"],
        &["default"],
        &["defaulted"],
        &["defaulting"],
        &["defaults"],
    ],
    range: 2..=7,
};

static WORD_DEFR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DEFR_CHILDREN),
    value: None,
};

pub static WORD_DEFR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("agmenation")],
    values: &[&["defragmentation"]],
    range: 10..=10,
};

static WORD_DEFQ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DEFQ_CHILDREN),
    value: None,
};

pub static WORD_DEFQ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ault")],
    values: &[&["default"]],
    range: 4..=4,
};

static WORD_DEFO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DEFO_CHILDREN),
    value: None,
};

pub static WORD_DEFO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("re")],
    values: &[&["before"]],
    range: 2..=2,
};

static WORD_DEFN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DEFN_CHILDREN),
    value: None,
};

pub static WORD_DEFN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("iately"),
        dictgen::InsensitiveStr::Ascii("ietly"),
        dictgen::InsensitiveStr::Ascii("inition"),
        dictgen::InsensitiveStr::Ascii("initions"),
        dictgen::InsensitiveStr::Ascii("itely"),
        dictgen::InsensitiveStr::Ascii("itions"),
    ],
    values: &[
        &["defend", "defined"],
        &["definitely"],
        &["definitely"],
        &["definition"],
        &["definitions"],
        &["definitely"],
        &["definitions"],
    ],
    range: 2..=8,
};

static WORD_DEFL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DEFL_CHILDREN),
    value: None,
};

pub static WORD_DEFL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("action"),
        dictgen::InsensitiveStr::Ascii("atin"),
        dictgen::InsensitiveStr::Ascii("aut"),
        dictgen::InsensitiveStr::Ascii("eciton"),
        dictgen::InsensitiveStr::Ascii("ecticon"),
        dictgen::InsensitiveStr::Ascii("ectin"),
        dictgen::InsensitiveStr::Ascii("ecto"),
        dictgen::InsensitiveStr::Ascii("ektion"),
    ],
    values: &[
        &["deflection"],
        &["deflation"],
        &["default"],
        &["deflection"],
        &["deflection"],
        &["deflection"],
        &["deflection"],
        &["deflection"],
    ],
    range: 3..=7,
};

static WORD_DEFI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_DEFI_CHILDREN),
    value: None,
};

static WORD_DEFI_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_DEFIA_NODE),
    Some(&WORD_DEFIB_NODE),
    Some(&WORD_DEFIC_NODE),
    None,
    Some(&WORD_DEFIE_NODE),
    None,
    None,
    None,
    Some(&WORD_DEFII_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_DEFIN_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_DEFIS_NODE),
    Some(&WORD_DEFIT_NODE),
    None,
    Some(&WORD_DEFIV_NODE),
    None,
    None,
    None,
    None,
];

static WORD_DEFIV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DEFIV_CHILDREN),
    value: None,
};

pub static WORD_DEFIV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ed")],
    values: &[&["derived"]],
    range: 2..=2,
};

static WORD_DEFIT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DEFIT_CHILDREN),
    value: None,
};

pub static WORD_DEFIT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("enly"),
        dictgen::InsensitiveStr::Ascii("inly"),
        dictgen::InsensitiveStr::Ascii("ion"),
        dictgen::InsensitiveStr::Ascii("ions"),
        dictgen::InsensitiveStr::Ascii("naly"),
        dictgen::InsensitiveStr::Ascii("nely"),
    ],
    values: &[
        &["definitely"],
        &["definitely"],
        &["definition"],
        &["definitions"],
        &["defiantly"],
        &["definitely"],
    ],
    range: 3..=4,
};

static WORD_DEFIS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DEFIS_CHILDREN),
    value: None,
};

pub static WORD_DEFIS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("hant"),
        dictgen::InsensitiveStr::Ascii("hantly"),
    ],
    values: &[&["deficient"], &["deficiently"]],
    range: 4..=6,
};

static WORD_DEFIN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_DEFIN_CHILDREN),
    value: Some(&["define"]),
};

static WORD_DEFIN_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_DEFINA_NODE),
    None,
    None,
    Some(&WORD_DEFIND_NODE),
    Some(&WORD_DEFINE_NODE),
    None,
    None,
    None,
    Some(&WORD_DEFINI_NODE),
    Some(&WORD_DEFINJ_NODE),
    None,
    Some(&WORD_DEFINL_NODE),
    None,
    Some(&WORD_DEFINN_NODE),
    Some(&WORD_DEFINO_NODE),
    None,
    None,
    None,
    Some(&WORD_DEFINS_NODE),
    Some(&WORD_DEFINT_NODE),
    Some(&WORD_DEFINU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_DEFINU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DEFINU_CHILDREN),
    value: None,
};

pub static WORD_DEFINU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("tely")],
    values: &[&["definitely"]],
    range: 4..=4,
};

static WORD_DEFINT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DEFINT_CHILDREN),
    value: Some(&["definite", "define"]),
};

pub static WORD_DEFINT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aley"),
        dictgen::InsensitiveStr::Ascii("aly"),
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("ian"),
        dictgen::InsensitiveStr::Ascii("iely"),
        dictgen::InsensitiveStr::Ascii("iion"),
        dictgen::InsensitiveStr::Ascii("iions"),
        dictgen::InsensitiveStr::Ascii("ily"),
        dictgen::InsensitiveStr::Ascii("ion"),
        dictgen::InsensitiveStr::Ascii("ions"),
        dictgen::InsensitiveStr::Ascii("ition"),
        dictgen::InsensitiveStr::Ascii("ivly"),
        dictgen::InsensitiveStr::Ascii("ley"),
    ],
    values: &[
        &["definitely"],
        &["defiantly"],
        &["definite", "define"],
        &["definition"],
        &["definitely"],
        &["definitions", "definition"],
        &["definitions"],
        &["definitely"],
        &["definition"],
        &["definitions"],
        &["definition"],
        &["definitively"],
        &["definitely"],
    ],
    range: 1..=5,
};

static WORD_DEFINS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DEFINS_CHILDREN),
    value: Some(&["defines", "define"]),
};

pub static WORD_DEFINS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("tely")],
    values: &[&["definitely"]],
    range: 4..=4,
};

static WORD_DEFINO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DEFINO_CHILDREN),
    value: None,
};

pub static WORD_DEFINO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("tely")],
    values: &[&["definitely"]],
    range: 4..=4,
};

static WORD_DEFINN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DEFINN_CHILDREN),
    value: None,
};

pub static WORD_DEFINN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("ition"),
    ],
    values: &[&["defined"], &["definition"]],
    range: 2..=5,
};

static WORD_DEFINL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DEFINL_CHILDREN),
    value: None,
};

pub static WORD_DEFINL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("tely"),
        dictgen::InsensitiveStr::Ascii("tey"),
    ],
    values: &[&["definitely"], &["definitely"]],
    range: 3..=4,
};

static WORD_DEFINJ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DEFINJ_CHILDREN),
    value: None,
};

pub static WORD_DEFINJ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("tely")],
    values: &[&["definitely"]],
    range: 4..=4,
};

static WORD_DEFINI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DEFINI_CHILDREN),
    value: None,
};

pub static WORD_DEFINI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ation"),
        dictgen::InsensitiveStr::Ascii("cion"),
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("etly"),
        dictgen::InsensitiveStr::Ascii("fiton"),
        dictgen::InsensitiveStr::Ascii("g"),
        dictgen::InsensitiveStr::Ascii("lty"),
        dictgen::InsensitiveStr::Ascii("ning"),
        dictgen::InsensitiveStr::Ascii("nitely"),
        dictgen::InsensitiveStr::Ascii("nition"),
        dictgen::InsensitiveStr::Ascii("nitions"),
        dictgen::InsensitiveStr::Ascii("nng"),
        dictgen::InsensitiveStr::Ascii("ntion"),
        dictgen::InsensitiveStr::Ascii("on"),
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("taley"),
        dictgen::InsensitiveStr::Ascii("taly"),
        dictgen::InsensitiveStr::Ascii("tavely"),
        dictgen::InsensitiveStr::Ascii("telly"),
        dictgen::InsensitiveStr::Ascii("tevely"),
        dictgen::InsensitiveStr::Ascii("tevly"),
        dictgen::InsensitiveStr::Ascii("teyl"),
        dictgen::InsensitiveStr::Ascii("tian"),
        dictgen::InsensitiveStr::Ascii("tie"),
        dictgen::InsensitiveStr::Ascii("tiely"),
        dictgen::InsensitiveStr::Ascii("tieve"),
        dictgen::InsensitiveStr::Ascii("tifely"),
        dictgen::InsensitiveStr::Ascii("tiion"),
        dictgen::InsensitiveStr::Ascii("tiions"),
        dictgen::InsensitiveStr::Ascii("tiley"),
        dictgen::InsensitiveStr::Ascii("tin"),
        dictgen::InsensitiveStr::Ascii("tinely"),
        dictgen::InsensitiveStr::Ascii("tio"),
        dictgen::InsensitiveStr::Ascii("tios"),
        dictgen::InsensitiveStr::Ascii("titely"),
        dictgen::InsensitiveStr::Ascii("tivelly"),
        dictgen::InsensitiveStr::Ascii("tivley"),
        dictgen::InsensitiveStr::Ascii("tivly"),
        dictgen::InsensitiveStr::Ascii("tivno"),
        dictgen::InsensitiveStr::Ascii("tivo"),
        dictgen::InsensitiveStr::Ascii("tivos"),
        dictgen::InsensitiveStr::Ascii("tlely"),
        dictgen::InsensitiveStr::Ascii("tlety"),
        dictgen::InsensitiveStr::Ascii("tley"),
        dictgen::InsensitiveStr::Ascii("tlly"),
        dictgen::InsensitiveStr::Ascii("tlry"),
        dictgen::InsensitiveStr::Ascii("tlty"),
        dictgen::InsensitiveStr::Ascii("tly"),
        dictgen::InsensitiveStr::Ascii("to"),
        dictgen::InsensitiveStr::Ascii("toin"),
        dictgen::InsensitiveStr::Ascii("ton"),
        dictgen::InsensitiveStr::Ascii("tons"),
        dictgen::InsensitiveStr::Ascii("tv"),
        dictgen::InsensitiveStr::Ascii("tve"),
        dictgen::InsensitiveStr::Ascii("tyl"),
    ],
    values: &[
        &["definition"],
        &["definition"],
        &["definite"],
        &["defined"],
        &["definitely"],
        &["definition"],
        &["defining"],
        &["definitely"],
        &["defining"],
        &["definitively"],
        &["definition"],
        &["definitions"],
        &["defining"],
        &["definition"],
        &["definition"],
        &["definite"],
        &["definitely"],
        &["definitely"],
        &["definitively"],
        &["definitely"],
        &["definitively"],
        &["definitively"],
        &["definitely"],
        &["definition"],
        &["definitive"],
        &["definitively", "definitely"],
        &["definitive"],
        &["definitively"],
        &["definition"],
        &["definitions"],
        &["definitively"],
        &["definitions"],
        &["definitively"],
        &["definition"],
        &["definition", "definitions"],
        &["definitively"],
        &["definitively"],
        &["definitively"],
        &["definitively"],
        &["definition"],
        &["definition"],
        &["definitions"],
        &["definitely"],
        &["definitely"],
        &["definitely"],
        &["definitely"],
        &["definitely"],
        &["definitely"],
        &["definitely"],
        &["definition"],
        &["definition"],
        &["definition"],
        &["definitions"],
        &["definitive"],
        &["definite"],
        &["definitely"],
    ],
    range: 1..=7,
};

static WORD_DEFINE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DEFINE_CHILDREN),
    value: None,
};

pub static WORD_DEFINE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("able"),
        dictgen::InsensitiveStr::Ascii("as"),
        dictgen::InsensitiveStr::Ascii("atly"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("nd"),
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("tally"),
        dictgen::InsensitiveStr::Ascii("taly"),
        dictgen::InsensitiveStr::Ascii("te"),
        dictgen::InsensitiveStr::Ascii("telly"),
        dictgen::InsensitiveStr::Ascii("tely"),
        dictgen::InsensitiveStr::Ascii("tily"),
        dictgen::InsensitiveStr::Ascii("tlely"),
        dictgen::InsensitiveStr::Ascii("tlly"),
        dictgen::InsensitiveStr::Ascii("tly"),
        dictgen::InsensitiveStr::Ascii("ttly"),
        dictgen::InsensitiveStr::Ascii("ty"),
        dictgen::InsensitiveStr::Ascii("tyl"),
    ],
    values: &[
        &["definable"],
        &["defines"],
        &["definitely"],
        &["defined"],
        &["defined"],
        &["definite"],
        &["definitely"],
        &["definitely"],
        &["definite"],
        &["definitely"],
        &["definitely"],
        &["definitely"],
        &["definitely"],
        &["definitely"],
        &["definitely"],
        &["definitely"],
        &["definitely"],
        &["definitely"],
    ],
    range: 1..=5,
};

static WORD_DEFIND_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DEFIND_CHILDREN),
    value: Some(&["defined", "defund"]),
};

pub static WORD_DEFIND_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("ing"),
    ],
    values: &[
        &["define", "defined", "defines"],
        &["defined", "defunded"],
        &["defining"],
    ],
    range: 1..=3,
};

static WORD_DEFINA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DEFINA_CHILDREN),
    value: None,
};

pub static WORD_DEFINA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("d"),
        dictgen::InsensitiveStr::Ascii("etly"),
        dictgen::InsensitiveStr::Ascii("itly"),
        dictgen::InsensitiveStr::Ascii("ltey"),
        dictgen::InsensitiveStr::Ascii("nce"),
        dictgen::InsensitiveStr::Ascii("ntley"),
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("taly"),
        dictgen::InsensitiveStr::Ascii("te"),
        dictgen::InsensitiveStr::Ascii("tedly"),
        dictgen::InsensitiveStr::Ascii("teky"),
        dictgen::InsensitiveStr::Ascii("teley"),
        dictgen::InsensitiveStr::Ascii("telly"),
        dictgen::InsensitiveStr::Ascii("telty"),
        dictgen::InsensitiveStr::Ascii("tely"),
        dictgen::InsensitiveStr::Ascii("tetly"),
        dictgen::InsensitiveStr::Ascii("tey"),
        dictgen::InsensitiveStr::Ascii("tily"),
        dictgen::InsensitiveStr::Ascii("tion"),
        dictgen::InsensitiveStr::Ascii("tions"),
        dictgen::InsensitiveStr::Ascii("tive"),
        dictgen::InsensitiveStr::Ascii("tively"),
        dictgen::InsensitiveStr::Ascii("tlely"),
        dictgen::InsensitiveStr::Ascii("tlly"),
        dictgen::InsensitiveStr::Ascii("tly"),
        dictgen::InsensitiveStr::Ascii("trly"),
        dictgen::InsensitiveStr::Ascii("ty"),
        dictgen::InsensitiveStr::Ascii("yely"),
    ],
    values: &[
        &["defined"],
        &["definitely"],
        &["definitely"],
        &["definitely"],
        &["defiance"],
        &["definitely"],
        &["defiant"],
        &["definitely"],
        &["definite"],
        &["definitely"],
        &["definitely"],
        &["definitely"],
        &["definitely"],
        &["definitely"],
        &["definitely"],
        &["definitely"],
        &["definitely"],
        &["definitely"],
        &["definition"],
        &["definitions"],
        &["definitive"],
        &["definitively"],
        &["definitely"],
        &["definitely"],
        &["definitely"],
        &["definitely"],
        &["definitely"],
        &["definitely"],
    ],
    range: 1..=6,
};

static WORD_DEFII_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DEFII_CHILDREN),
    value: None,
};

pub static WORD_DEFII_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ntely")],
    values: &[&["definitely"]],
    range: 5..=5,
};

static WORD_DEFIE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DEFIE_CHILDREN),
    value: None,
};

pub static WORD_DEFIE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("n"),
        dictgen::InsensitiveStr::Ascii("nd"),
        dictgen::InsensitiveStr::Ascii("ned"),
    ],
    values: &[&["define"], &["defined"], &["defined"]],
    range: 1..=3,
};

static WORD_DEFIC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DEFIC_CHILDREN),
    value: None,
};

pub static WORD_DEFIC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ately"),
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("eint"),
        dictgen::InsensitiveStr::Ascii("iancies"),
        dictgen::InsensitiveStr::Ascii("iancy"),
        dictgen::InsensitiveStr::Ascii("ience"),
        dictgen::InsensitiveStr::Ascii("iencey"),
        dictgen::InsensitiveStr::Ascii("iencias"),
        dictgen::InsensitiveStr::Ascii("ienct"),
        dictgen::InsensitiveStr::Ascii("ienies"),
        dictgen::InsensitiveStr::Ascii("iensies"),
        dictgen::InsensitiveStr::Ascii("ientcy"),
        dictgen::InsensitiveStr::Ascii("ienty"),
        dictgen::InsensitiveStr::Ascii("ieny"),
        dictgen::InsensitiveStr::Ascii("iet"),
        dictgen::InsensitiveStr::Ascii("ites"),
    ],
    values: &[
        &["definitely"],
        &["device"],
        &["deficient"],
        &["deficiencies"],
        &["deficiency"],
        &["deficiencies"],
        &["deficiency"],
        &["deficiencies"],
        &["deficient"],
        &["deficiencies"],
        &["deficiencies"],
        &["deficiency"],
        &["deficiency"],
        &["deficiency"],
        &["deficient"],
        &["deficits"],
    ],
    range: 1..=7,
};

static WORD_DEFIB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DEFIB_CHILDREN),
    value: None,
};

pub static WORD_DEFIB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ately")],
    values: &[&["definitely"]],
    range: 5..=5,
};

static WORD_DEFIA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DEFIA_CHILDREN),
    value: None,
};

pub static WORD_DEFIA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("netly"),
        dictgen::InsensitiveStr::Ascii("nlty"),
        dictgen::InsensitiveStr::Ascii("ntely"),
        dictgen::InsensitiveStr::Ascii("ntley"),
    ],
    values: &[
        &["definitely"],
        &["defiantly"],
        &["definitely", "defiantly"],
        &["definitely"],
    ],
    range: 4..=5,
};

static WORD_DEFF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DEFF_CHILDREN),
    value: None,
};

pub static WORD_DEFF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ault"),
        dictgen::InsensitiveStr::Ascii("aulted"),
        dictgen::InsensitiveStr::Ascii("aults"),
        dictgen::InsensitiveStr::Ascii("ensively"),
        dictgen::InsensitiveStr::Ascii("er"),
        dictgen::InsensitiveStr::Ascii("ered"),
        dictgen::InsensitiveStr::Ascii("erence"),
        dictgen::InsensitiveStr::Ascii("erent"),
        dictgen::InsensitiveStr::Ascii("erential"),
        dictgen::InsensitiveStr::Ascii("erently"),
        dictgen::InsensitiveStr::Ascii("ering"),
        dictgen::InsensitiveStr::Ascii("erred"),
        dictgen::InsensitiveStr::Ascii("ers"),
        dictgen::InsensitiveStr::Ascii("ine"),
        dictgen::InsensitiveStr::Ascii("ined"),
        dictgen::InsensitiveStr::Ascii("inition"),
        dictgen::InsensitiveStr::Ascii("initively"),
        dictgen::InsensitiveStr::Ascii("irent"),
    ],
    values: &[
        &["default"],
        &["defaulted"],
        &["defaults"],
        &["defensively"],
        &["differ", "defer"],
        &["differed", "deferred"],
        &["difference", "deference"],
        &["different", "deferent"],
        &["differential", "deferential"],
        &["differently"],
        &["differing"],
        &["deferred"],
        &["differs", "defers"],
        &["define"],
        &["defined"],
        &["definition"],
        &["definitively"],
        &["different"],
    ],
    range: 2..=9,
};

static WORD_DEFE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DEFE_CHILDREN),
    value: None,
};

pub static WORD_DEFE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ault"),
        dictgen::InsensitiveStr::Ascii("aulted"),
        dictgen::InsensitiveStr::Ascii("aulting"),
        dictgen::InsensitiveStr::Ascii("aults"),
        dictgen::InsensitiveStr::Ascii("cit"),
        dictgen::InsensitiveStr::Ascii("ctos"),
        dictgen::InsensitiveStr::Ascii("ctus"),
        dictgen::InsensitiveStr::Ascii("ine"),
        dictgen::InsensitiveStr::Ascii("ines"),
        dictgen::InsensitiveStr::Ascii("intly"),
        dictgen::InsensitiveStr::Ascii("lct"),
        dictgen::InsensitiveStr::Ascii("lction"),
        dictgen::InsensitiveStr::Ascii("nate"),
        dictgen::InsensitiveStr::Ascii("nately"),
        dictgen::InsensitiveStr::Ascii("ndas"),
        dictgen::InsensitiveStr::Ascii("ndeers"),
        dictgen::InsensitiveStr::Ascii("ndent"),
        dictgen::InsensitiveStr::Ascii("ndents"),
        dictgen::InsensitiveStr::Ascii("nderes"),
        dictgen::InsensitiveStr::Ascii("nderlas"),
        dictgen::InsensitiveStr::Ascii("nderlos"),
        dictgen::InsensitiveStr::Ascii("ndernos"),
        dictgen::InsensitiveStr::Ascii("ndes"),
        dictgen::InsensitiveStr::Ascii("ndis"),
        dictgen::InsensitiveStr::Ascii("ndre"),
        dictgen::InsensitiveStr::Ascii("ndrs"),
        dictgen::InsensitiveStr::Ascii("nesless"),
        dictgen::InsensitiveStr::Ascii("nesman"),
        dictgen::InsensitiveStr::Ascii("nisvely"),
        dictgen::InsensitiveStr::Ascii("nitely"),
        dictgen::InsensitiveStr::Ascii("nition"),
        dictgen::InsensitiveStr::Ascii("nitions"),
        dictgen::InsensitiveStr::Ascii("nitly"),
        dictgen::InsensitiveStr::Ascii("nsd"),
        dictgen::InsensitiveStr::Ascii("nsea"),
        dictgen::InsensitiveStr::Ascii("nselss"),
        dictgen::InsensitiveStr::Ascii("nsen"),
        dictgen::InsensitiveStr::Ascii("nsese"),
        dictgen::InsensitiveStr::Ascii("nsie"),
        dictgen::InsensitiveStr::Ascii("nsivley"),
        dictgen::InsensitiveStr::Ascii("nsivly"),
        dictgen::InsensitiveStr::Ascii("ral"),
        dictgen::InsensitiveStr::Ascii("rals"),
        dictgen::InsensitiveStr::Ascii("rance"),
        dictgen::InsensitiveStr::Ascii("red"),
        dictgen::InsensitiveStr::Ascii("rencing"),
        dictgen::InsensitiveStr::Ascii("rentiating"),
        dictgen::InsensitiveStr::Ascii("ring"),
        dictgen::InsensitiveStr::Ascii("rreal"),
        dictgen::InsensitiveStr::Ascii("tead"),
    ],
    values: &[
        &["default"],
        &["defaulted"],
        &["defaulting"],
        &["defaults"],
        &["deficit"],
        &["defects"],
        &["defects"],
        &["define"],
        &["defines"],
        &["definitely"],
        &["deflect"],
        &["deflection"],
        &["definite"],
        &["definitely"],
        &["defends"],
        &["defender"],
        &["defendant"],
        &["defendants"],
        &["defenders"],
        &["defenders"],
        &["defenders"],
        &["defenders"],
        &["defenders"],
        &["defends"],
        &["defender"],
        &["defends"],
        &["defenseless"],
        &["defenseman"],
        &["defensively"],
        &["definitely"],
        &["definition"],
        &["definitions"],
        &["definitely"],
        &["defends"],
        &["defenseman"],
        &["defenseless"],
        &["defenseman"],
        &["defenseless"],
        &["defensive"],
        &["defensively"],
        &["defensively"],
        &["deferral"],
        &["deferrals"],
        &["deference"],
        &["deferred"],
        &["dereferencing"],
        &["differentiating"],
        &["deferring"],
        &["deferral"],
        &["defeated"],
    ],
    range: 3..=10,
};

static WORD_DEFA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DEFA_CHILDREN),
    value: None,
};

pub static WORD_DEFA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cation"),
        dictgen::InsensitiveStr::Ascii("il"),
        dictgen::InsensitiveStr::Ascii("ilt"),
        dictgen::InsensitiveStr::Ascii("int"),
        dictgen::InsensitiveStr::Ascii("intly"),
        dictgen::InsensitiveStr::Ascii("lt"),
        dictgen::InsensitiveStr::Ascii("ltion"),
        dictgen::InsensitiveStr::Ascii("lts"),
        dictgen::InsensitiveStr::Ascii("lut"),
        dictgen::InsensitiveStr::Ascii("mating"),
        dictgen::InsensitiveStr::Ascii("nitely"),
        dictgen::InsensitiveStr::Ascii("nitly"),
        dictgen::InsensitiveStr::Ascii("rgkey"),
        dictgen::InsensitiveStr::Ascii("tult"),
        dictgen::InsensitiveStr::Ascii("ukt"),
        dictgen::InsensitiveStr::Ascii("ul"),
        dictgen::InsensitiveStr::Ascii("ulat"),
        dictgen::InsensitiveStr::Ascii("ulats"),
        dictgen::InsensitiveStr::Ascii("uld"),
        dictgen::InsensitiveStr::Ascii("ulds"),
        dictgen::InsensitiveStr::Ascii("ule"),
        dictgen::InsensitiveStr::Ascii("uled"),
        dictgen::InsensitiveStr::Ascii("ules"),
        dictgen::InsensitiveStr::Ascii("ulf"),
        dictgen::InsensitiveStr::Ascii("ulfs"),
        dictgen::InsensitiveStr::Ascii("ulg"),
        dictgen::InsensitiveStr::Ascii("ulgs"),
        dictgen::InsensitiveStr::Ascii("ulh"),
        dictgen::InsensitiveStr::Ascii("ulhs"),
        dictgen::InsensitiveStr::Ascii("uling"),
        dictgen::InsensitiveStr::Ascii("ulit"),
        dictgen::InsensitiveStr::Ascii("ulits"),
        dictgen::InsensitiveStr::Ascii("ulkt"),
        dictgen::InsensitiveStr::Ascii("ulkts"),
        dictgen::InsensitiveStr::Ascii("ull"),
        dictgen::InsensitiveStr::Ascii("ulls"),
        dictgen::InsensitiveStr::Ascii("ullt"),
        dictgen::InsensitiveStr::Ascii("ullts"),
        dictgen::InsensitiveStr::Ascii("ulr"),
        dictgen::InsensitiveStr::Ascii("ulrs"),
        dictgen::InsensitiveStr::Ascii("ulrt"),
        dictgen::InsensitiveStr::Ascii("ulrts"),
        dictgen::InsensitiveStr::Ascii("uls"),
        dictgen::InsensitiveStr::Ascii("ulst"),
        dictgen::InsensitiveStr::Ascii("ultet"),
        dictgen::InsensitiveStr::Ascii("ulty"),
        dictgen::InsensitiveStr::Ascii("uly"),
        dictgen::InsensitiveStr::Ascii("ulys"),
        dictgen::InsensitiveStr::Ascii("ulz"),
        dictgen::InsensitiveStr::Ascii("ut"),
        dictgen::InsensitiveStr::Ascii("utl"),
        dictgen::InsensitiveStr::Ascii("utled"),
        dictgen::InsensitiveStr::Ascii("utling"),
        dictgen::InsensitiveStr::Ascii("utls"),
        dictgen::InsensitiveStr::Ascii("utlt"),
        dictgen::InsensitiveStr::Ascii("utly"),
        dictgen::InsensitiveStr::Ascii("uts"),
        dictgen::InsensitiveStr::Ascii("utt"),
        dictgen::InsensitiveStr::Ascii("utted"),
        dictgen::InsensitiveStr::Ascii("utting"),
        dictgen::InsensitiveStr::Ascii("utts"),
    ],
    values: &[
        &["defamation"],
        &["detail"],
        &["default"],
        &["defiant"],
        &["defiantly"],
        &["default"],
        &["deflation"],
        &["defaults"],
        &["default"],
        &["defamation"],
        &["definitely"],
        &["defiantly"],
        &["defragkey"],
        &["default"],
        &["default"],
        &["default"],
        &["default"],
        &["defaults"],
        &["default"],
        &["defaults"],
        &["default"],
        &["default", "defaulted"],
        &["defaults"],
        &["default"],
        &["defaults"],
        &["default"],
        &["defaults"],
        &["default"],
        &["defaults"],
        &["defaulting"],
        &["default"],
        &["defaults"],
        &["default"],
        &["defaults"],
        &["default"],
        &["defaults"],
        &["default"],
        &["defaults"],
        &["default"],
        &["defaults"],
        &["default"],
        &["defaults"],
        &["defaults", "default"],
        &["defaults", "default"],
        &["defaulted"],
        &["default"],
        &["default"],
        &["defaults"],
        &["default", "defaults"],
        &["default"],
        &["default"],
        &["defaulted"],
        &["defaulting"],
        &["defaults"],
        &["default"],
        &["defaultly", "default"],
        &["defaults"],
        &["default"],
        &["defaulted"],
        &["defaulting"],
        &["defaults"],
    ],
    range: 2..=6,
};

static WORD_DEE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DEE_CHILDREN),
    value: None,
};

pub static WORD_DEE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("corator"),
        dictgen::InsensitiveStr::Ascii("ep"),
        dictgen::InsensitiveStr::Ascii("lte"),
        dictgen::InsensitiveStr::Ascii("ndencies"),
        dictgen::InsensitiveStr::Ascii("ndency"),
        dictgen::InsensitiveStr::Ascii("po"),
        dictgen::InsensitiveStr::Ascii("pos"),
        dictgen::InsensitiveStr::Ascii("sil"),
        dictgen::InsensitiveStr::Ascii("zil"),
    ],
    values: &[
        &["decorator"],
        &["deep"],
        &["delete"],
        &["dependencies"],
        &["dependency"],
        &["depot"],
        &["depots"],
        &["diesel"],
        &["diesel"],
    ],
    range: 2..=8,
};

static WORD_DED_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DED_CHILDREN),
    value: Some(&["dead"]),
};

pub static WORD_DED_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ault"),
        dictgen::InsensitiveStr::Ascii("ect"),
        dictgen::InsensitiveStr::Ascii("ected"),
        dictgen::InsensitiveStr::Ascii("ection"),
        dictgen::InsensitiveStr::Ascii("ections"),
        dictgen::InsensitiveStr::Ascii("ects"),
        dictgen::InsensitiveStr::Ascii("fined"),
        dictgen::InsensitiveStr::Ascii("icacion"),
        dictgen::InsensitiveStr::Ascii("icato"),
        dictgen::InsensitiveStr::Ascii("idate"),
        dictgen::InsensitiveStr::Ascii("idated"),
        dictgen::InsensitiveStr::Ascii("idates"),
        dictgen::InsensitiveStr::Ascii("ikation"),
        dictgen::InsensitiveStr::Ascii("ly"),
        dictgen::InsensitiveStr::Ascii("ucatble"),
        dictgen::InsensitiveStr::Ascii("ucitble"),
        dictgen::InsensitiveStr::Ascii("uctable"),
        dictgen::InsensitiveStr::Ascii("uctables"),
        dictgen::InsensitiveStr::Ascii("uctiable"),
        dictgen::InsensitiveStr::Ascii("uctibe"),
        dictgen::InsensitiveStr::Ascii("uctie"),
        dictgen::InsensitiveStr::Ascii("uplacate"),
        dictgen::InsensitiveStr::Ascii("uplacated"),
        dictgen::InsensitiveStr::Ascii("uplacates"),
        dictgen::InsensitiveStr::Ascii("uplacation"),
        dictgen::InsensitiveStr::Ascii("uplacte"),
        dictgen::InsensitiveStr::Ascii("uplacted"),
        dictgen::InsensitiveStr::Ascii("uplactes"),
        dictgen::InsensitiveStr::Ascii("uplaction"),
        dictgen::InsensitiveStr::Ascii("uplaicate"),
        dictgen::InsensitiveStr::Ascii("uplaicated"),
        dictgen::InsensitiveStr::Ascii("uplaicates"),
        dictgen::InsensitiveStr::Ascii("uplaication"),
        dictgen::InsensitiveStr::Ascii("uplate"),
        dictgen::InsensitiveStr::Ascii("uplated"),
        dictgen::InsensitiveStr::Ascii("uplates"),
        dictgen::InsensitiveStr::Ascii("uplation"),
        dictgen::InsensitiveStr::Ascii("upliate"),
        dictgen::InsensitiveStr::Ascii("upliated"),
    ],
    values: &[
        &["default"],
        &["deduct", "detect"],
        &["detected", "deducted"],
        &["detection", "deduction"],
        &["detections"],
        &["deducts", "detects"],
        &["defined"],
        &["dedication"],
        &["dedication"],
        &["dedicate"],
        &["dedicated"],
        &["dedicates"],
        &["dedication"],
        &["deadly"],
        &["deductible"],
        &["deductible"],
        &["deductible"],
        &["deductibles"],
        &["deductible"],
        &["deductible"],
        &["deductible"],
        &["deduplicate"],
        &["deduplicated"],
        &["deduplicates"],
        &["deduplication"],
        &["deduplicate"],
        &["deduplicated"],
        &["deduplicates"],
        &["deduplication"],
        &["deduplicate"],
        &["deduplicated"],
        &["deduplicates"],
        &["deduplication"],
        &["deduplicate"],
        &["deduplicated"],
        &["deduplicates"],
        &["deduplication"],
        &["deduplicate"],
        &["deduplicated"],
    ],
    range: 2..=11,
};

static WORD_DEC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_DEC_CHILDREN),
    value: None,
};

static WORD_DEC_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_DECA_NODE),
    None,
    Some(&WORD_DECC_NODE),
    None,
    Some(&WORD_DECE_NODE),
    None,
    None,
    None,
    Some(&WORD_DECI_NODE),
    None,
    None,
    Some(&WORD_DECL_NODE),
    Some(&WORD_DECM_NODE),
    None,
    Some(&WORD_DECO_NODE),
    Some(&WORD_DECP_NODE),
    None,
    Some(&WORD_DECR_NODE),
    Some(&WORD_DECS_NODE),
    Some(&WORD_DECT_NODE),
    Some(&WORD_DECU_NODE),
    None,
    None,
    None,
    Some(&WORD_DECY_NODE),
    None,
];

static WORD_DECY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DECY_CHILDREN),
    value: None,
};

pub static WORD_DECY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("pher"),
        dictgen::InsensitiveStr::Ascii("phered"),
    ],
    values: &[&["decipher"], &["deciphered"]],
    range: 4..=6,
};

static WORD_DECU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DECU_CHILDREN),
    value: None,
};

pub static WORD_DECU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("table"),
        dictgen::InsensitiveStr::Ascii("tables"),
    ],
    values: &[&["deductible"], &["deductibles"]],
    range: 5..=6,
};

static WORD_DECT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DECT_CHILDREN),
    value: None,
};

pub static WORD_DECT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ect"),
        dictgen::InsensitiveStr::Ascii("ecte"),
        dictgen::InsensitiveStr::Ascii("ected"),
        dictgen::InsensitiveStr::Ascii("ecting"),
        dictgen::InsensitiveStr::Ascii("ection"),
        dictgen::InsensitiveStr::Ascii("ections"),
        dictgen::InsensitiveStr::Ascii("ector"),
        dictgen::InsensitiveStr::Ascii("ivate"),
    ],
    values: &[
        &["detect"],
        &["detect", "detected", "detects"],
        &["detected"],
        &["detecting"],
        &["detection"],
        &["detections"],
        &["detector"],
        &["deactivate"],
    ],
    range: 3..=7,
};

static WORD_DECS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DECS_CHILDREN),
    value: None,
};

pub static WORD_DECS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cription"),
        dictgen::InsensitiveStr::Ascii("end"),
        dictgen::InsensitiveStr::Ascii("endants"),
        dictgen::InsensitiveStr::Ascii("ended"),
        dictgen::InsensitiveStr::Ascii("ending"),
        dictgen::InsensitiveStr::Ascii("ion"),
        dictgen::InsensitiveStr::Ascii("ions"),
        dictgen::InsensitiveStr::Ascii("iptors"),
        dictgen::InsensitiveStr::Ascii("ribed"),
        dictgen::InsensitiveStr::Ascii("riptor"),
        dictgen::InsensitiveStr::Ascii("riptors"),
        dictgen::InsensitiveStr::Ascii("tiption"),
        dictgen::InsensitiveStr::Ascii("tiptions"),
    ],
    values: &[
        &["description"],
        &["descend"],
        &["descendants"],
        &["descended"],
        &["descending"],
        &["decision"],
        &["decisions"],
        &["descriptors"],
        &["described"],
        &["descriptor"],
        &["descriptors"],
        &["description"],
        &["descriptions"],
    ],
    range: 3..=8,
};

static WORD_DECR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DECR_CHILDREN),
    value: None,
};

pub static WORD_DECR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aesing"),
        dictgen::InsensitiveStr::Ascii("asing"),
        dictgen::InsensitiveStr::Ascii("ation"),
        dictgen::InsensitiveStr::Ascii("eace"),
        dictgen::InsensitiveStr::Ascii("eas"),
        dictgen::InsensitiveStr::Ascii("eate"),
        dictgen::InsensitiveStr::Ascii("emeant"),
        dictgen::InsensitiveStr::Ascii("emeantal"),
        dictgen::InsensitiveStr::Ascii("emeanted"),
        dictgen::InsensitiveStr::Ascii("emeanting"),
        dictgen::InsensitiveStr::Ascii("emeants"),
        dictgen::InsensitiveStr::Ascii("emenet"),
        dictgen::InsensitiveStr::Ascii("emenetd"),
        dictgen::InsensitiveStr::Ascii("emeneted"),
        dictgen::InsensitiveStr::Ascii("ese"),
        dictgen::InsensitiveStr::Ascii("esing"),
        dictgen::InsensitiveStr::Ascii("ess"),
        dictgen::InsensitiveStr::Ascii("eypted"),
        dictgen::InsensitiveStr::Ascii("ibe"),
        dictgen::InsensitiveStr::Ascii("ibed"),
        dictgen::InsensitiveStr::Ascii("ibes"),
        dictgen::InsensitiveStr::Ascii("ibing"),
        dictgen::InsensitiveStr::Ascii("iption"),
        dictgen::InsensitiveStr::Ascii("iptions"),
        dictgen::InsensitiveStr::Ascii("iptive"),
        dictgen::InsensitiveStr::Ascii("iptor"),
        dictgen::InsensitiveStr::Ascii("iptors"),
        dictgen::InsensitiveStr::Ascii("menet"),
        dictgen::InsensitiveStr::Ascii("menetd"),
        dictgen::InsensitiveStr::Ascii("meneted"),
        dictgen::InsensitiveStr::Ascii("ment"),
        dictgen::InsensitiveStr::Ascii("mented"),
        dictgen::InsensitiveStr::Ascii("menting"),
        dictgen::InsensitiveStr::Ascii("ments"),
        dictgen::InsensitiveStr::Ascii("oation"),
        dictgen::InsensitiveStr::Ascii("oative"),
        dictgen::InsensitiveStr::Ascii("pt"),
        dictgen::InsensitiveStr::Ascii("pted"),
        dictgen::InsensitiveStr::Ascii("ption"),
        dictgen::InsensitiveStr::Ascii("yp"),
        dictgen::InsensitiveStr::Ascii("yped"),
        dictgen::InsensitiveStr::Ascii("yptation"),
        dictgen::InsensitiveStr::Ascii("ytion"),
        dictgen::InsensitiveStr::Ascii("ytpion"),
    ],
    values: &[
        &["decreasing", "deceasing"],
        &["decreasing", "deceasing"],
        &["decoration"],
        &["decrease"],
        &["decrease"],
        &["decrease", "desecrate", "destroy", "discrete"],
        &["decrement"],
        &["decremental"],
        &["decremented"],
        &["decrementing"],
        &["decrements"],
        &["decrement"],
        &["decremented"],
        &["decremented"],
        &["decrease"],
        &["decreasing", "deceasing"],
        &["decrees"],
        &["decrypted"],
        &["describe"],
        &["described"],
        &["describes"],
        &["describing"],
        &["description", "decryption"],
        &["descriptions", "decryptions"],
        &["descriptive"],
        &["descriptor"],
        &["descriptors"],
        &["decrement"],
        &["decremented"],
        &["decremented"],
        &["decrement"],
        &["decremented"],
        &["decrementing"],
        &["decrements"],
        &["decoration"],
        &["decorative"],
        &["decrypt"],
        &["decrypted"],
        &["decryption"],
        &["decrypt"],
        &["decrypted"],
        &["decryption"],
        &["decryption"],
        &["decryption"],
    ],
    range: 2..=9,
};

static WORD_DECP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DECP_CHILDREN),
    value: None,
};

pub static WORD_DECP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("etion"),
        dictgen::InsensitiveStr::Ascii("etive"),
    ],
    values: &[&["deception"], &["deceptive"]],
    range: 5..=5,
};

static WORD_DECO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_DECO_CHILDREN),
    value: None,
};

static WORD_DECO_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_DECOA_NODE),
    None,
    Some(&WORD_DECOC_NODE),
    Some(&WORD_DECOD_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_DECOM_NODE),
    Some(&WORD_DECON_NODE),
    None,
    Some(&WORD_DECOP_NODE),
    None,
    Some(&WORD_DECOR_NODE),
    Some(&WORD_DECOS_NODE),
    Some(&WORD_DECOT_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_DECOT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DECOT_CHILDREN),
    value: None,
};

pub static WORD_DECOT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ations")],
    values: &[&["decorations"]],
    range: 6..=6,
};

static WORD_DECOS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DECOS_CHILDREN),
    value: None,
};

pub static WORD_DECOS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("er"),
        dictgen::InsensitiveStr::Ascii("ers"),
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("ings"),
    ],
    values: &[
        &["decode"],
        &["decoded"],
        &["decoder"],
        &["decoders"],
        &["decodes"],
        &["decoding"],
        &["decodings"],
    ],
    range: 1..=4,
};

static WORD_DECOR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DECOR_CHILDREN),
    value: None,
};

pub static WORD_DECOR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("acion"),
        dictgen::InsensitiveStr::Ascii("aded"),
        dictgen::InsensitiveStr::Ascii("atie"),
        dictgen::InsensitiveStr::Ascii("atieve"),
        dictgen::InsensitiveStr::Ascii("atin"),
        dictgen::InsensitiveStr::Ascii("ativo"),
        dictgen::InsensitiveStr::Ascii("ativos"),
        dictgen::InsensitiveStr::Ascii("atrion"),
        dictgen::InsensitiveStr::Ascii("de"),
        dictgen::InsensitiveStr::Ascii("ded"),
        dictgen::InsensitiveStr::Ascii("der"),
        dictgen::InsensitiveStr::Ascii("ders"),
        dictgen::InsensitiveStr::Ascii("des"),
        dictgen::InsensitiveStr::Ascii("ding"),
        dictgen::InsensitiveStr::Ascii("dings"),
        dictgen::InsensitiveStr::Ascii("itive"),
        dictgen::InsensitiveStr::Ascii("rellation"),
        dictgen::InsensitiveStr::Ascii("tator"),
        dictgen::InsensitiveStr::Ascii("tive"),
    ],
    values: &[
        &["decoration"],
        &["decorated"],
        &["decorative"],
        &["decorative"],
        &["decorations"],
        &["decoration"],
        &["decorations"],
        &["decoration"],
        &["decode"],
        &["decoded"],
        &["decoder"],
        &["decoders"],
        &["decodes"],
        &["decoding"],
        &["decodings"],
        &["decorative"],
        &["decorrelation"],
        &["decorator"],
        &["decorative"],
    ],
    range: 2..=9,
};

static WORD_DECOP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DECOP_CHILDREN),
    value: None,
};

pub static WORD_DECOP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ose"),
        dictgen::InsensitiveStr::Ascii("oses"),
    ],
    values: &[&["decompose"], &["decomposes"]],
    range: 3..=4,
};

static WORD_DECON_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DECON_CHILDREN),
    value: None,
};

pub static WORD_DECON_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("d"),
        dictgen::InsensitiveStr::Ascii("de"),
        dictgen::InsensitiveStr::Ascii("ded"),
        dictgen::InsensitiveStr::Ascii("der"),
        dictgen::InsensitiveStr::Ascii("ders"),
        dictgen::InsensitiveStr::Ascii("des"),
        dictgen::InsensitiveStr::Ascii("ding"),
        dictgen::InsensitiveStr::Ascii("dings"),
        dictgen::InsensitiveStr::Ascii("stract"),
        dictgen::InsensitiveStr::Ascii("stracted"),
        dictgen::InsensitiveStr::Ascii("strcutor"),
    ],
    values: &[
        &["decode"],
        &["decode"],
        &["decoded"],
        &["decoder"],
        &["decoders"],
        &["decodes"],
        &["decoding"],
        &["decodings"],
        &["deconstruct"],
        &["deconstructed"],
        &["deconstructor"],
    ],
    range: 1..=8,
};

static WORD_DECOM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DECOM_CHILDREN),
    value: None,
};

pub static WORD_DECOM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("issioned"),
        dictgen::InsensitiveStr::Ascii("issioning"),
        dictgen::InsensitiveStr::Ascii("missionn"),
        dictgen::InsensitiveStr::Ascii("missionned"),
        dictgen::InsensitiveStr::Ascii("mpress"),
        dictgen::InsensitiveStr::Ascii("oposition"),
        dictgen::InsensitiveStr::Ascii("poseion"),
        dictgen::InsensitiveStr::Ascii("posion"),
        dictgen::InsensitiveStr::Ascii("posit"),
        dictgen::InsensitiveStr::Ascii("posited"),
        dictgen::InsensitiveStr::Ascii("positing"),
        dictgen::InsensitiveStr::Ascii("positon"),
        dictgen::InsensitiveStr::Ascii("positons"),
        dictgen::InsensitiveStr::Ascii("posits"),
        dictgen::InsensitiveStr::Ascii("postion"),
        dictgen::InsensitiveStr::Ascii("postition"),
        dictgen::InsensitiveStr::Ascii("pres"),
        dictgen::InsensitiveStr::Ascii("presed"),
        dictgen::InsensitiveStr::Ascii("preser"),
        dictgen::InsensitiveStr::Ascii("preses"),
        dictgen::InsensitiveStr::Ascii("presing"),
        dictgen::InsensitiveStr::Ascii("presion"),
        dictgen::InsensitiveStr::Ascii("presor"),
        dictgen::InsensitiveStr::Ascii("pressd"),
        dictgen::InsensitiveStr::Ascii("presser"),
        dictgen::InsensitiveStr::Ascii("presssion"),
        dictgen::InsensitiveStr::Ascii("pse"),
    ],
    values: &[
        &["decommissioned"],
        &["decommissioning"],
        &["decommission"],
        &["decommissioned"],
        &["decompress"],
        &["decomposition"],
        &["decomposition"],
        &["decomposition"],
        &["decompose"],
        &["decomposed"],
        &["decomposing"],
        &["decomposition"],
        &["decompositions"],
        &["decomposes"],
        &["decomposition"],
        &["decomposition"],
        &["decompress"],
        &["decompressed"],
        &["decompressor"],
        &["decompresses"],
        &["decompressing"],
        &["decompression"],
        &["decompressor"],
        &["decompressed"],
        &["decompressor"],
        &["decompression"],
        &["decompose"],
    ],
    range: 3..=10,
};

static WORD_DECOD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DECOD_CHILDREN),
    value: None,
};

pub static WORD_DECOD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ded"),
        dictgen::InsensitiveStr::Ascii("ding"),
        dictgen::InsensitiveStr::Ascii("eing"),
    ],
    values: &[&["decoded"], &["decoding"], &["decoding"]],
    range: 3..=4,
};

static WORD_DECOC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DECOC_CHILDREN),
    value: None,
};

pub static WORD_DECOC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("de"),
        dictgen::InsensitiveStr::Ascii("ded"),
        dictgen::InsensitiveStr::Ascii("der"),
        dictgen::InsensitiveStr::Ascii("ders"),
        dictgen::InsensitiveStr::Ascii("des"),
        dictgen::InsensitiveStr::Ascii("ding"),
        dictgen::InsensitiveStr::Ascii("dings"),
    ],
    values: &[
        &["decode"],
        &["decoded"],
        &["decoder"],
        &["decoders"],
        &["decodes"],
        &["decoding"],
        &["decodings"],
    ],
    range: 2..=5,
};

static WORD_DECOA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DECOA_CHILDREN),
    value: None,
};

pub static WORD_DECOA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("rtions")],
    values: &[&["decoration"]],
    range: 6..=6,
};

static WORD_DECM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DECM_CHILDREN),
    value: None,
};

pub static WORD_DECM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("eber")],
    values: &[&["december"]],
    range: 4..=4,
};

static WORD_DECL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DECL_CHILDREN),
    value: None,
};

pub static WORD_DECL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ar"),
        dictgen::InsensitiveStr::Ascii("aracion"),
        dictgen::InsensitiveStr::Ascii("araion"),
        dictgen::InsensitiveStr::Ascii("araions"),
        dictgen::InsensitiveStr::Ascii("arase"),
        dictgen::InsensitiveStr::Ascii("arasen"),
        dictgen::InsensitiveStr::Ascii("araste"),
        dictgen::InsensitiveStr::Ascii("arated"),
        dictgen::InsensitiveStr::Ascii("aratinos"),
        dictgen::InsensitiveStr::Ascii("aratiom"),
        dictgen::InsensitiveStr::Ascii("araton"),
        dictgen::InsensitiveStr::Ascii("aratons"),
        dictgen::InsensitiveStr::Ascii("arayion"),
        dictgen::InsensitiveStr::Ascii("arayions"),
        dictgen::InsensitiveStr::Ascii("ard"),
        dictgen::InsensitiveStr::Ascii("arded"),
        dictgen::InsensitiveStr::Ascii("areation"),
        dictgen::InsensitiveStr::Ascii("arees"),
        dictgen::InsensitiveStr::Ascii("aremos"),
        dictgen::InsensitiveStr::Ascii("aritive"),
        dictgen::InsensitiveStr::Ascii("aritively"),
        dictgen::InsensitiveStr::Ascii("arnig"),
        dictgen::InsensitiveStr::Ascii("ars"),
        dictgen::InsensitiveStr::Ascii("artated"),
        dictgen::InsensitiveStr::Ascii("artation"),
        dictgen::InsensitiveStr::Ascii("artations"),
        dictgen::InsensitiveStr::Ascii("artative"),
        dictgen::InsensitiveStr::Ascii("artator"),
        dictgen::InsensitiveStr::Ascii("artators"),
        dictgen::InsensitiveStr::Ascii("arted"),
        dictgen::InsensitiveStr::Ascii("artion"),
        dictgen::InsensitiveStr::Ascii("artions"),
        dictgen::InsensitiveStr::Ascii("artiuon"),
        dictgen::InsensitiveStr::Ascii("artiuons"),
        dictgen::InsensitiveStr::Ascii("artiuve"),
        dictgen::InsensitiveStr::Ascii("artive"),
        dictgen::InsensitiveStr::Ascii("artor"),
        dictgen::InsensitiveStr::Ascii("artors"),
        dictgen::InsensitiveStr::Ascii("ase"),
        dictgen::InsensitiveStr::Ascii("ataions"),
        dictgen::InsensitiveStr::Ascii("atation"),
        dictgen::InsensitiveStr::Ascii("atations"),
        dictgen::InsensitiveStr::Ascii("ated"),
        dictgen::InsensitiveStr::Ascii("ation"),
        dictgen::InsensitiveStr::Ascii("ations"),
        dictgen::InsensitiveStr::Ascii("atory"),
        dictgen::InsensitiveStr::Ascii("ears"),
        dictgen::InsensitiveStr::Ascii("eration"),
        dictgen::InsensitiveStr::Ascii("erations"),
        dictgen::InsensitiveStr::Ascii("inig"),
        dictgen::InsensitiveStr::Ascii("inining"),
        dictgen::InsensitiveStr::Ascii("oration"),
        dictgen::InsensitiveStr::Ascii("ration"),
    ],
    values: &[
        &["declare"],
        &["declaration"],
        &["declaration"],
        &["declarations"],
        &["declares"],
        &["declares"],
        &["declares"],
        &["declared"],
        &["declarations"],
        &["declaration"],
        &["declaration"],
        &["declarations"],
        &["declaration"],
        &["declarations"],
        &["declared"],
        &["declared"],
        &["declaration"],
        &["declares"],
        &["declares"],
        &["declarative"],
        &["declaratively"],
        &["declaring"],
        &["declares", "declared"],
        &["declared"],
        &["declaration"],
        &["declarations"],
        &["declarative"],
        &["declarator"],
        &["declarators"],
        &["declared"],
        &["declaration"],
        &["declarations"],
        &["declaration"],
        &["declarations"],
        &["declarative"],
        &["declarative"],
        &["declarator"],
        &["declarators"],
        &["declares"],
        &["declarations"],
        &["declaration"],
        &["declarations"],
        &["declared"],
        &["declaration"],
        &["declarations"],
        &["declaratory"],
        &["declares"],
        &["declaration"],
        &["declarations"],
        &["declining"],
        &["declining"],
        &["declaration"],
        &["declaration"],
    ],
    range: 2..=9,
};

static WORD_DECI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DECI_CHILDREN),
    value: None,
};

pub static WORD_DECI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aml"),
        dictgen::InsensitiveStr::Ascii("amls"),
        dictgen::InsensitiveStr::Ascii("ces"),
        dictgen::InsensitiveStr::Ascii("date"),
        dictgen::InsensitiveStr::Ascii("dated"),
        dictgen::InsensitiveStr::Ascii("dates"),
        dictgen::InsensitiveStr::Ascii("deable"),
        dictgen::InsensitiveStr::Ascii("dely"),
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("edd"),
        dictgen::InsensitiveStr::Ascii("ede"),
        dictgen::InsensitiveStr::Ascii("eded"),
        dictgen::InsensitiveStr::Ascii("edes"),
        dictgen::InsensitiveStr::Ascii("eding"),
        dictgen::InsensitiveStr::Ascii("eds"),
        dictgen::InsensitiveStr::Ascii("emal"),
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("eve"),
        dictgen::InsensitiveStr::Ascii("eved"),
        dictgen::InsensitiveStr::Ascii("eves"),
        dictgen::InsensitiveStr::Ascii("eving"),
        dictgen::InsensitiveStr::Ascii("fits"),
        dictgen::InsensitiveStr::Ascii("mials"),
        dictgen::InsensitiveStr::Ascii("ple"),
        dictgen::InsensitiveStr::Ascii("ples"),
        dictgen::InsensitiveStr::Ascii("pted"),
        dictgen::InsensitiveStr::Ascii("pting"),
        dictgen::InsensitiveStr::Ascii("ption"),
        dictgen::InsensitiveStr::Ascii("ptions"),
        dictgen::InsensitiveStr::Ascii("siones"),
        dictgen::InsensitiveStr::Ascii("sivie"),
        dictgen::InsensitiveStr::Ascii("son"),
        dictgen::InsensitiveStr::Ascii("ssion"),
    ],
    values: &[
        &["decimal"],
        &["decimals"],
        &["decides"],
        &["dedicate"],
        &["dedicated"],
        &["dedicates"],
        &["decidable"],
        &["decidedly"],
        &["decide"],
        &["decide", "decided"],
        &["decided"],
        &["decide"],
        &["decided"],
        &["decides"],
        &["deciding"],
        &["decides"],
        &["decimal"],
        &["decides"],
        &["deceive"],
        &["deceived"],
        &["deceives"],
        &["deceiving"],
        &["deficits"],
        &["decimals"],
        &["disciple"],
        &["disciples"],
        &["depicted"],
        &["depicting"],
        &["depiction"],
        &["depictions"],
        &["decisions"],
        &["decisive"],
        &["decision"],
        &["decision"],
    ],
    range: 1..=6,
};

static WORD_DECE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DECE_CHILDREN),
    value: None,
};

pub static WORD_DECE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ber"),
        dictgen::InsensitiveStr::Ascii("laration"),
        dictgen::InsensitiveStr::Ascii("larations"),
        dictgen::InsensitiveStr::Ascii("mbeard"),
        dictgen::InsensitiveStr::Ascii("mbre"),
        dictgen::InsensitiveStr::Ascii("mer"),
        dictgen::InsensitiveStr::Ascii("nd"),
        dictgen::InsensitiveStr::Ascii("ndant"),
        dictgen::InsensitiveStr::Ascii("ndants"),
        dictgen::InsensitiveStr::Ascii("ndend"),
        dictgen::InsensitiveStr::Ascii("ndent"),
        dictgen::InsensitiveStr::Ascii("ndentant"),
        dictgen::InsensitiveStr::Ascii("ndentants"),
        dictgen::InsensitiveStr::Ascii("ndents"),
        dictgen::InsensitiveStr::Ascii("nding"),
        dictgen::InsensitiveStr::Ascii("nsitized"),
        dictgen::InsensitiveStr::Ascii("ntraliced"),
        dictgen::InsensitiveStr::Ascii("ntrilized"),
        dictgen::InsensitiveStr::Ascii("ptionist"),
        dictgen::InsensitiveStr::Ascii("ptivley"),
        dictgen::InsensitiveStr::Ascii("rn"),
        dictgen::InsensitiveStr::Ascii("rned"),
        dictgen::InsensitiveStr::Ascii("rning"),
        dictgen::InsensitiveStr::Ascii("rns"),
    ],
    values: &[
        &["december"],
        &["deceleration", "declaration"],
        &["decelerations", "declarations"],
        &["december"],
        &["december"],
        &["december"],
        &["descend"],
        &["descendant"],
        &["descendants"],
        &["descendent", "descended"],
        &["descendent"],
        &["descendant"],
        &["descendants"],
        &["descendents"],
        &["descending"],
        &["desensitized"],
        &["decentralized"],
        &["decentralized"],
        &["receptionist"],
        &["deceptive"],
        &["discern"],
        &["discerned"],
        &["discerning"],
        &["discerns"],
    ],
    range: 2..=9,
};

static WORD_DECC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DECC_CHILDREN),
    value: None,
};

pub static WORD_DECC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("elerate"),
        dictgen::InsensitiveStr::Ascii("elerated"),
        dictgen::InsensitiveStr::Ascii("elerates"),
        dictgen::InsensitiveStr::Ascii("elerating"),
        dictgen::InsensitiveStr::Ascii("eleration"),
        dictgen::InsensitiveStr::Ascii("rement"),
        dictgen::InsensitiveStr::Ascii("remented"),
        dictgen::InsensitiveStr::Ascii("rements"),
    ],
    values: &[
        &["decelerate"],
        &["decelerated"],
        &["decelerates"],
        &["decelerating"],
        &["deceleration"],
        &["decrement"],
        &["decremented"],
        &["decrements"],
    ],
    range: 6..=9,
};

static WORD_DECA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DECA_CHILDREN),
    value: None,
};

pub static WORD_DECA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ffinated"),
        dictgen::InsensitiveStr::Ascii("lare"),
        dictgen::InsensitiveStr::Ascii("lared"),
        dictgen::InsensitiveStr::Ascii("lares"),
        dictgen::InsensitiveStr::Ascii("laring"),
        dictgen::InsensitiveStr::Ascii("lration"),
        dictgen::InsensitiveStr::Ascii("lrations"),
        dictgen::InsensitiveStr::Ascii("lratiosn"),
        dictgen::InsensitiveStr::Ascii("lre"),
        dictgen::InsensitiveStr::Ascii("lred"),
        dictgen::InsensitiveStr::Ascii("lres"),
        dictgen::InsensitiveStr::Ascii("lring"),
        dictgen::InsensitiveStr::Ascii("psulting"),
        dictgen::InsensitiveStr::Ascii("thalon"),
    ],
    values: &[
        &["decaffeinated"],
        &["declare"],
        &["declared"],
        &["declares"],
        &["declaring"],
        &["declaration"],
        &["declarations"],
        &["declarations"],
        &["declare"],
        &["declared"],
        &["declares"],
        &["declaring"],
        &["decapsulating"],
        &["decathlon"],
    ],
    range: 3..=8,
};

static WORD_DEB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DEB_CHILDREN),
    value: None,
};

pub static WORD_DEB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ain"),
        dictgen::InsensitiveStr::Ascii("ateable"),
        dictgen::InsensitiveStr::Ascii("buger"),
        dictgen::InsensitiveStr::Ascii("ehlper"),
        dictgen::InsensitiveStr::Ascii("gu"),
        dictgen::InsensitiveStr::Ascii("gug"),
        dictgen::InsensitiveStr::Ascii("guging"),
        dictgen::InsensitiveStr::Ascii("hlper"),
        dictgen::InsensitiveStr::Ascii("ia"),
        dictgen::InsensitiveStr::Ascii("iab"),
        dictgen::InsensitiveStr::Ascii("ina"),
        dictgen::InsensitiveStr::Ascii("loking"),
        dictgen::InsensitiveStr::Ascii("nia"),
        dictgen::InsensitiveStr::Ascii("ouce"),
        dictgen::InsensitiveStr::Ascii("ouced"),
        dictgen::InsensitiveStr::Ascii("ouces"),
        dictgen::InsensitiveStr::Ascii("oucing"),
        dictgen::InsensitiveStr::Ascii("th"),
        dictgen::InsensitiveStr::Ascii("ths"),
        dictgen::InsensitiveStr::Ascii("udg"),
        dictgen::InsensitiveStr::Ascii("udgged"),
        dictgen::InsensitiveStr::Ascii("udgger"),
        dictgen::InsensitiveStr::Ascii("udgging"),
        dictgen::InsensitiveStr::Ascii("udgs"),
        dictgen::InsensitiveStr::Ascii("uffes"),
        dictgen::InsensitiveStr::Ascii("ufffs"),
        dictgen::InsensitiveStr::Ascii("ufs"),
        dictgen::InsensitiveStr::Ascii("ugee"),
        dictgen::InsensitiveStr::Ascii("uger"),
        dictgen::InsensitiveStr::Ascii("ugg"),
        dictgen::InsensitiveStr::Ascii("uggg"),
        dictgen::InsensitiveStr::Ascii("uggge"),
        dictgen::InsensitiveStr::Ascii("uggged"),
        dictgen::InsensitiveStr::Ascii("ugggee"),
        dictgen::InsensitiveStr::Ascii("uggger"),
        dictgen::InsensitiveStr::Ascii("uggging"),
        dictgen::InsensitiveStr::Ascii("ugggs"),
        dictgen::InsensitiveStr::Ascii("uggin"),
        dictgen::InsensitiveStr::Ascii("ugginf"),
        dictgen::InsensitiveStr::Ascii("uggs"),
        dictgen::InsensitiveStr::Ascii("uging"),
    ],
    values: &[
        &["debian"],
        &["debatable"],
        &["debugger"],
        &["debhelper"],
        &["debug"],
        &["debug"],
        &["debugging"],
        &["debhelper"],
        &["debian"],
        &["debian"],
        &["debian"],
        &["deblocking"],
        &["debian"],
        &["debounce"],
        &["debounced"],
        &["debounces"],
        &["debouncing"],
        &["depth"],
        &["depths"],
        &["debug"],
        &["debugged"],
        &["debugger"],
        &["debugging"],
        &["debugs"],
        &["debuffs"],
        &["debuffs"],
        &["debugfs"],
        &["debuggee"],
        &["debugger"],
        &["debug"],
        &["debug"],
        &["debuggee"],
        &["debugged"],
        &["debuggee"],
        &["debugger"],
        &["debugging"],
        &["debugs"],
        &["debugging"],
        &["debugging"],
        &["debugs"],
        &["debugging"],
    ],
    range: 2..=7,
};

static WORD_DEA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_DEA_CHILDREN),
    value: None,
};

static WORD_DEA_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    Some(&WORD_DEAC_NODE),
    Some(&WORD_DEAD_NODE),
    Some(&WORD_DEAE_NODE),
    Some(&WORD_DEAF_NODE),
    None,
    Some(&WORD_DEAH_NODE),
    Some(&WORD_DEAI_NODE),
    None,
    Some(&WORD_DEAK_NODE),
    Some(&WORD_DEAL_NODE),
    Some(&WORD_DEAM_NODE),
    None,
    None,
    Some(&WORD_DEAP_NODE),
    None,
    None,
    Some(&WORD_DEAS_NODE),
    Some(&WORD_DEAT_NODE),
    Some(&WORD_DEAU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_DEAU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DEAU_CHILDREN),
    value: None,
};

pub static WORD_DEAU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("lt"),
        dictgen::InsensitiveStr::Ascii("lts"),
        dictgen::InsensitiveStr::Ascii("thenication"),
    ],
    values: &[&["default"], &["defaults"], &["deauthentication"]],
    range: 2..=11,
};

static WORD_DEAT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DEAT_CHILDREN),
    value: None,
};

pub static WORD_DEAT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ch"),
        dictgen::InsensitiveStr::Ascii("ched"),
        dictgen::InsensitiveStr::Ascii("ches"),
        dictgen::InsensitiveStr::Ascii("ching"),
        dictgen::InsensitiveStr::Ascii("hamtch"),
        dictgen::InsensitiveStr::Ascii("hcat"),
        dictgen::InsensitiveStr::Ascii("hmacth"),
        dictgen::InsensitiveStr::Ascii("hmath"),
        dictgen::InsensitiveStr::Ascii("il"),
        dictgen::InsensitiveStr::Ascii("iled"),
        dictgen::InsensitiveStr::Ascii("iling"),
        dictgen::InsensitiveStr::Ascii("ils"),
        dictgen::InsensitiveStr::Ascii("ivate"),
        dictgen::InsensitiveStr::Ascii("ivated"),
        dictgen::InsensitiveStr::Ascii("ivates"),
        dictgen::InsensitiveStr::Ascii("ivation"),
        dictgen::InsensitiveStr::Ascii("lhy"),
        dictgen::InsensitiveStr::Ascii("tach"),
        dictgen::InsensitiveStr::Ascii("tached"),
        dictgen::InsensitiveStr::Ascii("taches"),
        dictgen::InsensitiveStr::Ascii("taching"),
        dictgen::InsensitiveStr::Ascii("tachment"),
        dictgen::InsensitiveStr::Ascii("ure"),
    ],
    values: &[
        &["detach"],
        &["detached"],
        &["detaches"],
        &["detaching"],
        &["deathmatch"],
        &["deathmatch"],
        &["deathmatch"],
        &["deathmatch"],
        &["detail"],
        &["detailed"],
        &["detailing"],
        &["details"],
        &["deactivate"],
        &["deactivated"],
        &["deactivates"],
        &["deactivation"],
        &["deathly"],
        &["detach"],
        &["detached"],
        &["detaches"],
        &["detaching"],
        &["detachment"],
        &["feature"],
    ],
    range: 2..=8,
};

static WORD_DEAS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DEAS_CHILDREN),
    value: None,
};

pub static WORD_DEAS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("sering")],
    values: &[&["deasserting"]],
    range: 6..=6,
};

static WORD_DEAP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DEAP_CHILDREN),
    value: None,
};

pub static WORD_DEAP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("th"),
        dictgen::InsensitiveStr::Ascii("ths"),
    ],
    values: &[&["depth"], &["depths"]],
    range: 2..=3,
};

static WORD_DEAM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DEAM_CHILDREN),
    value: None,
};

pub static WORD_DEAM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("and"),
        dictgen::InsensitiveStr::Ascii("anding"),
        dictgen::InsensitiveStr::Ascii("ands"),
        dictgen::InsensitiveStr::Ascii("bigate"),
        dictgen::InsensitiveStr::Ascii("bigates"),
        dictgen::InsensitiveStr::Ascii("bigation"),
        dictgen::InsensitiveStr::Ascii("biguage"),
        dictgen::InsensitiveStr::Ascii("biguages"),
        dictgen::InsensitiveStr::Ascii("biguate"),
        dictgen::InsensitiveStr::Ascii("biguates"),
        dictgen::InsensitiveStr::Ascii("biguation"),
        dictgen::InsensitiveStr::Ascii("enor"),
        dictgen::InsensitiveStr::Ascii("iguate"),
        dictgen::InsensitiveStr::Ascii("iguates"),
        dictgen::InsensitiveStr::Ascii("iguation"),
        dictgen::InsensitiveStr::Ascii("on"),
        dictgen::InsensitiveStr::Ascii("onified"),
        dictgen::InsensitiveStr::Ascii("onisation"),
        dictgen::InsensitiveStr::Ascii("onise"),
        dictgen::InsensitiveStr::Ascii("onised"),
        dictgen::InsensitiveStr::Ascii("onises"),
        dictgen::InsensitiveStr::Ascii("onising"),
        dictgen::InsensitiveStr::Ascii("onization"),
        dictgen::InsensitiveStr::Ascii("onize"),
        dictgen::InsensitiveStr::Ascii("onized"),
        dictgen::InsensitiveStr::Ascii("onizes"),
        dictgen::InsensitiveStr::Ascii("onizing"),
        dictgen::InsensitiveStr::Ascii("ons"),
    ],
    values: &[
        &["demand"],
        &["demanding"],
        &["demands"],
        &["disambiguate"],
        &["disambiguates"],
        &["disambiguation"],
        &["disambiguate"],
        &["disambiguates"],
        &["disambiguate"],
        &["disambiguates"],
        &["disambiguation"],
        &["demeanor"],
        &["disambiguate"],
        &["disambiguates"],
        &["disambiguation"],
        &["daemon"],
        &["daemonised", "daemonized"],
        &["daemonisation"],
        &["daemonise"],
        &["daemonised"],
        &["daemonises"],
        &["daemonising"],
        &["daemonization"],
        &["daemonize"],
        &["daemonized"],
        &["daemonizes"],
        &["daemonizing"],
        &["daemons"],
    ],
    range: 2..=9,
};

static WORD_DEAL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DEAL_CHILDREN),
    value: None,
};

pub static WORD_DEAL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("erhsip"),
        dictgen::InsensitiveStr::Ascii("ershits"),
        dictgen::InsensitiveStr::Ascii("ershp"),
        dictgen::InsensitiveStr::Ascii("ilng"),
        dictgen::InsensitiveStr::Ascii("loacte"),
        dictgen::InsensitiveStr::Ascii("locaed"),
        dictgen::InsensitiveStr::Ascii("ocate"),
        dictgen::InsensitiveStr::Ascii("te"),
        dictgen::InsensitiveStr::Ascii("ying"),
    ],
    values: &[
        &["dealt"],
        &["dealerships"],
        &["dealerships"],
        &["dealerships"],
        &["dealing"],
        &["deallocate"],
        &["deallocated"],
        &["deallocate"],
        &["delete"],
        &["delaying"],
    ],
    range: 2..=7,
};

static WORD_DEAK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DEAK_CHILDREN),
    value: None,
};

pub static WORD_DEAK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("tivate"),
        dictgen::InsensitiveStr::Ascii("tivated"),
    ],
    values: &[&["deactivate"], &["deactivated"]],
    range: 6..=7,
};

static WORD_DEAI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DEAI_CHILDREN),
    value: None,
};

pub static WORD_DEAI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("l"),
        dictgen::InsensitiveStr::Ascii("ling"),
    ],
    values: &[&["deal"], &["dealing"]],
    range: 1..=4,
};

static WORD_DEAH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DEAH_CHILDREN),
    value: None,
};

pub static WORD_DEAH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("tly")],
    values: &[&["deathly"]],
    range: 3..=3,
};

static WORD_DEAF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DEAF_CHILDREN),
    value: None,
};

pub static WORD_DEAF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ault"),
        dictgen::InsensitiveStr::Ascii("eted"),
        dictgen::InsensitiveStr::Ascii("ualt"),
        dictgen::InsensitiveStr::Ascii("ualts"),
        dictgen::InsensitiveStr::Ascii("ult"),
        dictgen::InsensitiveStr::Ascii("ulted"),
        dictgen::InsensitiveStr::Ascii("ults"),
    ],
    values: &[
        &["default"],
        &["defeated"],
        &["default"],
        &["defaults"],
        &["default"],
        &["defaulted"],
        &["defaults"],
    ],
    range: 3..=5,
};

static WORD_DEAE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DEAE_CHILDREN),
    value: None,
};

pub static WORD_DEAE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("mon")],
    values: &[&["daemon"]],
    range: 3..=3,
};

static WORD_DEAD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DEAD_CHILDREN),
    value: None,
};

pub static WORD_DEAD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("lfit"),
        dictgen::InsensitiveStr::Ascii("lfits"),
        dictgen::InsensitiveStr::Ascii("lifs"),
        dictgen::InsensitiveStr::Ascii("lifters"),
        dictgen::InsensitiveStr::Ascii("lit"),
        dictgen::InsensitiveStr::Ascii("pol"),
        dictgen::InsensitiveStr::Ascii("poool"),
    ],
    values: &[
        &["deadlift"],
        &["deadlifts"],
        &["deadlifts"],
        &["deadlifts"],
        &["deadlift"],
        &["deadpool"],
        &["deadpool"],
    ],
    range: 3..=7,
};

static WORD_DEAC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DEAC_CHILDREN),
    value: None,
};

pub static WORD_DEAC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("itivation"),
        dictgen::InsensitiveStr::Ascii("itvated"),
        dictgen::InsensitiveStr::Ascii("riptor"),
        dictgen::InsensitiveStr::Ascii("riptors"),
        dictgen::InsensitiveStr::Ascii("tivatiion"),
        dictgen::InsensitiveStr::Ascii("tive"),
        dictgen::InsensitiveStr::Ascii("tiveate"),
        dictgen::InsensitiveStr::Ascii("tived"),
        dictgen::InsensitiveStr::Ascii("tivete"),
        dictgen::InsensitiveStr::Ascii("tiveted"),
        dictgen::InsensitiveStr::Ascii("tivetes"),
        dictgen::InsensitiveStr::Ascii("tiviate"),
        dictgen::InsensitiveStr::Ascii("tiviates"),
        dictgen::InsensitiveStr::Ascii("tiving"),
    ],
    values: &[
        &["deactivation"],
        &["deactivated"],
        &["decryptor", "descriptor"],
        &["decryptors", "descriptors"],
        &["deactivation"],
        &["deactivate"],
        &["deactivate"],
        &["deactivated"],
        &["deactivate"],
        &["deactivated"],
        &["deactivates"],
        &["deactivate"],
        &["deactivates"],
        &["deactivating"],
    ],
    range: 4..=9,
};

static WORD_DD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DD_CHILDREN),
    value: None,
};

pub static WORD_DD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("elete"),
        dictgen::InsensitiveStr::Ascii("ivision"),
        dictgen::InsensitiveStr::Ascii("ogers"),
        dictgen::InsensitiveStr::Ascii("oging"),
        dictgen::InsensitiveStr::Ascii("ons"),
    ],
    values: &[
        &["delete"],
        &["division"],
        &["dodgers"],
        &["dodging"],
        &["addons"],
    ],
    range: 3..=7,
};

static WORD_DC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DC_CHILDREN),
    value: None,
};

pub static WORD_DC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("hp"),
        dictgen::InsensitiveStr::Ascii("ok"),
        dictgen::InsensitiveStr::Ascii("oked"),
        dictgen::InsensitiveStr::Ascii("oker"),
        dictgen::InsensitiveStr::Ascii("okerd"),
        dictgen::InsensitiveStr::Ascii("oking"),
        dictgen::InsensitiveStr::Ascii("oks"),
        dictgen::InsensitiveStr::Ascii("ument"),
        dictgen::InsensitiveStr::Ascii("umented"),
        dictgen::InsensitiveStr::Ascii("umenting"),
        dictgen::InsensitiveStr::Ascii("uments"),
    ],
    values: &[
        &["dhcp"],
        &["dock"],
        &["docked"],
        &["docker"],
        &["dockerd", "docked", "docker"],
        &["docking"],
        &["docks"],
        &["document"],
        &["documented"],
        &["documenting"],
        &["documents"],
    ],
    range: 2..=8,
};

static WORD_DB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DB_CHILDREN),
    value: None,
};

pub static WORD_DB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("eian")],
    values: &[&["debian"]],
    range: 4..=4,
};

static WORD_DA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_DA_CHILDREN),
    value: None,
};

static WORD_DA_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_DAA_NODE),
    Some(&WORD_DAB_NODE),
    Some(&WORD_DAC_NODE),
    Some(&WORD_DAD_NODE),
    Some(&WORD_DAE_NODE),
    Some(&WORD_DAF_NODE),
    Some(&WORD_DAG_NODE),
    Some(&WORD_DAH_NODE),
    Some(&WORD_DAI_NODE),
    None,
    Some(&WORD_DAK_NODE),
    Some(&WORD_DAL_NODE),
    Some(&WORD_DAM_NODE),
    Some(&WORD_DAN_NODE),
    None,
    Some(&WORD_DAP_NODE),
    None,
    Some(&WORD_DAR_NODE),
    Some(&WORD_DAS_NODE),
    Some(&WORD_DAT_NODE),
    Some(&WORD_DAU_NODE),
    Some(&WORD_DAV_NODE),
    Some(&WORD_DAW_NODE),
    None,
    Some(&WORD_DAY_NODE),
    None,
];

static WORD_DAY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DAY_CHILDREN),
    value: None,
};

pub static WORD_DAY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("bue")],
    values: &[&["debut"]],
    range: 3..=3,
};

static WORD_DAW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DAW_CHILDREN),
    value: None,
};

pub static WORD_DAW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("rves")],
    values: &[&["dwarves"]],
    range: 4..=4,
};

static WORD_DAV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DAV_CHILDREN),
    value: None,
};

pub static WORD_DAV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("antage")],
    values: &[&["advantage"]],
    range: 6..=6,
};

static WORD_DAU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DAU_CHILDREN),
    value: None,
};

pub static WORD_DAU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("gher"),
        dictgen::InsensitiveStr::Ascii("gther"),
        dictgen::InsensitiveStr::Ascii("gthers"),
        dictgen::InsensitiveStr::Ascii("lity"),
    ],
    values: &[&["daughter"], &["daughter"], &["daughters"], &["duality"]],
    range: 4..=6,
};

static WORD_DAT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DAT_CHILDREN),
    value: None,
};

pub static WORD_DAT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("abaase"),
        dictgen::InsensitiveStr::Ascii("abaases"),
        dictgen::InsensitiveStr::Ascii("abae"),
        dictgen::InsensitiveStr::Ascii("abaes"),
        dictgen::InsensitiveStr::Ascii("abaeses"),
        dictgen::InsensitiveStr::Ascii("abas"),
        dictgen::InsensitiveStr::Ascii("abasse"),
        dictgen::InsensitiveStr::Ascii("absae"),
        dictgen::InsensitiveStr::Ascii("absaes"),
        dictgen::InsensitiveStr::Ascii("abse"),
        dictgen::InsensitiveStr::Ascii("abses"),
        dictgen::InsensitiveStr::Ascii("adsir"),
        dictgen::InsensitiveStr::Ascii("aet"),
        dictgen::InsensitiveStr::Ascii("aets"),
        dictgen::InsensitiveStr::Ascii("as"),
        dictgen::InsensitiveStr::Ascii("astrcuture"),
        dictgen::InsensitiveStr::Ascii("astrcutures"),
        dictgen::InsensitiveStr::Ascii("astrem"),
        dictgen::InsensitiveStr::Ascii("atbase"),
        dictgen::InsensitiveStr::Ascii("atbases"),
        dictgen::InsensitiveStr::Ascii("atgram"),
        dictgen::InsensitiveStr::Ascii("atgrams"),
        dictgen::InsensitiveStr::Ascii("atore"),
        dictgen::InsensitiveStr::Ascii("atores"),
        dictgen::InsensitiveStr::Ascii("atpe"),
        dictgen::InsensitiveStr::Ascii("atpes"),
        dictgen::InsensitiveStr::Ascii("atpye"),
        dictgen::InsensitiveStr::Ascii("atpyes"),
        dictgen::InsensitiveStr::Ascii("atset"),
        dictgen::InsensitiveStr::Ascii("atsets"),
        dictgen::InsensitiveStr::Ascii("atstructure"),
        dictgen::InsensitiveStr::Ascii("atstructures"),
        dictgen::InsensitiveStr::Ascii("attype"),
        dictgen::InsensitiveStr::Ascii("attypes"),
        dictgen::InsensitiveStr::Ascii("atye"),
        dictgen::InsensitiveStr::Ascii("atyep"),
        dictgen::InsensitiveStr::Ascii("atyepe"),
        dictgen::InsensitiveStr::Ascii("atyepes"),
        dictgen::InsensitiveStr::Ascii("atyeps"),
        dictgen::InsensitiveStr::Ascii("atyes"),
        dictgen::InsensitiveStr::Ascii("atyoe"),
        dictgen::InsensitiveStr::Ascii("atyoes"),
        dictgen::InsensitiveStr::Ascii("atytpe"),
        dictgen::InsensitiveStr::Ascii("atytpes"),
        dictgen::InsensitiveStr::Ascii("aum"),
        dictgen::InsensitiveStr::Ascii("base"),
        dictgen::InsensitiveStr::Ascii("bases"),
        dictgen::InsensitiveStr::Ascii("ea"),
        dictgen::InsensitiveStr::Ascii("ecreatedd"),
        dictgen::InsensitiveStr::Ascii("ection"),
        dictgen::InsensitiveStr::Ascii("ections"),
        dictgen::InsensitiveStr::Ascii("ee"),
        dictgen::InsensitiveStr::Ascii("eset"),
        dictgen::InsensitiveStr::Ascii("esets"),
        dictgen::InsensitiveStr::Ascii("set"),
        dictgen::InsensitiveStr::Ascii("sets"),
        dictgen::InsensitiveStr::Ascii("y"),
    ],
    values: &[
        &["database"],
        &["databases"],
        &["database"],
        &["database"],
        &["databases"],
        &["database"],
        &["database", "databases"],
        &["database"],
        &["databases"],
        &["database"],
        &["databases"],
        &["datadir"],
        &["dataset"],
        &["datasets"],
        &["data"],
        &["datastructure"],
        &["datastructures"],
        &["datastream"],
        &["database"],
        &["databases"],
        &["datagram"],
        &["datagrams"],
        &["datastore"],
        &["datastores"],
        &["datatype"],
        &["datatypes"],
        &["datatype"],
        &["datatypes"],
        &["dataset"],
        &["datasets"],
        &["datastructure"],
        &["datastructures"],
        &["datatype"],
        &["datatypes"],
        &["datatype"],
        &["datatype"],
        &["datatype"],
        &["datatypes"],
        &["datatypes"],
        &["datatypes"],
        &["datatype"],
        &["datatypes"],
        &["datatype"],
        &["datatypes"],
        &["datum"],
        &["database"],
        &["databases"],
        &["date", "data"],
        &["datecreated"],
        &["detection"],
        &["detections"],
        &["date"],
        &["dataset"],
        &["datasets"],
        &["dataset"],
        &["datasets"],
        &["data", "date"],
    ],
    range: 1..=12,
};

static WORD_DAS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DAS_CHILDREN),
    value: None,
};

pub static WORD_DAS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("board"),
        dictgen::InsensitiveStr::Ascii("boards"),
        dictgen::InsensitiveStr::Ascii("dot"),
        dictgen::InsensitiveStr::Ascii("hbaord"),
        dictgen::InsensitiveStr::Ascii("hbaords"),
        dictgen::InsensitiveStr::Ascii("hboad"),
        dictgen::InsensitiveStr::Ascii("hboads"),
        dictgen::InsensitiveStr::Ascii("hboar"),
        dictgen::InsensitiveStr::Ascii("hboars"),
        dictgen::InsensitiveStr::Ascii("hbord"),
        dictgen::InsensitiveStr::Ascii("hbords"),
        dictgen::InsensitiveStr::Ascii("hs"),
        dictgen::InsensitiveStr::Ascii("pora"),
        dictgen::InsensitiveStr::Ascii("poras"),
        dictgen::InsensitiveStr::Ascii("y"),
    ],
    values: &[
        &["dashboard"],
        &["dashboards"],
        &["dashdot"],
        &["dashboard"],
        &["dashboards"],
        &["dashboard"],
        &["dashboards"],
        &["dashboard"],
        &["dashboards"],
        &["dashboard"],
        &["dashboards"],
        &["dashes"],
        &["diaspora"],
        &["diasporas"],
        &["daisy", "dash", "days", "easy"],
    ],
    range: 1..=7,
};

static WORD_DAR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DAR_CHILDREN),
    value: None,
};

pub static WORD_DAR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cula"),
        dictgen::InsensitiveStr::Ascii("denelles"),
        dictgen::InsensitiveStr::Ascii("gons"),
        dictgen::InsensitiveStr::Ascii("kenss"),
        dictgen::InsensitiveStr::Ascii("kets"),
        dictgen::InsensitiveStr::Ascii("ma"),
        dictgen::InsensitiveStr::Ascii("nkess"),
    ],
    values: &[
        &["dracula"],
        &["dardanelles"],
        &["dragons"],
        &["darkness"],
        &["darkest"],
        &["dharma"],
        &["darkness"],
    ],
    range: 2..=8,
};

static WORD_DAP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DAP_CHILDREN),
    value: None,
};

pub static WORD_DAP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("licating")],
    values: &[&["duplicating"]],
    range: 8..=8,
};

static WORD_DAN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DAN_CHILDREN),
    value: None,
};

pub static WORD_DAN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ceing"),
        dictgen::InsensitiveStr::Ascii("didates"),
        dictgen::InsensitiveStr::Ascii("gereous"),
        dictgen::InsensitiveStr::Ascii("geros"),
        dictgen::InsensitiveStr::Ascii("geroulsy"),
        dictgen::InsensitiveStr::Ascii("gerouly"),
        dictgen::InsensitiveStr::Ascii("gerousely"),
        dictgen::InsensitiveStr::Ascii("geroys"),
        dictgen::InsensitiveStr::Ascii("gerus"),
    ],
    values: &[
        &["dancing"],
        &["candidates"],
        &["dangerous"],
        &["dangers"],
        &["dangerously"],
        &["dangerously"],
        &["dangerously"],
        &["dangerously"],
        &["dangers"],
    ],
    range: 5..=9,
};

static WORD_DAM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DAM_CHILDREN),
    value: None,
};

pub static WORD_DAM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("amge"),
        dictgen::InsensitiveStr::Ascii("amged"),
        dictgen::InsensitiveStr::Ascii("amges"),
        dictgen::InsensitiveStr::Ascii("amging"),
        dictgen::InsensitiveStr::Ascii("ange"),
        dictgen::InsensitiveStr::Ascii("anged"),
        dictgen::InsensitiveStr::Ascii("anges"),
        dictgen::InsensitiveStr::Ascii("anging"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("enor"),
        dictgen::InsensitiveStr::Ascii("eon"),
        dictgen::InsensitiveStr::Ascii("ge"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("mage"),
        dictgen::InsensitiveStr::Ascii("mages"),
        dictgen::InsensitiveStr::Ascii("on"),
        dictgen::InsensitiveStr::Ascii("ons"),
    ],
    values: &[
        &["damage"],
        &["damaged"],
        &["damages"],
        &["damaging"],
        &["damage"],
        &["damaged"],
        &["damages"],
        &["damaging"],
        &["damned", "damped", "domed", "gamed"],
        &["demeanor"],
        &["daemon", "demon", "damien"],
        &["damage"],
        &["damning", "damping", "doming", "gaming"],
        &["damage"],
        &["damages"],
        &["daemon", "demon"],
        &["daemons", "demons"],
    ],
    range: 2..=6,
};

static WORD_DAL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DAL_CHILDREN),
    value: None,
};

pub static WORD_DAL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("egate"),
        dictgen::InsensitiveStr::Ascii("mation"),
        dictgen::InsensitiveStr::Ascii("ta"),
    ],
    values: &[&["delegate"], &["dalmatian"], &["delta"]],
    range: 2..=6,
};

static WORD_DAK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DAK_CHILDREN),
    value: None,
};

pub static WORD_DAK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("e")],
    values: &[&["take"]],
    range: 1..=1,
};

static WORD_DAI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DAI_CHILDREN),
    value: None,
};

pub static WORD_DAI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("mond"),
        dictgen::InsensitiveStr::Ascii("monds"),
        dictgen::InsensitiveStr::Ascii("ta"),
    ],
    values: &[&["diamond"], &["diamonds"], &["data"]],
    range: 2..=5,
};

static WORD_DAH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DAH_CHILDREN),
    value: None,
};

pub static WORD_DAH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("sboard")],
    values: &[&["dashboard"]],
    range: 6..=6,
};

static WORD_DAG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DAG_CHILDREN),
    value: None,
};

pub static WORD_DAG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ners")],
    values: &[&["dangers"]],
    range: 4..=4,
};

static WORD_DAF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DAF_CHILDREN),
    value: None,
};

pub static WORD_DAF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ault"),
        dictgen::InsensitiveStr::Ascii("aults"),
        dictgen::InsensitiveStr::Ascii("aut"),
        dictgen::InsensitiveStr::Ascii("ualt"),
        dictgen::InsensitiveStr::Ascii("ualted"),
        dictgen::InsensitiveStr::Ascii("ualts"),
    ],
    values: &[
        &["default"],
        &["defaults"],
        &["default"],
        &["default"],
        &["defaulted"],
        &["defaults"],
    ],
    range: 3..=6,
};

static WORD_DAE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DAE_CHILDREN),
    value: None,
};

pub static WORD_DAE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("d"),
        dictgen::InsensitiveStr::Ascii("l"),
        dictgen::InsensitiveStr::Ascii("monified"),
    ],
    values: &[
        &["dead"],
        &["deal", "dial", "dahl"],
        &["daemonised", "daemonized"],
    ],
    range: 1..=8,
};

static WORD_DAD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DAD_CHILDREN),
    value: None,
};

pub static WORD_DAD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("lock")],
    values: &[&["deadlock"]],
    range: 4..=4,
};

static WORD_DAC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DAC_CHILDREN),
    value: None,
};

pub static WORD_DAC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("kery"),
        dictgen::InsensitiveStr::Ascii("laration"),
        dictgen::InsensitiveStr::Ascii("quiri"),
    ],
    values: &[&["daiquiri"], &["declaration"], &["daiquiri"]],
    range: 4..=8,
};

static WORD_DAB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DAB_CHILDREN),
    value: None,
};

pub static WORD_DAB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ase"),
        dictgen::InsensitiveStr::Ascii("ilitating"),
        dictgen::InsensitiveStr::Ascii("ree"),
        dictgen::InsensitiveStr::Ascii("ue"),
    ],
    values: &[&["database"], &["debilitating"], &["debris"], &["debut"]],
    range: 2..=9,
};

static WORD_DAA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_DAA_CHILDREN),
    value: Some(&["data"]),
};

pub static WORD_DAA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[],
    values: &[],
    range: 0..=0,
};

static WORD_C_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_C_CHILDREN),
    value: None,
};

static WORD_C_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_CA_NODE),
    None,
    Some(&WORD_CC_NODE),
    Some(&WORD_CD_NODE),
    Some(&WORD_CE_NODE),
    None,
    Some(&WORD_CG_NODE),
    Some(&WORD_CH_NODE),
    Some(&WORD_CI_NODE),
    Some(&WORD_CJ_NODE),
    Some(&WORD_CK_NODE),
    Some(&WORD_CL_NODE),
    Some(&WORD_CM_NODE),
    Some(&WORD_CN_NODE),
    Some(&WORD_CO_NODE),
    Some(&WORD_CP_NODE),
    None,
    Some(&WORD_CR_NODE),
    Some(&WORD_CS_NODE),
    Some(&WORD_CT_NODE),
    Some(&WORD_CU_NODE),
    Some(&WORD_CV_NODE),
    None,
    Some(&WORD_CX_NODE),
    Some(&WORD_CY_NODE),
    None,
];

static WORD_CY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CY_CHILDREN),
    value: None,
};

pub static WORD_CY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("andie"),
        dictgen::InsensitiveStr::Ascii("cic"),
        dictgen::InsensitiveStr::Ascii("clinder"),
        dictgen::InsensitiveStr::Ascii("clinders"),
        dictgen::InsensitiveStr::Ascii("clistes"),
        dictgen::InsensitiveStr::Ascii("clits"),
        dictgen::InsensitiveStr::Ascii("cloen"),
        dictgen::InsensitiveStr::Ascii("colps"),
        dictgen::InsensitiveStr::Ascii("cular"),
        dictgen::InsensitiveStr::Ascii("gin"),
        dictgen::InsensitiveStr::Ascii("lces"),
        dictgen::InsensitiveStr::Ascii("lcic"),
        dictgen::InsensitiveStr::Ascii("lcical"),
        dictgen::InsensitiveStr::Ascii("lcist"),
        dictgen::InsensitiveStr::Ascii("lcists"),
        dictgen::InsensitiveStr::Ascii("lcone"),
        dictgen::InsensitiveStr::Ascii("lcops"),
        dictgen::InsensitiveStr::Ascii("le"),
        dictgen::InsensitiveStr::Ascii("lic"),
        dictgen::InsensitiveStr::Ascii("lider"),
        dictgen::InsensitiveStr::Ascii("liders"),
        dictgen::InsensitiveStr::Ascii("lidner"),
        dictgen::InsensitiveStr::Ascii("lindical"),
        dictgen::InsensitiveStr::Ascii("lindre"),
        dictgen::InsensitiveStr::Ascii("lindres"),
        dictgen::InsensitiveStr::Ascii("llinder"),
        dictgen::InsensitiveStr::Ascii("llinders"),
        dictgen::InsensitiveStr::Ascii("lnder"),
        dictgen::InsensitiveStr::Ascii("lnders"),
        dictgen::InsensitiveStr::Ascii("lynders"),
        dictgen::InsensitiveStr::Ascii("mk"),
        dictgen::InsensitiveStr::Ascii("mptum"),
        dictgen::InsensitiveStr::Ascii("mptumatic"),
        dictgen::InsensitiveStr::Ascii("mptumatically"),
        dictgen::InsensitiveStr::Ascii("mptumaticaly"),
        dictgen::InsensitiveStr::Ascii("mptumaticlly"),
        dictgen::InsensitiveStr::Ascii("mptumaticly"),
        dictgen::InsensitiveStr::Ascii("mptums"),
        dictgen::InsensitiveStr::Ascii("naide"),
        dictgen::InsensitiveStr::Ascii("nicisim"),
        dictgen::InsensitiveStr::Ascii("nisicm"),
        dictgen::InsensitiveStr::Ascii("phersuite"),
        dictgen::InsensitiveStr::Ascii("phersuites"),
        dictgen::InsensitiveStr::Ascii("phertext"),
        dictgen::InsensitiveStr::Ascii("phertexts"),
        dictgen::InsensitiveStr::Ascii("prt"),
        dictgen::InsensitiveStr::Ascii("prtic"),
        dictgen::InsensitiveStr::Ascii("prto"),
        dictgen::InsensitiveStr::Ascii("rllic"),
        dictgen::InsensitiveStr::Ascii("rptic"),
        dictgen::InsensitiveStr::Ascii("rpto"),
        dictgen::InsensitiveStr::Ascii("rrent"),
        dictgen::InsensitiveStr::Ascii("rrilic"),
        dictgen::InsensitiveStr::Ascii("rstal"),
        dictgen::InsensitiveStr::Ascii("rstalline"),
        dictgen::InsensitiveStr::Ascii("rstallisation"),
        dictgen::InsensitiveStr::Ascii("rstallise"),
        dictgen::InsensitiveStr::Ascii("rstallization"),
        dictgen::InsensitiveStr::Ascii("rstallize"),
        dictgen::InsensitiveStr::Ascii("rstals"),
        dictgen::InsensitiveStr::Ascii("rto"),
        dictgen::InsensitiveStr::Ascii("wgin"),
    ],
    values: &[
        &["cyanide"],
        &["cyclic"],
        &["cylinder"],
        &["cylinders"],
        &["cyclists"],
        &["cyclist"],
        &["cyclone"],
        &["cyclops"],
        &["circular"],
        &["cygwin"],
        &["cycles"],
        &["cyclic"],
        &["cyclical"],
        &["cyclist"],
        &["cyclists"],
        &["cyclone"],
        &["cyclops"],
        &["cycle"],
        &["cyclic"],
        &["cylinder"],
        &["cylinders"],
        &["cylinder"],
        &["cylindrical"],
        &["cylinder"],
        &["cylinders"],
        &["cylinder"],
        &["cylinders"],
        &["cylinder"],
        &["cylinders"],
        &["cylinders"],
        &["cmyk"],
        &["symptom"],
        &["symptomatic"],
        &["symptomatically"],
        &["symptomatically"],
        &["symptomatically"],
        &["symptomatically"],
        &["symptoms"],
        &["cyanide"],
        &["cynicism"],
        &["cynicism"],
        &["ciphersuite"],
        &["ciphersuites"],
        &["ciphertext"],
        &["ciphertexts"],
        &["crypt"],
        &["cryptic"],
        &["crypto"],
        &["cyrillic"],
        &["cryptic"],
        &["crypto"],
        &["current"],
        &["cyrillic"],
        &["crystal"],
        &["crystalline"],
        &["crystallisation"],
        &["crystallise"],
        &["crystallization"],
        &["crystallize"],
        &["crystals"],
        &["crypto"],
        &["cygwin"],
    ],
    range: 2..=13,
};

static WORD_CX_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CX_CHILDREN),
    value: None,
};

pub static WORD_CX_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("an")],
    values: &[&["cyan"]],
    range: 2..=2,
};

static WORD_CV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CV_CHILDREN),
    value: None,
};

pub static WORD_CV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ignore")],
    values: &[&["cvsignore"]],
    range: 6..=6,
};

static WORD_CU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_CU_CHILDREN),
    value: None,
};

static WORD_CU_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_CUA_NODE),
    Some(&WORD_CUB_NODE),
    None,
    Some(&WORD_CUD_NODE),
    Some(&WORD_CUE_NODE),
    None,
    None,
    None,
    Some(&WORD_CUI_NODE),
    None,
    None,
    Some(&WORD_CUL_NODE),
    Some(&WORD_CUM_NODE),
    Some(&WORD_CUN_NODE),
    None,
    Some(&WORD_CUP_NODE),
    None,
    Some(&WORD_CUR_NODE),
    Some(&WORD_CUS_NODE),
    Some(&WORD_CUT_NODE),
    Some(&WORD_CUU_NODE),
    Some(&WORD_CUV_NODE),
    None,
    None,
    None,
    Some(&WORD_CUZ_NODE),
];

static WORD_CUZ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CUZ_CHILDREN),
    value: None,
};

pub static WORD_CUZ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("tomizable"),
        dictgen::InsensitiveStr::Ascii("tomization"),
        dictgen::InsensitiveStr::Ascii("tomizations"),
        dictgen::InsensitiveStr::Ascii("tomize"),
        dictgen::InsensitiveStr::Ascii("tomized"),
        dictgen::InsensitiveStr::Ascii("tomizer"),
        dictgen::InsensitiveStr::Ascii("tomizers"),
        dictgen::InsensitiveStr::Ascii("tomizes"),
        dictgen::InsensitiveStr::Ascii("tomizing"),
    ],
    values: &[
        &["customizable"],
        &["customization"],
        &["customizations"],
        &["customize"],
        &["customized"],
        &["customizer"],
        &["customizers"],
        &["customizes"],
        &["customizing"],
    ],
    range: 6..=11,
};

static WORD_CUV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CUV_CHILDREN),
    value: None,
};

pub static WORD_CUV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("re"),
        dictgen::InsensitiveStr::Ascii("res"),
    ],
    values: &[
        &["curves", "cubes", "caves"],
        &["curve", "cover"],
        &["curves", "covers"],
    ],
    range: 2..=3,
};

static WORD_CUU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CUU_CHILDREN),
    value: None,
};

pub static WORD_CUU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("rently"),
        dictgen::InsensitiveStr::Ascii("rrent"),
        dictgen::InsensitiveStr::Ascii("rrents"),
    ],
    values: &[&["currently"], &["current"], &["currents"]],
    range: 5..=6,
};

static WORD_CUT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CUT_CHILDREN),
    value: None,
};

pub static WORD_CUT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("om"),
        dictgen::InsensitiveStr::Ascii("sceen"),
        dictgen::InsensitiveStr::Ascii("sceens"),
        dictgen::InsensitiveStr::Ascii("scence"),
        dictgen::InsensitiveStr::Ascii("scences"),
        dictgen::InsensitiveStr::Ascii("scens"),
        dictgen::InsensitiveStr::Ascii("scenses"),
        dictgen::InsensitiveStr::Ascii("sence"),
        dictgen::InsensitiveStr::Ascii("sences"),
        dictgen::InsensitiveStr::Ascii("som"),
        dictgen::InsensitiveStr::Ascii("ted"),
    ],
    values: &[
        &["cut", "cute", "cuter"],
        &["custom"],
        &["cutscene"],
        &["cutscenes"],
        &["cutscene"],
        &["cutscene"],
        &["cutscenes"],
        &["cutscene"],
        &["cutscene"],
        &["cutscenes"],
        &["custom"],
        &["cut", "cutter", "gutted"],
    ],
    range: 2..=7,
};

static WORD_CUS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_CUS_CHILDREN),
    value: None,
};

static WORD_CUS_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_CUSH_NODE),
    Some(&WORD_CUSI_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_CUSO_NODE),
    None,
    None,
    None,
    Some(&WORD_CUSS_NODE),
    Some(&WORD_CUST_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_CUST_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_CUST_CHILDREN),
    value: None,
};

static WORD_CUST_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_CUSTA_NODE),
    None,
    Some(&WORD_CUSTC_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_CUSTI_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_CUSTO_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_CUSTU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_CUSTU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CUSTU_CHILDREN),
    value: None,
};

pub static WORD_CUSTU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("m"),
        dictgen::InsensitiveStr::Ascii("mer"),
        dictgen::InsensitiveStr::Ascii("mised"),
        dictgen::InsensitiveStr::Ascii("mizable"),
        dictgen::InsensitiveStr::Ascii("mization"),
        dictgen::InsensitiveStr::Ascii("mized"),
        dictgen::InsensitiveStr::Ascii("ms"),
    ],
    values: &[
        &["custom"],
        &["customer"],
        &["customised"],
        &["customizable"],
        &["customization"],
        &["customized"],
        &["customs"],
    ],
    range: 1..=8,
};

static WORD_CUSTO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CUSTO_CHILDREN),
    value: None,
};

pub static WORD_CUSTO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("isable"),
        dictgen::InsensitiveStr::Ascii("isation"),
        dictgen::InsensitiveStr::Ascii("ise"),
        dictgen::InsensitiveStr::Ascii("ised"),
        dictgen::InsensitiveStr::Ascii("iser"),
        dictgen::InsensitiveStr::Ascii("isers"),
        dictgen::InsensitiveStr::Ascii("ising"),
        dictgen::InsensitiveStr::Ascii("izable"),
        dictgen::InsensitiveStr::Ascii("ization"),
        dictgen::InsensitiveStr::Ascii("ize"),
        dictgen::InsensitiveStr::Ascii("ized"),
        dictgen::InsensitiveStr::Ascii("izer"),
        dictgen::InsensitiveStr::Ascii("izers"),
        dictgen::InsensitiveStr::Ascii("izing"),
        dictgen::InsensitiveStr::Ascii("mable"),
        dictgen::InsensitiveStr::Ascii("me"),
        dictgen::InsensitiveStr::Ascii("micable"),
        dictgen::InsensitiveStr::Ascii("mie"),
        dictgen::InsensitiveStr::Ascii("mied"),
        dictgen::InsensitiveStr::Ascii("misaton"),
        dictgen::InsensitiveStr::Ascii("misatons"),
        dictgen::InsensitiveStr::Ascii("mizabe"),
        dictgen::InsensitiveStr::Ascii("mizaton"),
        dictgen::InsensitiveStr::Ascii("mizatons"),
        dictgen::InsensitiveStr::Ascii("mizble"),
        dictgen::InsensitiveStr::Ascii("mizeable"),
        dictgen::InsensitiveStr::Ascii("mizeble"),
        dictgen::InsensitiveStr::Ascii("mizible"),
        dictgen::InsensitiveStr::Ascii("mn"),
        dictgen::InsensitiveStr::Ascii("mns"),
        dictgen::InsensitiveStr::Ascii("msied"),
        dictgen::InsensitiveStr::Ascii("mzied"),
        dictgen::InsensitiveStr::Ascii("n"),
        dictgen::InsensitiveStr::Ascii("nary"),
        dictgen::InsensitiveStr::Ascii("ner"),
        dictgen::InsensitiveStr::Ascii("ners"),
        dictgen::InsensitiveStr::Ascii("nisable"),
        dictgen::InsensitiveStr::Ascii("nisation"),
        dictgen::InsensitiveStr::Ascii("nise"),
        dictgen::InsensitiveStr::Ascii("nised"),
        dictgen::InsensitiveStr::Ascii("niser"),
        dictgen::InsensitiveStr::Ascii("nisers"),
        dictgen::InsensitiveStr::Ascii("nising"),
        dictgen::InsensitiveStr::Ascii("nizable"),
        dictgen::InsensitiveStr::Ascii("nization"),
        dictgen::InsensitiveStr::Ascii("nize"),
        dictgen::InsensitiveStr::Ascii("nized"),
        dictgen::InsensitiveStr::Ascii("nizer"),
        dictgen::InsensitiveStr::Ascii("nizers"),
        dictgen::InsensitiveStr::Ascii("nizing"),
        dictgen::InsensitiveStr::Ascii("ns"),
        dictgen::InsensitiveStr::Ascii("rmer"),
    ],
    values: &[
        &["customisable"],
        &["customisation"],
        &["customise"],
        &["customised"],
        &["customiser"],
        &["customisers"],
        &["customising"],
        &["customizable"],
        &["customization"],
        &["customize"],
        &["customized"],
        &["customizer"],
        &["customizers"],
        &["customizing"],
        &["customizable"],
        &["custom", "customs", "costume", "customer"],
        &["customisable", "customizable"],
        &["customize"],
        &["customized"],
        &["customisation"],
        &["customisations"],
        &["customizable"],
        &["customization"],
        &["customizations"],
        &["customizable"],
        &["customizable"],
        &["customizable"],
        &["customizable"],
        &["custom"],
        &["customs"],
        &["customised"],
        &["customized"],
        &["custom"],
        &["customary"],
        &["customer"],
        &["customers"],
        &["customisable"],
        &["customisation"],
        &["customise"],
        &["customised"],
        &["customiser"],
        &["customisers"],
        &["customising"],
        &["customizable"],
        &["customization"],
        &["customize"],
        &["customized"],
        &["customizer"],
        &["customizers"],
        &["customizing"],
        &["customs"],
        &["customer"],
    ],
    range: 1..=8,
};

static WORD_CUSTI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CUSTI_CHILDREN),
    value: None,
};

pub static WORD_CUSTI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("mizable"),
        dictgen::InsensitiveStr::Ascii("mized"),
    ],
    values: &[&["customizable"], &["customized"]],
    range: 5..=7,
};

static WORD_CUSTC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CUSTC_CHILDREN),
    value: None,
};

pub static WORD_CUSTC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ene"),
        dictgen::InsensitiveStr::Ascii("enes"),
    ],
    values: &[&["cutscene"], &["cutscenes"]],
    range: 3..=4,
};

static WORD_CUSTA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CUSTA_CHILDREN),
    value: None,
};

pub static WORD_CUSTA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("mizable"),
        dictgen::InsensitiveStr::Ascii("mized"),
        dictgen::InsensitiveStr::Ascii("mizes"),
        dictgen::InsensitiveStr::Ascii("mizing"),
    ],
    values: &[
        &["customizable"],
        &["customized"],
        &["customizes"],
        &["customizing"],
    ],
    range: 5..=7,
};

static WORD_CUSS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CUSS_CHILDREN),
    value: None,
};

pub static WORD_CUSS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ess"),
        dictgen::InsensitiveStr::Ascii("tom"),
        dictgen::InsensitiveStr::Ascii("tomer"),
        dictgen::InsensitiveStr::Ascii("tomers"),
        dictgen::InsensitiveStr::Ascii("tomizable"),
        dictgen::InsensitiveStr::Ascii("tomization"),
        dictgen::InsensitiveStr::Ascii("tomize"),
        dictgen::InsensitiveStr::Ascii("tomized"),
        dictgen::InsensitiveStr::Ascii("toms"),
    ],
    values: &[
        &["success"],
        &["custom"],
        &["customer"],
        &["customers"],
        &["customizable"],
        &["customization"],
        &["customize"],
        &["customized"],
        &["customs"],
    ],
    range: 3..=10,
};

static WORD_CUSO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CUSO_CHILDREN),
    value: None,
};

pub static WORD_CUSO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("m"),
        dictgen::InsensitiveStr::Ascii("tm"),
    ],
    values: &[&["custom"], &["custom"]],
    range: 1..=2,
};

static WORD_CUSI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CUSI_CHILDREN),
    value: None,
};

pub static WORD_CUSI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ne"),
        dictgen::InsensitiveStr::Ascii("nes"),
    ],
    values: &[&["cuisine"], &["cuisines"]],
    range: 2..=3,
};

static WORD_CUSH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CUSH_CHILDREN),
    value: None,
};

pub static WORD_CUSH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("in"),
        dictgen::InsensitiveStr::Ascii("ins"),
    ],
    values: &[&["cushion"], &["cushions"]],
    range: 2..=3,
};

static WORD_CUR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_CUR_CHILDREN),
    value: None,
};

static WORD_CUR_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_CURA_NODE),
    None,
    Some(&WORD_CURC_NODE),
    None,
    Some(&WORD_CURE_NODE),
    None,
    None,
    None,
    Some(&WORD_CURI_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_CURN_NODE),
    None,
    None,
    None,
    Some(&WORD_CURR_NODE),
    Some(&WORD_CURS_NODE),
    Some(&WORD_CURT_NODE),
    None,
    Some(&WORD_CURV_NODE),
    None,
    None,
    None,
    None,
];

static WORD_CURV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CURV_CHILDREN),
    value: None,
};

pub static WORD_CURV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("asious"),
        dictgen::InsensitiveStr::Ascii("atrue"),
        dictgen::InsensitiveStr::Ascii("atrues"),
        dictgen::InsensitiveStr::Ascii("elinear"),
    ],
    values: &[
        &["curvacious"],
        &["curvature"],
        &["curvatures"],
        &["curvilinear"],
    ],
    range: 5..=7,
};

static WORD_CURT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CURT_CHILDREN),
    value: None,
};

pub static WORD_CURT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("esy"),
        dictgen::InsensitiveStr::Ascii("eus"),
        dictgen::InsensitiveStr::Ascii("eusly"),
        dictgen::InsensitiveStr::Ascii("ian"),
    ],
    values: &[
        &["courtesy", "curtsy"],
        &["courteous"],
        &["courteously"],
        &["curtain"],
    ],
    range: 3..=5,
};

static WORD_CURS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CURS_CHILDREN),
    value: None,
};

pub static WORD_CURS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ade"),
        dictgen::InsensitiveStr::Ascii("ader"),
        dictgen::InsensitiveStr::Ascii("aders"),
        dictgen::InsensitiveStr::Ascii("er"),
        dictgen::InsensitiveStr::Ascii("os"),
        dictgen::InsensitiveStr::Ascii("ot"),
        dictgen::InsensitiveStr::Ascii("ro"),
    ],
    values: &[
        &["crusade"],
        &["crusader"],
        &["crusaders"],
        &["cursor"],
        &["cursors", "cursor"],
        &["cursor"],
        &["cursor"],
    ],
    range: 2..=5,
};

static WORD_CURR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CURR_CHILDREN),
    value: None,
};

pub static WORD_CURR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ancies"),
        dictgen::InsensitiveStr::Ascii("ate"),
        dictgen::InsensitiveStr::Ascii("ecnies"),
        dictgen::InsensitiveStr::Ascii("ecny"),
        dictgen::InsensitiveStr::Ascii("ect"),
        dictgen::InsensitiveStr::Ascii("ected"),
        dictgen::InsensitiveStr::Ascii("ecting"),
        dictgen::InsensitiveStr::Ascii("ectly"),
        dictgen::InsensitiveStr::Ascii("ects"),
        dictgen::InsensitiveStr::Ascii("ecy"),
        dictgen::InsensitiveStr::Ascii("eent"),
        dictgen::InsensitiveStr::Ascii("eents"),
        dictgen::InsensitiveStr::Ascii("emt"),
        dictgen::InsensitiveStr::Ascii("emtly"),
        dictgen::InsensitiveStr::Ascii("emts"),
        dictgen::InsensitiveStr::Ascii("en"),
        dictgen::InsensitiveStr::Ascii("ence"),
        dictgen::InsensitiveStr::Ascii("enctly"),
        dictgen::InsensitiveStr::Ascii("enices"),
        dictgen::InsensitiveStr::Ascii("enlty"),
        dictgen::InsensitiveStr::Ascii("enly"),
        dictgen::InsensitiveStr::Ascii("ennt"),
        dictgen::InsensitiveStr::Ascii("enntly"),
        dictgen::InsensitiveStr::Ascii("ennts"),
        dictgen::InsensitiveStr::Ascii("ens"),
        dictgen::InsensitiveStr::Ascii("entfps"),
        dictgen::InsensitiveStr::Ascii("entl"),
        dictgen::InsensitiveStr::Ascii("entlly"),
        dictgen::InsensitiveStr::Ascii("entlys"),
        dictgen::InsensitiveStr::Ascii("entpos"),
        dictgen::InsensitiveStr::Ascii("entry"),
        dictgen::InsensitiveStr::Ascii("entusa"),
        dictgen::InsensitiveStr::Ascii("enty"),
        dictgen::InsensitiveStr::Ascii("eny"),
        dictgen::InsensitiveStr::Ascii("esponding"),
        dictgen::InsensitiveStr::Ascii("est"),
        dictgen::InsensitiveStr::Ascii("etly"),
        dictgen::InsensitiveStr::Ascii("etn"),
        dictgen::InsensitiveStr::Ascii("etnly"),
        dictgen::InsensitiveStr::Ascii("iculem"),
        dictgen::InsensitiveStr::Ascii("iculim"),
        dictgen::InsensitiveStr::Ascii("icullum"),
        dictgen::InsensitiveStr::Ascii("iculm"),
        dictgen::InsensitiveStr::Ascii("iences"),
        dictgen::InsensitiveStr::Ascii("ious"),
        dictgen::InsensitiveStr::Ascii("net"),
        dictgen::InsensitiveStr::Ascii("netly"),
        dictgen::InsensitiveStr::Ascii("nt"),
        dictgen::InsensitiveStr::Ascii("ntly"),
        dictgen::InsensitiveStr::Ascii("option"),
        dictgen::InsensitiveStr::Ascii("os"),
        dictgen::InsensitiveStr::Ascii("rency"),
        dictgen::InsensitiveStr::Ascii("rent"),
        dictgen::InsensitiveStr::Ascii("rently"),
        dictgen::InsensitiveStr::Ascii("uent"),
        dictgen::InsensitiveStr::Ascii("upt"),
        dictgen::InsensitiveStr::Ascii("uptable"),
        dictgen::InsensitiveStr::Ascii("upted"),
        dictgen::InsensitiveStr::Ascii("uptible"),
        dictgen::InsensitiveStr::Ascii("uption"),
        dictgen::InsensitiveStr::Ascii("uptions"),
        dictgen::InsensitiveStr::Ascii("upts"),
        dictgen::InsensitiveStr::Ascii("us"),
    ],
    values: &[
        &["currencies"],
        &["curate"],
        &["currencies"],
        &["currency"],
        &["correct", "current"],
        &["corrected"],
        &["correcting"],
        &["correctly", "currently"],
        &["corrects", "currents"],
        &["currency"],
        &["current"],
        &["currents"],
        &["current"],
        &["currently"],
        &["currents"],
        &["current"],
        &["currencies"],
        &["currency", "currently"],
        &["currencies"],
        &["currently"],
        &["currently"],
        &["current"],
        &["currently"],
        &["currents"],
        &["currents"],
        &["currents"],
        &["currently"],
        &["currently"],
        &["currents"],
        &["currents"],
        &["currently"],
        &["currents"],
        &["currently"],
        &["currency"],
        &["corresponding"],
        &["currents"],
        &["currently"],
        &["current"],
        &["currently"],
        &["curriculum"],
        &["curriculum"],
        &["curriculum"],
        &["curriculum"],
        &["currencies"],
        &["curious"],
        &["current"],
        &["currently"],
        &["current"],
        &["currently"],
        &["corruption"],
        &["cursor"],
        &["currency"],
        &["current"],
        &["currently"],
        &["current"],
        &["corrupt"],
        &["corruptible"],
        &["corrupted"],
        &["corruptible"],
        &["corruption"],
        &["corruptions"],
        &["corrupts"],
        &["cirrus"],
    ],
    range: 2..=9,
};

static WORD_CURN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CURN_CHILDREN),
    value: None,
};

pub static WORD_CURN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("el"),
        dictgen::InsensitiveStr::Ascii("els"),
        dictgen::InsensitiveStr::Ascii("ilinear"),
    ],
    values: &[&["colonel"], &["colonels"], &["curvilinear"]],
    range: 2..=7,
};

static WORD_CURI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CURI_CHILDREN),
    value: None,
};

pub static WORD_CURI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ocity"),
        dictgen::InsensitiveStr::Ascii("osly"),
        dictgen::InsensitiveStr::Ascii("ostiy"),
        dictgen::InsensitiveStr::Ascii("ousities"),
        dictgen::InsensitiveStr::Ascii("ousity"),
        dictgen::InsensitiveStr::Ascii("ser"),
        dictgen::InsensitiveStr::Ascii("sers"),
        dictgen::InsensitiveStr::Ascii("sing"),
        dictgen::InsensitiveStr::Ascii("soity"),
        dictgen::InsensitiveStr::Ascii("sve"),
    ],
    values: &[
        &["curiosity"],
        &["curiously"],
        &["curiosity"],
        &["curiosities"],
        &["curiosity"],
        &["cruiser"],
        &["cruisers"],
        &["cruising"],
        &["curiosity"],
        &["cursive"],
    ],
    range: 3..=8,
};

static WORD_CURE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CURE_CHILDREN),
    value: None,
};

pub static WORD_CURE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ful"),
        dictgen::InsensitiveStr::Ascii("fully"),
        dictgen::InsensitiveStr::Ascii("fuly"),
        dictgen::InsensitiveStr::Ascii("lty"),
        dictgen::InsensitiveStr::Ascii("nt"),
        dictgen::InsensitiveStr::Ascii("ntfilter"),
        dictgen::InsensitiveStr::Ascii("ntly"),
        dictgen::InsensitiveStr::Ascii("rnt"),
        dictgen::InsensitiveStr::Ascii("rntly"),
        dictgen::InsensitiveStr::Ascii("v"),
        dictgen::InsensitiveStr::Ascii("vd"),
        dictgen::InsensitiveStr::Ascii("vs"),
    ],
    values: &[
        &["careful"],
        &["carefully"],
        &["carefully"],
        &["cruelty"],
        &["current"],
        &["currentfilter"],
        &["currently"],
        &["current"],
        &["currently"],
        &["curve"],
        &["curved"],
        &["curves"],
    ],
    range: 1..=8,
};

static WORD_CURC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CURC_CHILDREN),
    value: None,
};

pub static WORD_CURC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("h"),
        dictgen::InsensitiveStr::Ascii("ial"),
        dictgen::InsensitiveStr::Ascii("ible"),
        dictgen::InsensitiveStr::Ascii("uit"),
        dictgen::InsensitiveStr::Ascii("uits"),
        dictgen::InsensitiveStr::Ascii("umcision"),
        dictgen::InsensitiveStr::Ascii("umference"),
        dictgen::InsensitiveStr::Ascii("umstance"),
        dictgen::InsensitiveStr::Ascii("umstances"),
        dictgen::InsensitiveStr::Ascii("umstantial"),
    ],
    values: &[
        &["course", "curse", "curve"],
        &["church"],
        &["crucial"],
        &["crucible"],
        &["circuit"],
        &["circuits"],
        &["circumcision"],
        &["circumference"],
        &["circumstance"],
        &["circumstances"],
        &["circumstantial"],
    ],
    range: 1..=10,
};

static WORD_CURA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CURA_CHILDREN),
    value: None,
};

pub static WORD_CURA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ge"),
        dictgen::InsensitiveStr::Ascii("geous"),
        dictgen::InsensitiveStr::Ascii("tin"),
        dictgen::InsensitiveStr::Ascii("ture"),
    ],
    values: &[&["courage"], &["courageous"], &["curtain"], &["curvature"]],
    range: 2..=5,
};

static WORD_CUP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CUP_CHILDREN),
    value: None,
};

pub static WORD_CUP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("baord"),
        dictgen::InsensitiveStr::Ascii("boad"),
        dictgen::InsensitiveStr::Ascii("borad"),
        dictgen::InsensitiveStr::Ascii("le"),
        dictgen::InsensitiveStr::Ascii("les"),
        dictgen::InsensitiveStr::Ascii("lrit"),
    ],
    values: &[
        &["cupboard"],
        &["cupboard"],
        &["cupboard"],
        &["couple"],
        &["couples"],
        &["culprit"],
    ],
    range: 2..=5,
};

static WORD_CUN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CUN_CHILDREN),
    value: None,
};

pub static WORD_CUN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("curency"),
        dictgen::InsensitiveStr::Ascii("taminated"),
        dictgen::InsensitiveStr::Ascii("ted"),
        dictgen::InsensitiveStr::Ascii("ter"),
        dictgen::InsensitiveStr::Ascii("terpart"),
        dictgen::InsensitiveStr::Ascii("ters"),
        dictgen::InsensitiveStr::Ascii("ting"),
    ],
    values: &[
        &["concurrency"],
        &["contaminated"],
        &["counted", "hunted"],
        &["counter", "hunter"],
        &["counterpart"],
        &["counters", "hunters"],
        &["counting", "hunting"],
    ],
    range: 3..=9,
};

static WORD_CUM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CUM_CHILDREN),
    value: None,
};

pub static WORD_CUM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("bersone"),
        dictgen::InsensitiveStr::Ascii("bursome"),
        dictgen::InsensitiveStr::Ascii("lative"),
        dictgen::InsensitiveStr::Ascii("mand"),
        dictgen::InsensitiveStr::Ascii("mulated"),
        dictgen::InsensitiveStr::Ascii("mulative"),
        dictgen::InsensitiveStr::Ascii("municate"),
        dictgen::InsensitiveStr::Ascii("polsory"),
        dictgen::InsensitiveStr::Ascii("pus"),
        dictgen::InsensitiveStr::Ascii("puses"),
        dictgen::InsensitiveStr::Ascii("ulatative"),
        dictgen::InsensitiveStr::Ascii("ulattive"),
        dictgen::InsensitiveStr::Ascii("ulitive"),
    ],
    values: &[
        &["cumbersome"],
        &["cumbersome"],
        &["cumulative"],
        &["command"],
        &["cumulated"],
        &["cumulative"],
        &["communicate"],
        &["compulsory"],
        &["compass"],
        &["compasses"],
        &["cumulative"],
        &["cumulative"],
        &["cumulative"],
    ],
    range: 3..=9,
};

static WORD_CUL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CUL_CHILDREN),
    value: None,
};

pub static WORD_CUL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("iminating"),
        dictgen::InsensitiveStr::Ascii("itvate"),
        dictgen::InsensitiveStr::Ascii("print"),
        dictgen::InsensitiveStr::Ascii("rpit"),
        dictgen::InsensitiveStr::Ascii("terally"),
        dictgen::InsensitiveStr::Ascii("tivative"),
        dictgen::InsensitiveStr::Ascii("trual"),
        dictgen::InsensitiveStr::Ascii("trually"),
        dictgen::InsensitiveStr::Ascii("turaly"),
        dictgen::InsensitiveStr::Ascii("turels"),
        dictgen::InsensitiveStr::Ascii("turs"),
        dictgen::InsensitiveStr::Ascii("umative"),
        dictgen::InsensitiveStr::Ascii("utral"),
        dictgen::InsensitiveStr::Ascii("utrally"),
    ],
    values: &[
        &["culminating"],
        &["cultivate"],
        &["culprit"],
        &["culprit"],
        &["culturally"],
        &["cultivate"],
        &["cultural"],
        &["culturally"],
        &["culturally"],
        &["cultures"],
        &["cultures"],
        &["cumulative"],
        &["cultural"],
        &["culturally"],
    ],
    range: 4..=9,
};

static WORD_CUI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CUI_CHILDREN),
    value: None,
};

pub static WORD_CUI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("leoga")],
    values: &[&["cuileog"]],
    range: 5..=5,
};

static WORD_CUE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CUE_CHILDREN),
    value: None,
};

pub static WORD_CUE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("stion"),
        dictgen::InsensitiveStr::Ascii("stionable"),
        dictgen::InsensitiveStr::Ascii("stioned"),
        dictgen::InsensitiveStr::Ascii("stions"),
    ],
    values: &[
        &["question"],
        &["questionable"],
        &["questioned"],
        &["questions"],
    ],
    range: 5..=9,
};

static WORD_CUD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CUD_CHILDREN),
    value: None,
};

pub static WORD_CUD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("dels"),
        dictgen::InsensitiveStr::Ascii("dleys"),
    ],
    values: &[&["cuddles"], &["cuddles"]],
    range: 4..=5,
};

static WORD_CUB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CUB_CHILDREN),
    value: None,
};

pub static WORD_CUB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("burd"),
        dictgen::InsensitiveStr::Ascii("burds"),
        dictgen::InsensitiveStr::Ascii("cile"),
        dictgen::InsensitiveStr::Ascii("ilce"),
        dictgen::InsensitiveStr::Ascii("poard"),
    ],
    values: &[
        &["cupboard"],
        &["cupboards"],
        &["cubicle"],
        &["cubicle"],
        &["cupboard"],
    ],
    range: 4..=5,
};

static WORD_CUA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CUA_CHILDREN),
    value: None,
};

pub static WORD_CUA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("casian"),
        dictgen::InsensitiveStr::Ascii("sality"),
        dictgen::InsensitiveStr::Ascii("sation"),
        dictgen::InsensitiveStr::Ascii("se"),
        dictgen::InsensitiveStr::Ascii("sed"),
        dictgen::InsensitiveStr::Ascii("ses"),
        dictgen::InsensitiveStr::Ascii("sing"),
        dictgen::InsensitiveStr::Ascii("tiously"),
    ],
    values: &[
        &["caucasian"],
        &["causality"],
        &["causation"],
        &["cause"],
        &["caused"],
        &["causes"],
        &["causing"],
        &["cautiously"],
    ],
    range: 2..=7,
};

static WORD_CT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CT_CHILDREN),
    value: None,
};

pub static WORD_CT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eate"),
        dictgen::InsensitiveStr::Ascii("eateing"),
        dictgen::InsensitiveStr::Ascii("eater"),
        dictgen::InsensitiveStr::Ascii("eates"),
        dictgen::InsensitiveStr::Ascii("eating"),
        dictgen::InsensitiveStr::Ascii("eation"),
        dictgen::InsensitiveStr::Ascii("eations"),
        dictgen::InsensitiveStr::Ascii("eator"),
        dictgen::InsensitiveStr::Ascii("hluhu"),
        dictgen::InsensitiveStr::Ascii("huhlu"),
        dictgen::InsensitiveStr::Ascii("hulhlu"),
        dictgen::InsensitiveStr::Ascii("hulluh"),
        dictgen::InsensitiveStr::Ascii("huluh"),
        dictgen::InsensitiveStr::Ascii("ificate"),
        dictgen::InsensitiveStr::Ascii("ificated"),
        dictgen::InsensitiveStr::Ascii("ificates"),
        dictgen::InsensitiveStr::Ascii("ification"),
        dictgen::InsensitiveStr::Ascii("uhlhu"),
    ],
    values: &[
        &["create"],
        &["creating"],
        &["creator"],
        &["creates"],
        &["creating"],
        &["creation"],
        &["creations"],
        &["creator"],
        &["cthulhu"],
        &["cthulhu"],
        &["cthulhu"],
        &["cthulhu"],
        &["cthulhu"],
        &["certificate"],
        &["certificated"],
        &["certificates"],
        &["certification"],
        &["cthulhu"],
    ],
    range: 4..=9,
};

static WORD_CS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CS_CHILDREN),
    value: None,
};

pub static WORD_CS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ae"),
        dictgen::InsensitiveStr::Ascii("aes"),
        dictgen::InsensitiveStr::Ascii("ses"),
    ],
    values: &[&["case"], &["cases"], &["cases"]],
    range: 2..=3,
};

static WORD_CR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_CR_CHILDREN),
    value: None,
};

static WORD_CR_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_CRA_NODE),
    None,
    None,
    None,
    Some(&WORD_CRE_NODE),
    None,
    None,
    Some(&WORD_CRH_NODE),
    Some(&WORD_CRI_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_CRO_NODE),
    Some(&WORD_CRP_NODE),
    None,
    Some(&WORD_CRR_NODE),
    Some(&WORD_CRS_NODE),
    Some(&WORD_CRT_NODE),
    Some(&WORD_CRU_NODE),
    None,
    None,
    None,
    Some(&WORD_CRY_NODE),
    None,
];

static WORD_CRY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CRY_CHILDREN),
    value: None,
};

pub static WORD_CRY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("pitc"),
        dictgen::InsensitiveStr::Ascii("pric"),
        dictgen::InsensitiveStr::Ascii("pted"),
        dictgen::InsensitiveStr::Ascii("ptocraphic"),
        dictgen::InsensitiveStr::Ascii("ptograhic"),
        dictgen::InsensitiveStr::Ascii("ptographc"),
        dictgen::InsensitiveStr::Ascii("ptograpic"),
        dictgen::InsensitiveStr::Ascii("stalens"),
        dictgen::InsensitiveStr::Ascii("stalisation"),
        dictgen::InsensitiveStr::Ascii("stalisk"),
        dictgen::InsensitiveStr::Ascii("stallis"),
        dictgen::InsensitiveStr::Ascii("stalls"),
        dictgen::InsensitiveStr::Ascii("stalus"),
        dictgen::InsensitiveStr::Ascii("stalys"),
        dictgen::InsensitiveStr::Ascii("stas"),
        dictgen::InsensitiveStr::Ascii("stsl"),
        dictgen::InsensitiveStr::Ascii("to"),
        dictgen::InsensitiveStr::Ascii("topgraphic"),
        dictgen::InsensitiveStr::Ascii("tpic"),
        dictgen::InsensitiveStr::Ascii("tpo"),
        dictgen::InsensitiveStr::Ascii("tsal"),
    ],
    values: &[
        &["cryptic"],
        &["cryptic"],
        &["encrypted"],
        &["cryptographic"],
        &["cryptographic"],
        &["cryptographic"],
        &["cryptographic"],
        &["crystals"],
        &["crystallisation"],
        &["crystals"],
        &["crystals"],
        &["crystals"],
        &["crystals"],
        &["crystals"],
        &["crystals"],
        &["crystals"],
        &["crypto"],
        &["cryptographic"],
        &["cryptic"],
        &["crypto"],
        &["crystal"],
    ],
    range: 2..=11,
};

static WORD_CRU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CRU_CHILDREN),
    value: None,
};

pub static WORD_CRU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("asder"),
        dictgen::InsensitiveStr::Ascii("ciaal"),
        dictgen::InsensitiveStr::Ascii("cialy"),
        dictgen::InsensitiveStr::Ascii("cibe"),
        dictgen::InsensitiveStr::Ascii("cibel"),
        dictgen::InsensitiveStr::Ascii("cifiction"),
        dictgen::InsensitiveStr::Ascii("etly"),
        dictgen::InsensitiveStr::Ascii("ical"),
        dictgen::InsensitiveStr::Ascii("icble"),
        dictgen::InsensitiveStr::Ascii("lety"),
        dictgen::InsensitiveStr::Ascii("ncing"),
        dictgen::InsensitiveStr::Ascii("rrent"),
        dictgen::InsensitiveStr::Ascii("sdae"),
        dictgen::InsensitiveStr::Ascii("sdaer"),
        dictgen::InsensitiveStr::Ascii("sdaers"),
        dictgen::InsensitiveStr::Ascii("sier"),
        dictgen::InsensitiveStr::Ascii("siers"),
        dictgen::InsensitiveStr::Ascii("sies"),
        dictgen::InsensitiveStr::Ascii("siing"),
        dictgen::InsensitiveStr::Ascii("sive"),
        dictgen::InsensitiveStr::Ascii("sor"),
        dictgen::InsensitiveStr::Ascii("tchers"),
        dictgen::InsensitiveStr::Ascii("tchetts"),
        dictgen::InsensitiveStr::Ascii("tchs"),
        dictgen::InsensitiveStr::Ascii("thces"),
        dictgen::InsensitiveStr::Ascii("tial"),
        dictgen::InsensitiveStr::Ascii("tially"),
        dictgen::InsensitiveStr::Ascii("tialy"),
        dictgen::InsensitiveStr::Ascii("ze"),
        dictgen::InsensitiveStr::Ascii("zed"),
        dictgen::InsensitiveStr::Ascii("zer"),
        dictgen::InsensitiveStr::Ascii("zes"),
        dictgen::InsensitiveStr::Ascii("zing"),
    ],
    values: &[
        &["crusader"],
        &["crucial"],
        &["crucially"],
        &["crucible"],
        &["crucible"],
        &["crucifixion"],
        &["cruelty"],
        &["crucial"],
        &["crucible"],
        &["cruelty"],
        &["crunching"],
        &["current"],
        &["crusade"],
        &["crusader"],
        &["crusaders"],
        &["cruiser"],
        &["cruisers"],
        &["cruises"],
        &["cruising"],
        &["cursive"],
        &["cursor"],
        &["crutches"],
        &["crutches"],
        &["crutches"],
        &["crutches"],
        &["crucial"],
        &["crucially"],
        &["crucially"],
        &["cruise"],
        &["cruised"],
        &["cruiser"],
        &["cruises"],
        &["cruising"],
    ],
    range: 2..=9,
};

static WORD_CRT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CRT_CHILDREN),
    value: None,
};

pub static WORD_CRT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ical"),
        dictgen::InsensitiveStr::Ascii("ically"),
        dictgen::InsensitiveStr::Ascii("icals"),
        dictgen::InsensitiveStr::Ascii("icised"),
    ],
    values: &[
        &["critical"],
        &["critically"],
        &["criticals"],
        &["criticised"],
    ],
    range: 4..=6,
};

static WORD_CRS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CRS_CHILDREN),
    value: None,
};

pub static WORD_CRS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ytal"),
        dictgen::InsensitiveStr::Ascii("ytalline"),
        dictgen::InsensitiveStr::Ascii("ytallisation"),
        dictgen::InsensitiveStr::Ascii("ytallise"),
        dictgen::InsensitiveStr::Ascii("ytallization"),
        dictgen::InsensitiveStr::Ascii("ytallize"),
        dictgen::InsensitiveStr::Ascii("ytallographic"),
        dictgen::InsensitiveStr::Ascii("ytals"),
    ],
    values: &[
        &["crystal"],
        &["crystalline"],
        &["crystallisation"],
        &["crystallise"],
        &["crystallization"],
        &["crystallize"],
        &["crystallographic"],
        &["crystals"],
    ],
    range: 4..=13,
};

static WORD_CRR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CRR_CHILDREN),
    value: None,
};

pub static WORD_CRR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("espond")],
    values: &[&["correspond"]],
    range: 6..=6,
};

static WORD_CRP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CRP_CHILDREN),
    value: None,
};

pub static WORD_CRP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ytic")],
    values: &[&["cryptic"]],
    range: 4..=4,
};

static WORD_CRO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CRO_CHILDREN),
    value: None,
};

pub static WORD_CRO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("atioa"),
        dictgen::InsensitiveStr::Ascii("ch"),
        dictgen::InsensitiveStr::Ascii("ckadile"),
        dictgen::InsensitiveStr::Ascii("ckodiles"),
        dictgen::InsensitiveStr::Ascii("codille"),
        dictgen::InsensitiveStr::Ascii("codiller"),
        dictgen::InsensitiveStr::Ascii("codilule"),
        dictgen::InsensitiveStr::Ascii("nological"),
        dictgen::InsensitiveStr::Ascii("nologically"),
        dictgen::InsensitiveStr::Ascii("oz"),
        dictgen::InsensitiveStr::Ascii("ozed"),
        dictgen::InsensitiveStr::Ascii("ozer"),
        dictgen::InsensitiveStr::Ascii("ozes"),
        dictgen::InsensitiveStr::Ascii("ozing"),
        dictgen::InsensitiveStr::Ascii("poration"),
        dictgen::InsensitiveStr::Ascii("porations"),
        dictgen::InsensitiveStr::Ascii("ppped"),
        dictgen::InsensitiveStr::Ascii("pses"),
        dictgen::InsensitiveStr::Ascii("s"),
        dictgen::InsensitiveStr::Ascii("sair"),
        dictgen::InsensitiveStr::Ascii("shet"),
        dictgen::InsensitiveStr::Ascii("ssfie"),
        dictgen::InsensitiveStr::Ascii("ssfiter"),
        dictgen::InsensitiveStr::Ascii("ssfiters"),
        dictgen::InsensitiveStr::Ascii("ssgne"),
        dictgen::InsensitiveStr::Ascii("sshar"),
        dictgen::InsensitiveStr::Ascii("sshiar"),
        dictgen::InsensitiveStr::Ascii("ssifre"),
        dictgen::InsensitiveStr::Ascii("ssin"),
        dictgen::InsensitiveStr::Ascii("sspot"),
        dictgen::InsensitiveStr::Ascii("wbahr"),
        dictgen::InsensitiveStr::Ascii("wdsigna"),
        dictgen::InsensitiveStr::Ascii("wkay"),
        dictgen::InsensitiveStr::Ascii("wm"),
        dictgen::InsensitiveStr::Ascii("wshay"),
        dictgen::InsensitiveStr::Ascii("wshays"),
    ],
    values: &[
        &["croatia"],
        &["crotch"],
        &["crocodile"],
        &["crocodiles"],
        &["crocodile"],
        &["crocodile"],
        &["crocodile"],
        &["chronological"],
        &["chronologically"],
        &["cruise"],
        &["cruised"],
        &["cruiser"],
        &["cruises"],
        &["cruising"],
        &["corporation"],
        &["corporations"],
        &["cropped"],
        &["corpses"],
        &["cross"],
        &["corsair"],
        &["crochet"],
        &["crossfire"],
        &["crossfire"],
        &["crossfire"],
        &["crossgen"],
        &["crosshair"],
        &["crosshair"],
        &["crossfire"],
        &["crossing"],
        &["crosspost"],
        &["crowbar"],
        &["crowdsignal"],
        &["croquet"],
        &["crown"],
        &["crochet"],
        &["crochets"],
    ],
    range: 1..=11,
};

static WORD_CRI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_CRI_CHILDREN),
    value: None,
};

static WORD_CRI_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    Some(&WORD_CRIC_NODE),
    None,
    None,
    None,
    Some(&WORD_CRIG_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_CRIM_NODE),
    Some(&WORD_CRIN_NODE),
    None,
    Some(&WORD_CRIP_NODE),
    None,
    Some(&WORD_CRIR_NODE),
    None,
    Some(&WORD_CRIT_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_CRIT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_CRIT_CHILDREN),
    value: None,
};

static WORD_CRIT_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    Some(&WORD_CRITC_NODE),
    None,
    Some(&WORD_CRITE_NODE),
    None,
    None,
    None,
    Some(&WORD_CRITI_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_CRITQ_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_CRITQ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CRITQ_CHILDREN),
    value: None,
};

pub static WORD_CRITQ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ue"),
        dictgen::InsensitiveStr::Ascii("ued"),
        dictgen::InsensitiveStr::Ascii("uing"),
    ],
    values: &[&["critique"], &["critiqued"], &["critiquing"]],
    range: 2..=4,
};

static WORD_CRITI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CRITI_CHILDREN),
    value: None,
};

pub static WORD_CRITI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cable"),
        dictgen::InsensitiveStr::Ascii("call"),
        dictgen::InsensitiveStr::Ascii("callity"),
        dictgen::InsensitiveStr::Ascii("caly"),
        dictgen::InsensitiveStr::Ascii("carlo"),
        dictgen::InsensitiveStr::Ascii("cas"),
        dictgen::InsensitiveStr::Ascii("ces"),
        dictgen::InsensitiveStr::Ascii("cial"),
        dictgen::InsensitiveStr::Ascii("cially"),
        dictgen::InsensitiveStr::Ascii("cials"),
        dictgen::InsensitiveStr::Ascii("cicing"),
        dictgen::InsensitiveStr::Ascii("cie"),
        dictgen::InsensitiveStr::Ascii("cies"),
        dictgen::InsensitiveStr::Ascii("ciing"),
        dictgen::InsensitiveStr::Ascii("cim"),
        dictgen::InsensitiveStr::Ascii("cis"),
        dictgen::InsensitiveStr::Ascii("cisied"),
        dictgen::InsensitiveStr::Ascii("cisim"),
        dictgen::InsensitiveStr::Ascii("cisims"),
        dictgen::InsensitiveStr::Ascii("cisize"),
        dictgen::InsensitiveStr::Ascii("cisme"),
        dictgen::InsensitiveStr::Ascii("cisn"),
        dictgen::InsensitiveStr::Ascii("cisng"),
        dictgen::InsensitiveStr::Ascii("cists"),
        dictgen::InsensitiveStr::Ascii("cisze"),
        dictgen::InsensitiveStr::Ascii("ciszed"),
        dictgen::InsensitiveStr::Ascii("ciszing"),
        dictgen::InsensitiveStr::Ascii("cizms"),
        dictgen::InsensitiveStr::Ascii("cizng"),
        dictgen::InsensitiveStr::Ascii("cms"),
        dictgen::InsensitiveStr::Ascii("cos"),
        dictgen::InsensitiveStr::Ascii("cts"),
        dictgen::InsensitiveStr::Ascii("cus"),
        dictgen::InsensitiveStr::Ascii("era"),
        dictgen::InsensitiveStr::Ascii("ical"),
        dictgen::InsensitiveStr::Ascii("ically"),
        dictgen::InsensitiveStr::Ascii("icals"),
        dictgen::InsensitiveStr::Ascii("sice"),
        dictgen::InsensitiveStr::Ascii("siced"),
        dictgen::InsensitiveStr::Ascii("sicing"),
        dictgen::InsensitiveStr::Ascii("sicm"),
        dictgen::InsensitiveStr::Ascii("sicms"),
        dictgen::InsensitiveStr::Ascii("sicsm"),
        dictgen::InsensitiveStr::Ascii("sing"),
        dictgen::InsensitiveStr::Ascii("siscm"),
        dictgen::InsensitiveStr::Ascii("sising"),
        dictgen::InsensitiveStr::Ascii("sism"),
        dictgen::InsensitiveStr::Ascii("sisms"),
        dictgen::InsensitiveStr::Ascii("size"),
        dictgen::InsensitiveStr::Ascii("sized"),
        dictgen::InsensitiveStr::Ascii("sizes"),
        dictgen::InsensitiveStr::Ascii("sizing"),
        dictgen::InsensitiveStr::Ascii("sizms"),
        dictgen::InsensitiveStr::Ascii("zed"),
        dictgen::InsensitiveStr::Ascii("ziced"),
        dictgen::InsensitiveStr::Ascii("zicing"),
        dictgen::InsensitiveStr::Ascii("zing"),
        dictgen::InsensitiveStr::Ascii("zised"),
        dictgen::InsensitiveStr::Ascii("zising"),
        dictgen::InsensitiveStr::Ascii("zisms"),
        dictgen::InsensitiveStr::Ascii("zized"),
        dictgen::InsensitiveStr::Ascii("zizing"),
    ],
    values: &[
        &["critical"],
        &["critical", "critically"],
        &["critically"],
        &["critically"],
        &["critical"],
        &["critics"],
        &["critics"],
        &["critical"],
        &["critically"],
        &["criticals"],
        &["criticising"],
        &["criticise"],
        &["criticise"],
        &["criticising"],
        &["criticisms"],
        &["critics"],
        &["criticise"],
        &["criticism"],
        &["criticisms"],
        &["criticise"],
        &["criticise"],
        &["criticising"],
        &["criticising"],
        &["critics"],
        &["criticise"],
        &["criticise"],
        &["criticising"],
        &["criticisms"],
        &["criticizing"],
        &["critics"],
        &["critics"],
        &["critics"],
        &["critics"],
        &["criteria"],
        &["critical"],
        &["critically"],
        &["criticals"],
        &["criticise"],
        &["criticized"],
        &["criticizing"],
        &["criticism"],
        &["criticisms"],
        &["criticisms"],
        &["criticising"],
        &["criticisms"],
        &["criticising"],
        &["criticism"],
        &["criticisms"],
        &["criticize"],
        &["criticized"],
        &["criticizes"],
        &["criticizing"],
        &["criticisms"],
        &["criticized"],
        &["criticized"],
        &["criticizing"],
        &["criticizing"],
        &["criticised"],
        &["criticising"],
        &["criticisms"],
        &["criticized"],
        &["criticizing"],
    ],
    range: 3..=7,
};

static WORD_CRITE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CRITE_CHILDREN),
    value: None,
};

pub static WORD_CRITE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ak"),
        dictgen::InsensitiveStr::Ascii("ra"),
        dictgen::InsensitiveStr::Ascii("reon"),
        dictgen::InsensitiveStr::Ascii("rias"),
        dictgen::InsensitiveStr::Ascii("riom"),
    ],
    values: &[
        &["critique"],
        &["criteria"],
        &["criterion"],
        &["criteria"],
        &["criterion"],
    ],
    range: 2..=4,
};

static WORD_CRITC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CRITC_CHILDREN),
    value: None,
};

pub static WORD_CRITC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("al"),
        dictgen::InsensitiveStr::Ascii("ally"),
        dictgen::InsensitiveStr::Ascii("als"),
        dictgen::InsensitiveStr::Ascii("ial"),
        dictgen::InsensitiveStr::Ascii("ially"),
        dictgen::InsensitiveStr::Ascii("ials"),
    ],
    values: &[
        &["critical"],
        &["critically"],
        &["criticals"],
        &["critical"],
        &["critically"],
        &["criticals"],
    ],
    range: 2..=5,
};

static WORD_CRIR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CRIR_CHILDREN),
    value: None,
};

pub static WORD_CRIR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ical"),
        dictgen::InsensitiveStr::Ascii("ically"),
        dictgen::InsensitiveStr::Ascii("icals"),
    ],
    values: &[&["critical"], &["critically"], &["criticals"]],
    range: 4..=6,
};

static WORD_CRIP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CRIP_CHILDREN),
    value: None,
};

pub static WORD_CRIP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("ts"),
    ],
    values: &[&["crypt", "script"], &["crypts", "scripts"]],
    range: 1..=2,
};

static WORD_CRIN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CRIN_CHILDREN),
    value: None,
};

pub static WORD_CRIN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("gely"),
        dictgen::InsensitiveStr::Ascii("gery"),
        dictgen::InsensitiveStr::Ascii("gewhorty"),
        dictgen::InsensitiveStr::Ascii("geworhty"),
        dictgen::InsensitiveStr::Ascii("geworhy"),
        dictgen::InsensitiveStr::Ascii("geworthey"),
        dictgen::InsensitiveStr::Ascii("geworthly"),
        dictgen::InsensitiveStr::Ascii("geworty"),
        dictgen::InsensitiveStr::Ascii("gewothy"),
        dictgen::InsensitiveStr::Ascii("gewrothy"),
        dictgen::InsensitiveStr::Ascii("gyworthy"),
    ],
    values: &[
        &["cringey"],
        &["cringey"],
        &["cringeworthy"],
        &["cringeworthy"],
        &["cringeworthy"],
        &["cringeworthy"],
        &["cringeworthy"],
        &["cringeworthy"],
        &["cringeworthy"],
        &["cringeworthy"],
        &["cringeworthy"],
    ],
    range: 4..=9,
};

static WORD_CRIM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CRIM_CHILDREN),
    value: None,
};

pub static WORD_CRIM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("anally"),
        dictgen::InsensitiveStr::Ascii("inalty"),
        dictgen::InsensitiveStr::Ascii("inalul"),
        dictgen::InsensitiveStr::Ascii("inaly"),
    ],
    values: &[
        &["criminally"],
        &["criminally"],
        &["criminally"],
        &["criminally"],
    ],
    range: 5..=6,
};

static WORD_CRIG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CRIG_CHILDREN),
    value: None,
};

pub static WORD_CRIG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("neworthy")],
    values: &[&["cringeworthy"]],
    range: 8..=8,
};

static WORD_CRIC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CRIC_CHILDREN),
    value: None,
};

pub static WORD_CRIC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ital"),
        dictgen::InsensitiveStr::Ascii("itally"),
        dictgen::InsensitiveStr::Ascii("itals"),
        dictgen::InsensitiveStr::Ascii("itising"),
        dictgen::InsensitiveStr::Ascii("ketts"),
        dictgen::InsensitiveStr::Ascii("les"),
        dictgen::InsensitiveStr::Ascii("ling"),
        dictgen::InsensitiveStr::Ascii("ulating"),
        dictgen::InsensitiveStr::Ascii("umference"),
    ],
    values: &[
        &["critical"],
        &["critically"],
        &["criticals"],
        &["criticising"],
        &["crickets"],
        &["circles"],
        &["circling"],
        &["circulating"],
        &["circumference"],
    ],
    range: 3..=9,
};

static WORD_CRH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CRH_CHILDREN),
    value: None,
};

pub static WORD_CRH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("istmas")],
    values: &[&["christmas"]],
    range: 6..=6,
};

static WORD_CRE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_CRE_CHILDREN),
    value: None,
};

static WORD_CRE_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_CREA_NODE),
    None,
    None,
    Some(&WORD_CRED_NODE),
    Some(&WORD_CREE_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_CRES_NODE),
    Some(&WORD_CRET_NODE),
    Some(&WORD_CREU_NODE),
    None,
    Some(&WORD_CREW_NODE),
    None,
    None,
    None,
];

static WORD_CREW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CREW_CHILDREN),
    value: None,
};

pub static WORD_CREW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("sant")],
    values: &[&["croissant"]],
    range: 4..=4,
};

static WORD_CREU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CREU_CHILDREN),
    value: None,
};

pub static WORD_CREU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("lty")],
    values: &[&["cruelty"]],
    range: 3..=3,
};

static WORD_CRET_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CRET_CHILDREN),
    value: None,
};

pub static WORD_CRET_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ae"),
        dictgen::InsensitiveStr::Ascii("aed"),
        dictgen::InsensitiveStr::Ascii("aes"),
        dictgen::InsensitiveStr::Ascii("aing"),
        dictgen::InsensitiveStr::Ascii("ate"),
        dictgen::InsensitiveStr::Ascii("ated"),
        dictgen::InsensitiveStr::Ascii("ates"),
        dictgen::InsensitiveStr::Ascii("ating"),
        dictgen::InsensitiveStr::Ascii("ator"),
        dictgen::InsensitiveStr::Ascii("ators"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("eria"),
    ],
    values: &[
        &["create"],
        &["created"],
        &["creates"],
        &["creating"],
        &["create"],
        &["created"],
        &["creates"],
        &["creating"],
        &["creator"],
        &["creators"],
        &["created"],
        &["criteria"],
    ],
    range: 2..=5,
};

static WORD_CRES_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CRES_CHILDREN),
    value: None,
};

pub static WORD_CRES_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ent"),
        dictgen::InsensitiveStr::Ascii("h"),
        dictgen::InsensitiveStr::Ascii("its"),
    ],
    values: &[&["crescent"], &["crèche"], &["credits"]],
    range: 1..=3,
};

static WORD_CREE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CREE_CHILDREN),
    value: None,
};

pub static WORD_CREE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("dence"),
        dictgen::InsensitiveStr::Ascii("perest"),
        dictgen::InsensitiveStr::Ascii("pes"),
        dictgen::InsensitiveStr::Ascii("pgin"),
        dictgen::InsensitiveStr::Ascii("pig"),
    ],
    values: &[
        &["credence"],
        &["creepers"],
        &["creepers"],
        &["creeping"],
        &["creeping"],
    ],
    range: 3..=6,
};

static WORD_CRED_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CRED_CHILDREN),
    value: None,
};

pub static WORD_CRED_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ate"),
        dictgen::InsensitiveStr::Ascii("encials"),
        dictgen::InsensitiveStr::Ascii("entail"),
        dictgen::InsensitiveStr::Ascii("entails"),
        dictgen::InsensitiveStr::Ascii("entaisl"),
        dictgen::InsensitiveStr::Ascii("etial"),
        dictgen::InsensitiveStr::Ascii("etials"),
        dictgen::InsensitiveStr::Ascii("ibillity"),
        dictgen::InsensitiveStr::Ascii("ibilty"),
        dictgen::InsensitiveStr::Ascii("idential"),
        dictgen::InsensitiveStr::Ascii("identials"),
        dictgen::InsensitiveStr::Ascii("ientals"),
        dictgen::InsensitiveStr::Ascii("iential"),
        dictgen::InsensitiveStr::Ascii("intial"),
        dictgen::InsensitiveStr::Ascii("intials"),
        dictgen::InsensitiveStr::Ascii("is"),
        dictgen::InsensitiveStr::Ascii("ists"),
        dictgen::InsensitiveStr::Ascii("itted"),
        dictgen::InsensitiveStr::Ascii("netials"),
    ],
    values: &[
        &["created"],
        &["credentials"],
        &["credential"],
        &["credentials"],
        &["credentials"],
        &["credential"],
        &["credentials"],
        &["credibility"],
        &["credibility"],
        &["credential"],
        &["credentials"],
        &["credentials"],
        &["credential"],
        &["credential"],
        &["credentials"],
        &["credits"],
        &["credits"],
        &["credited"],
        &["credentials"],
    ],
    range: 2..=9,
};

static WORD_CREA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CREA_CHILDREN),
    value: None,
};

pub static WORD_CREA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ate"),
        dictgen::InsensitiveStr::Ascii("cionism"),
        dictgen::InsensitiveStr::Ascii("dential"),
        dictgen::InsensitiveStr::Ascii("dentialed"),
        dictgen::InsensitiveStr::Ascii("dentials"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("entials"),
        dictgen::InsensitiveStr::Ascii("eted"),
        dictgen::InsensitiveStr::Ascii("mic"),
        dictgen::InsensitiveStr::Ascii("soat"),
        dictgen::InsensitiveStr::Ascii("stor"),
        dictgen::InsensitiveStr::Ascii("tation"),
        dictgen::InsensitiveStr::Ascii("tea"),
        dictgen::InsensitiveStr::Ascii("teable"),
        dictgen::InsensitiveStr::Ascii("tedd"),
        dictgen::InsensitiveStr::Ascii("tein"),
        dictgen::InsensitiveStr::Ascii("teing"),
        dictgen::InsensitiveStr::Ascii("teive"),
        dictgen::InsensitiveStr::Ascii("ten"),
        dictgen::InsensitiveStr::Ascii("ter"),
        dictgen::InsensitiveStr::Ascii("ters"),
        dictgen::InsensitiveStr::Ascii("teur"),
        dictgen::InsensitiveStr::Ascii("tie"),
        dictgen::InsensitiveStr::Ascii("tien"),
        dictgen::InsensitiveStr::Ascii("tiong"),
        dictgen::InsensitiveStr::Ascii("tionis"),
        dictgen::InsensitiveStr::Ascii("tionisim"),
        dictgen::InsensitiveStr::Ascii("tionistas"),
        dictgen::InsensitiveStr::Ascii("tionkit"),
        dictgen::InsensitiveStr::Ascii("tionnism"),
        dictgen::InsensitiveStr::Ascii("tionnist"),
        dictgen::InsensitiveStr::Ascii("tionsim"),
        dictgen::InsensitiveStr::Ascii("tionsism"),
        dictgen::InsensitiveStr::Ascii("tionsist"),
        dictgen::InsensitiveStr::Ascii("tionsit"),
        dictgen::InsensitiveStr::Ascii("tionsits"),
        dictgen::InsensitiveStr::Ascii("tionsm"),
        dictgen::InsensitiveStr::Ascii("tionst"),
        dictgen::InsensitiveStr::Ascii("tionsts"),
        dictgen::InsensitiveStr::Ascii("tivelly"),
        dictgen::InsensitiveStr::Ascii("tivey"),
        dictgen::InsensitiveStr::Ascii("tivily"),
        dictgen::InsensitiveStr::Ascii("tivley"),
        dictgen::InsensitiveStr::Ascii("tning"),
        dictgen::InsensitiveStr::Ascii("tre"),
        dictgen::InsensitiveStr::Ascii("tred"),
        dictgen::InsensitiveStr::Ascii("ts"),
        dictgen::InsensitiveStr::Ascii("tue"),
    ],
    values: &[
        &["create"],
        &["creationism"],
        &["credential"],
        &["credentialed"],
        &["credentials"],
        &["created"],
        &["credentials"],
        &["created"],
        &["ceramic"],
        &["creosote"],
        &["creator"],
        &["creation"],
        &["create"],
        &["creatable"],
        &["created"],
        &["creatine"],
        &["creating"],
        &["creative"],
        &["creatine"],
        &["creature", "creator", "crater"],
        &["craters", "creators"],
        &["creature"],
        &["creatine"],
        &["creatine"],
        &["creation", "creating"],
        &["creations"],
        &["creationism"],
        &["creationists"],
        &["creationist"],
        &["creationism"],
        &["creationist"],
        &["creationism"],
        &["creationism"],
        &["creationist"],
        &["creationist"],
        &["creationists"],
        &["creationism"],
        &["creationist"],
        &["creationists"],
        &["creatively"],
        &["creatively"],
        &["creatively"],
        &["creatively"],
        &["creating"],
        &["create"],
        &["created"],
        &["creates"],
        &["creature"],
    ],
    range: 2..=9,
};

static WORD_CRA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CRA_CHILDREN),
    value: None,
};

pub static WORD_CRA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("bine"),
        dictgen::InsensitiveStr::Ascii("ce"),
        dictgen::InsensitiveStr::Ascii("ced"),
        dictgen::InsensitiveStr::Ascii("ceful"),
        dictgen::InsensitiveStr::Ascii("cefully"),
        dictgen::InsensitiveStr::Ascii("cefulness"),
        dictgen::InsensitiveStr::Ascii("celess"),
        dictgen::InsensitiveStr::Ascii("ces"),
        dictgen::InsensitiveStr::Ascii("ches"),
        dictgen::InsensitiveStr::Ascii("cing"),
        dictgen::InsensitiveStr::Ascii("ete"),
        dictgen::InsensitiveStr::Ascii("eted"),
        dictgen::InsensitiveStr::Ascii("etes"),
        dictgen::InsensitiveStr::Ascii("eting"),
        dictgen::InsensitiveStr::Ascii("etor"),
        dictgen::InsensitiveStr::Ascii("etors"),
        dictgen::InsensitiveStr::Ascii("hed"),
        dictgen::InsensitiveStr::Ascii("hes"),
        dictgen::InsensitiveStr::Ascii("hs"),
        dictgen::InsensitiveStr::Ascii("hses"),
        dictgen::InsensitiveStr::Ascii("lwed"),
        dictgen::InsensitiveStr::Ascii("mugin"),
        dictgen::InsensitiveStr::Ascii("mugins"),
        dictgen::InsensitiveStr::Ascii("nberrry"),
        dictgen::InsensitiveStr::Ascii("nbery"),
        dictgen::InsensitiveStr::Ascii("nkenstein"),
        dictgen::InsensitiveStr::Ascii("otia"),
        dictgen::InsensitiveStr::Ascii("penter"),
        dictgen::InsensitiveStr::Ascii("shaes"),
        dictgen::InsensitiveStr::Ascii("sheed"),
        dictgen::InsensitiveStr::Ascii("shees"),
        dictgen::InsensitiveStr::Ascii("shess"),
        dictgen::InsensitiveStr::Ascii("shign"),
        dictgen::InsensitiveStr::Ascii("shs"),
        dictgen::InsensitiveStr::Ascii("tashous"),
        dictgen::InsensitiveStr::Ascii("tion"),
        dictgen::InsensitiveStr::Ascii("tionalism"),
        dictgen::InsensitiveStr::Ascii("tionalist"),
        dictgen::InsensitiveStr::Ascii("tionalists"),
        dictgen::InsensitiveStr::Ascii("tionist"),
        dictgen::InsensitiveStr::Ascii("tionists"),
        dictgen::InsensitiveStr::Ascii("tions"),
        dictgen::InsensitiveStr::Ascii("weld"),
        dictgen::InsensitiveStr::Ascii("yones"),
    ],
    values: &[
        &["carbine"],
        &["grace", "crate"],
        &["graced"],
        &["graceful"],
        &["gracefully"],
        &["gracefulness"],
        &["graceless"],
        &["crates", "graces"],
        &["crashes", "caches", "crutches"],
        &["gracing"],
        &["create", "crate"],
        &["created", "crated"],
        &["crates", "creates"],
        &["creating", "crating"],
        &["crater", "creator"],
        &["craters", "creators"],
        &["crashed"],
        &["crashes"],
        &["crash", "crass"],
        &["crashes"],
        &["crawled"],
        &["curmudgeon"],
        &["curmudgeons"],
        &["cranberry"],
        &["cranberry"],
        &["frankenstein"],
        &["croatia"],
        &["carpenter"],
        &["crashes"],
        &["crashed"],
        &["crashes"],
        &["crashes"],
        &["crashing"],
        &["crashes"],
        &["cretaceous"],
        &["creation", "nation", "ration"],
        &["nationalism", "rationalism"],
        &["nationalist", "rationalist"],
        &["nationalists", "rationalists"],
        &["creationist"],
        &["creationists"],
        &["creations", "nations", "rations"],
        &["crawled"],
        &["crayons"],
    ],
    range: 2..=10,
};

static WORD_CP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CP_CHILDREN),
    value: None,
};

pub static WORD_CP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("acities"),
        dictgen::InsensitiveStr::Ascii("acity"),
        dictgen::InsensitiveStr::Ascii("atains"),
        dictgen::InsensitiveStr::Ascii("ation"),
        dictgen::InsensitiveStr::Ascii("check"),
        dictgen::InsensitiveStr::Ascii("ontent"),
        dictgen::InsensitiveStr::Ascii("oy"),
        dictgen::InsensitiveStr::Ascii("pp"),
        dictgen::InsensitiveStr::Ascii("tion"),
        dictgen::InsensitiveStr::Ascii("uld"),
    ],
    values: &[
        &["capacities"],
        &["capacity"],
        &["captains"],
        &["caption"],
        &["cppcheck"],
        &["content"],
        &["coy", "copy"],
        &["cpp"],
        &["caption", "option"],
        &["could"],
    ],
    range: 2..=7,
};

static WORD_CO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_CO_CHILDREN),
    value: None,
};

static WORD_CO_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_COA_NODE),
    Some(&WORD_COB_NODE),
    Some(&WORD_COC_NODE),
    Some(&WORD_COD_NODE),
    Some(&WORD_COE_NODE),
    Some(&WORD_COF_NODE),
    Some(&WORD_COG_NODE),
    Some(&WORD_COH_NODE),
    Some(&WORD_COI_NODE),
    None,
    Some(&WORD_COK_NODE),
    Some(&WORD_COL_NODE),
    Some(&WORD_COM_NODE),
    Some(&WORD_CON_NODE),
    Some(&WORD_COO_NODE),
    Some(&WORD_COP_NODE),
    None,
    Some(&WORD_COR_NODE),
    Some(&WORD_COS_NODE),
    Some(&WORD_COT_NODE),
    Some(&WORD_COU_NODE),
    Some(&WORD_COV_NODE),
    None,
    None,
    Some(&WORD_COY_NODE),
    None,
];

static WORD_COY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COY_CHILDREN),
    value: None,
};

pub static WORD_COY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("otees"),
        dictgen::InsensitiveStr::Ascii("p"),
        dictgen::InsensitiveStr::Ascii("pright"),
        dictgen::InsensitiveStr::Ascii("prighted"),
        dictgen::InsensitiveStr::Ascii("prights"),
        dictgen::InsensitiveStr::Ascii("right"),
        dictgen::InsensitiveStr::Ascii("righted"),
        dictgen::InsensitiveStr::Ascii("rights"),
        dictgen::InsensitiveStr::Ascii("toes"),
    ],
    values: &[
        &["coyotes"],
        &["copy"],
        &["copyright"],
        &["copyrighted"],
        &["copyrights"],
        &["copyright"],
        &["copyrighted"],
        &["copyrights"],
        &["coyotes"],
    ],
    range: 1..=8,
};

static WORD_COV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COV_CHILDREN),
    value: None,
};

pub static WORD_COV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("anent"),
        dictgen::InsensitiveStr::Ascii("arage"),
        dictgen::InsensitiveStr::Ascii("arages"),
        dictgen::InsensitiveStr::Ascii("arege"),
        dictgen::InsensitiveStr::Ascii("ection"),
        dictgen::InsensitiveStr::Ascii("enat"),
        dictgen::InsensitiveStr::Ascii("enental"),
        dictgen::InsensitiveStr::Ascii("ention"),
        dictgen::InsensitiveStr::Ascii("entions"),
        dictgen::InsensitiveStr::Ascii("erate"),
        dictgen::InsensitiveStr::Ascii("erd"),
        dictgen::InsensitiveStr::Ascii("ere"),
        dictgen::InsensitiveStr::Ascii("eres"),
        dictgen::InsensitiveStr::Ascii("erge"),
        dictgen::InsensitiveStr::Ascii("ergence"),
        dictgen::InsensitiveStr::Ascii("erges"),
        dictgen::InsensitiveStr::Ascii("erred"),
        dictgen::InsensitiveStr::Ascii("ersion"),
        dictgen::InsensitiveStr::Ascii("ersions"),
        dictgen::InsensitiveStr::Ascii("ersity"),
        dictgen::InsensitiveStr::Ascii("erted"),
        dictgen::InsensitiveStr::Ascii("erter"),
        dictgen::InsensitiveStr::Ascii("erters"),
        dictgen::InsensitiveStr::Ascii("erting"),
        dictgen::InsensitiveStr::Ascii("nersation"),
        dictgen::InsensitiveStr::Ascii("nersion"),
        dictgen::InsensitiveStr::Ascii("nert"),
        dictgen::InsensitiveStr::Ascii("nerted"),
        dictgen::InsensitiveStr::Ascii("nerter"),
        dictgen::InsensitiveStr::Ascii("nerters"),
        dictgen::InsensitiveStr::Ascii("nertible"),
        dictgen::InsensitiveStr::Ascii("nerting"),
        dictgen::InsensitiveStr::Ascii("nertor"),
        dictgen::InsensitiveStr::Ascii("nertors"),
        dictgen::InsensitiveStr::Ascii("nerts"),
        dictgen::InsensitiveStr::Ascii("riance"),
        dictgen::InsensitiveStr::Ascii("riate"),
        dictgen::InsensitiveStr::Ascii("riates"),
    ],
    values: &[
        &["covenant"],
        &["coverage"],
        &["coverages"],
        &["coverage"],
        &["convection"],
        &["covenant"],
        &["covenant"],
        &["convention"],
        &["conventions"],
        &["coverage"],
        &["covered"],
        &["cover"],
        &["covers"],
        &["coverage", "converge"],
        &["convergence"],
        &["coverages", "converges"],
        &["covered"],
        &["conversion"],
        &["conversions"],
        &["coverity"],
        &["converted", "covered", "coveted"],
        &["converter"],
        &["converters"],
        &["converting"],
        &["conservation"],
        &["conversion"],
        &["convert"],
        &["converted"],
        &["converter"],
        &["converters"],
        &["convertible"],
        &["converting"],
        &["convertor"],
        &["convertors"],
        &["converts"],
        &["covariance"],
        &["covariate"],
        &["covariates"],
    ],
    range: 3..=9,
};

static WORD_COU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_COU_CHILDREN),
    value: None,
};

static WORD_COU_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    Some(&WORD_COUC_NODE),
    Some(&WORD_COUD_NODE),
    None,
    None,
    Some(&WORD_COUG_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_COUL_NODE),
    Some(&WORD_COUM_NODE),
    Some(&WORD_COUN_NODE),
    None,
    None,
    None,
    Some(&WORD_COUR_NODE),
    Some(&WORD_COUS_NODE),
    Some(&WORD_COUT_NODE),
    Some(&WORD_COUU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_COUU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COUU_CHILDREN),
    value: None,
};

pub static WORD_COUU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ld")],
    values: &[&["could"]],
    range: 2..=2,
};

static WORD_COUT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COUT_CHILDREN),
    value: None,
};

pub static WORD_COUT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("er"),
        dictgen::InsensitiveStr::Ascii("ermeasuere"),
        dictgen::InsensitiveStr::Ascii("ermeasueres"),
        dictgen::InsensitiveStr::Ascii("ermeasure"),
        dictgen::InsensitiveStr::Ascii("ermeasures"),
        dictgen::InsensitiveStr::Ascii("erpart"),
        dictgen::InsensitiveStr::Ascii("ers"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("ner"),
        dictgen::InsensitiveStr::Ascii("neract"),
        dictgen::InsensitiveStr::Ascii("nered"),
        dictgen::InsensitiveStr::Ascii("nerfeit"),
        dictgen::InsensitiveStr::Ascii("nering"),
        dictgen::InsensitiveStr::Ascii("nerpart"),
        dictgen::InsensitiveStr::Ascii("nerparts"),
        dictgen::InsensitiveStr::Ascii("nerplay"),
        dictgen::InsensitiveStr::Ascii("nerpoint"),
        dictgen::InsensitiveStr::Ascii("nerproductive"),
        dictgen::InsensitiveStr::Ascii("ners"),
    ],
    values: &[
        &["counted"],
        &["counter"],
        &["countermeasure"],
        &["countermeasures"],
        &["countermeasure"],
        &["countermeasures"],
        &["counterpart"],
        &["counters", "routers", "scouters"],
        &["counting"],
        &["counter"],
        &["counteract"],
        &["countered"],
        &["counterfeit"],
        &["countering"],
        &["counterpart"],
        &["counterparts"],
        &["counterplay"],
        &["counterpoint"],
        &["counterproductive"],
        &["counters"],
    ],
    range: 2..=13,
};

static WORD_COUS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COUS_CHILDREN),
    value: None,
};

pub static WORD_COUS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("ines"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("ings"),
        dictgen::InsensitiveStr::Ascii("nelors"),
    ],
    values: &[
        &["course", "cause"],
        &["courses", "causes"],
        &["cousins"],
        &["cousin"],
        &["cousins"],
        &["counselors"],
    ],
    range: 1..=6,
};

static WORD_COUR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COUR_CHILDREN),
    value: None,
};

pub static WORD_COUR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ce"),
        dictgen::InsensitiveStr::Ascii("cework"),
        dictgen::InsensitiveStr::Ascii("ching"),
        dictgen::InsensitiveStr::Ascii("sefork"),
        dictgen::InsensitiveStr::Ascii("tesey"),
        dictgen::InsensitiveStr::Ascii("testy"),
        dictgen::InsensitiveStr::Ascii("tey"),
        dictgen::InsensitiveStr::Ascii("thosue"),
        dictgen::InsensitiveStr::Ascii("thourse"),
        dictgen::InsensitiveStr::Ascii("trom"),
        dictgen::InsensitiveStr::Ascii("trooom"),
        dictgen::InsensitiveStr::Ascii("tsey"),
        dictgen::InsensitiveStr::Ascii("urier"),
    ],
    values: &[
        &["course", "coerce", "source"],
        &["coursework"],
        &["crouching"],
        &["coursework"],
        &["courtesy"],
        &["courtesy"],
        &["courtesy"],
        &["courthouse"],
        &["courthouse"],
        &["courtroom"],
        &["courtroom"],
        &["courtesy"],
        &["courier", "couturier"],
    ],
    range: 2..=7,
};

static WORD_COUN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_COUN_CHILDREN),
    value: None,
};

static WORD_COUN_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    Some(&WORD_COUNC_NODE),
    Some(&WORD_COUND_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_COUNL_NODE),
    None,
    None,
    None,
    Some(&WORD_COUNP_NODE),
    None,
    Some(&WORD_COUNR_NODE),
    Some(&WORD_COUNS_NODE),
    Some(&WORD_COUNT_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_COUNT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COUNT_CHILDREN),
    value: None,
};

pub static WORD_COUNT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ain"),
        dictgen::InsensitiveStr::Ascii("ainer"),
        dictgen::InsensitiveStr::Ascii("ainers"),
        dictgen::InsensitiveStr::Ascii("ains"),
        dictgen::InsensitiveStr::Ascii("epart"),
        dictgen::InsensitiveStr::Ascii("eratk"),
        dictgen::InsensitiveStr::Ascii("erbat"),
        dictgen::InsensitiveStr::Ascii("ercat"),
        dictgen::InsensitiveStr::Ascii("ercoat"),
        dictgen::InsensitiveStr::Ascii("ercut"),
        dictgen::InsensitiveStr::Ascii("erd"),
        dictgen::InsensitiveStr::Ascii("ere"),
        dictgen::InsensitiveStr::Ascii("eredit"),
        dictgen::InsensitiveStr::Ascii("eres"),
        dictgen::InsensitiveStr::Ascii("erfact"),
        dictgen::InsensitiveStr::Ascii("erfait"),
        dictgen::InsensitiveStr::Ascii("erfeight"),
        dictgen::InsensitiveStr::Ascii("erfest"),
        dictgen::InsensitiveStr::Ascii("erfiet"),
        dictgen::InsensitiveStr::Ascii("erfiets"),
        dictgen::InsensitiveStr::Ascii("erfit"),
        dictgen::InsensitiveStr::Ascii("erfited"),
        dictgen::InsensitiveStr::Ascii("erfits"),
        dictgen::InsensitiveStr::Ascii("eries"),
        dictgen::InsensitiveStr::Ascii("ermeausure"),
        dictgen::InsensitiveStr::Ascii("ermeausures"),
        dictgen::InsensitiveStr::Ascii("erpaly"),
        dictgen::InsensitiveStr::Ascii("erpar"),
        dictgen::InsensitiveStr::Ascii("erpary"),
        dictgen::InsensitiveStr::Ascii("erpath"),
        dictgen::InsensitiveStr::Ascii("erpats"),
        dictgen::InsensitiveStr::Ascii("erpoart"),
        dictgen::InsensitiveStr::Ascii("erpoarts"),
        dictgen::InsensitiveStr::Ascii("erpont"),
        dictgen::InsensitiveStr::Ascii("erporductive"),
        dictgen::InsensitiveStr::Ascii("erprodutive"),
        dictgen::InsensitiveStr::Ascii("erract"),
        dictgen::InsensitiveStr::Ascii("erracts"),
        dictgen::InsensitiveStr::Ascii("erside"),
        dictgen::InsensitiveStr::Ascii("ert"),
        dictgen::InsensitiveStr::Ascii("ertrap"),
        dictgen::InsensitiveStr::Ascii("ertraps"),
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("inue"),
        dictgen::InsensitiveStr::Ascii("inueq"),
        dictgen::InsensitiveStr::Ascii("ires"),
        dictgen::InsensitiveStr::Ascii("oring"),
        dictgen::InsensitiveStr::Ascii("ours"),
        dictgen::InsensitiveStr::Ascii("r"),
        dictgen::InsensitiveStr::Ascii("res"),
        dictgen::InsensitiveStr::Ascii("riside"),
        dictgen::InsensitiveStr::Ascii("rs"),
        dictgen::InsensitiveStr::Ascii("rycide"),
        dictgen::InsensitiveStr::Ascii("ryies"),
        dictgen::InsensitiveStr::Ascii("rying"),
        dictgen::InsensitiveStr::Ascii("rywides"),
        dictgen::InsensitiveStr::Ascii("rywise"),
    ],
    values: &[
        &["contain"],
        &["container"],
        &["containers"],
        &["contains"],
        &["counteract"],
        &["counteract"],
        &["counteract"],
        &["counteract"],
        &["counteract"],
        &["counteract"],
        &["countered"],
        &["counter"],
        &["counterfeit"],
        &["counters"],
        &["counteract"],
        &["counterfeit"],
        &["counterfeit"],
        &["counterfeit"],
        &["counterfeit"],
        &["counterfeit"],
        &["counterfeit"],
        &["counterfeit"],
        &["counterfeits"],
        &["counters"],
        &["countermeasure"],
        &["countermeasures"],
        &["counterplay"],
        &["counterpart"],
        &["counterplay"],
        &["counterpart"],
        &["counterparts"],
        &["counterpart"],
        &["counterparts"],
        &["counterpoint"],
        &["counterproductive"],
        &["counterproductive"],
        &["counterpart"],
        &["counterparts"],
        &["countryside"],
        &["counteract"],
        &["counterpart"],
        &["counterparts"],
        &["counters"],
        &["continue"],
        &["continueq", "continue"],
        &["countries", "counties"],
        &["countering"],
        &["contours", "counters"],
        &["counter", "contour", "country", "county"],
        &["counters"],
        &["countryside"],
        &["counters", "contours", "countries"],
        &["countryside"],
        &["countryside"],
        &["countering"],
        &["countryside"],
        &["countryside"],
    ],
    range: 1..=12,
};

static WORD_COUNS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COUNS_CHILDREN),
    value: None,
};

pub static WORD_COUNS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eil"),
        dictgen::InsensitiveStr::Ascii("elers"),
        dictgen::InsensitiveStr::Ascii("ellling"),
        dictgen::InsensitiveStr::Ascii("ellng"),
        dictgen::InsensitiveStr::Ascii("il"),
        dictgen::InsensitiveStr::Ascii("ilers"),
        dictgen::InsensitiveStr::Ascii("iling"),
        dictgen::InsensitiveStr::Ascii("illing"),
        dictgen::InsensitiveStr::Ascii("ilors"),
        dictgen::InsensitiveStr::Ascii("ils"),
        dictgen::InsensitiveStr::Ascii("le"),
        dictgen::InsensitiveStr::Ascii("ole"),
        dictgen::InsensitiveStr::Ascii("olers"),
        dictgen::InsensitiveStr::Ascii("oling"),
    ],
    values: &[
        &["counsel"],
        &["counselors"],
        &["counselling"],
        &["counselling"],
        &["counsel"],
        &["counselors"],
        &["counseling"],
        &["counselling"],
        &["counselors"],
        &["counsels"],
        &["counsel"],
        &["counsel"],
        &["counselors"],
        &["counseling"],
    ],
    range: 2..=7,
};

static WORD_COUNR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COUNR_CHILDREN),
    value: None,
};

pub static WORD_COUNR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ies"),
        dictgen::InsensitiveStr::Ascii("tyside"),
    ],
    values: &[&["countries", "counties"], &["countryside"]],
    range: 3..=6,
};

static WORD_COUNP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COUNP_CHILDREN),
    value: None,
};

pub static WORD_COUNP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ound"),
        dictgen::InsensitiveStr::Ascii("ounds"),
    ],
    values: &[&["compound"], &["compounds"]],
    range: 4..=5,
};

static WORD_COUNL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COUNL_CHILDREN),
    value: None,
};

pub static WORD_COUNL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("d")],
    values: &[&["could"]],
    range: 1..=1,
};

static WORD_COUND_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COUND_CHILDREN),
    value: Some(&["could", "count", "found"]),
};

pub static WORD_COUND_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("ition"),
        dictgen::InsensitiveStr::Ascii("s"),
    ],
    values: &[&["counted"], &["counting"], &["condition"], &["counts"]],
    range: 1..=5,
};

static WORD_COUNC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COUNC_CHILDREN),
    value: None,
};

pub static WORD_COUNC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("el"),
        dictgen::InsensitiveStr::Ascii("eling"),
        dictgen::InsensitiveStr::Ascii("elled"),
        dictgen::InsensitiveStr::Ascii("elling"),
        dictgen::InsensitiveStr::Ascii("ellor"),
        dictgen::InsensitiveStr::Ascii("ellors"),
        dictgen::InsensitiveStr::Ascii("elors"),
        dictgen::InsensitiveStr::Ascii("els"),
        dictgen::InsensitiveStr::Ascii("idental"),
        dictgen::InsensitiveStr::Ascii("identally"),
        dictgen::InsensitiveStr::Ascii("iler"),
        dictgen::InsensitiveStr::Ascii("ilers"),
        dictgen::InsensitiveStr::Ascii("iles"),
        dictgen::InsensitiveStr::Ascii("ills"),
        dictgen::InsensitiveStr::Ascii("ilos"),
    ],
    values: &[
        &["council", "counsel"],
        &["counseling"],
        &["counselled"],
        &["counselling"],
        &["councillor", "counsellor"],
        &["councillors", "counsellors"],
        &["counselors"],
        &["councils", "counsels"],
        &["coincidental"],
        &["coincidentally"],
        &["councilor"],
        &["councils", "councilors"],
        &["councils"],
        &["councils"],
        &["councils"],
    ],
    range: 2..=9,
};

static WORD_COUM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COUM_CHILDREN),
    value: None,
};

pub static WORD_COUM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("munities"),
        dictgen::InsensitiveStr::Ascii("munity"),
        dictgen::InsensitiveStr::Ascii("pound"),
        dictgen::InsensitiveStr::Ascii("pounds"),
    ],
    values: &[
        &["communities"],
        &["community"],
        &["compound"],
        &["compounds"],
    ],
    range: 5..=8,
};

static WORD_COUL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COUL_CHILDREN),
    value: Some(&["could"]),
};

pub static WORD_COUL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("dnot"),
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("mns"),
        dictgen::InsensitiveStr::Ascii("ndt"),
        dictgen::InsensitiveStr::Ascii("ored"),
        dictgen::InsensitiveStr::Ascii("oumb"),
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("umn"),
        dictgen::InsensitiveStr::Ascii("umns"),
    ],
    values: &[
        &["couldnt"],
        &["could"],
        &["columns"],
        &["couldnt"],
        &["colored"],
        &["coulomb"],
        &["could"],
        &["column", "coulomb"],
        &["columns", "coulombs"],
    ],
    range: 1..=4,
};

static WORD_COUG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COUG_CHILDREN),
    value: None,
};

pub static WORD_COUG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ht")],
    values: &[&["caught", "cough", "fought"]],
    range: 2..=2,
};

static WORD_COUD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COUD_CHILDREN),
    value: Some(&["could"]),
};

pub static WORD_COUD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("l"),
        dictgen::InsensitiveStr::Ascii("lnt"),
    ],
    values: &[&["could", "cloud"], &["couldnt"]],
    range: 1..=3,
};

static WORD_COUC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COUC_CHILDREN),
    value: None,
};

pub static WORD_COUC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("il")],
    values: &[&["council"]],
    range: 2..=2,
};

static WORD_COT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COT_CHILDREN),
    value: None,
};

pub static WORD_COT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ain"),
        dictgen::InsensitiveStr::Ascii("ained"),
        dictgen::InsensitiveStr::Ascii("ainer"),
        dictgen::InsensitiveStr::Ascii("ains"),
        dictgen::InsensitiveStr::Ascii("ave"),
        dictgen::InsensitiveStr::Ascii("aves"),
        dictgen::InsensitiveStr::Ascii("nain"),
        dictgen::InsensitiveStr::Ascii("nained"),
        dictgen::InsensitiveStr::Ascii("nainer"),
        dictgen::InsensitiveStr::Ascii("nainers"),
        dictgen::InsensitiveStr::Ascii("naining"),
        dictgen::InsensitiveStr::Ascii("nains"),
        dictgen::InsensitiveStr::Ascii("ranser"),
        dictgen::InsensitiveStr::Ascii("rasferred"),
        dictgen::InsensitiveStr::Ascii("rasfers"),
        dictgen::InsensitiveStr::Ascii("rol"),
        dictgen::InsensitiveStr::Ascii("roll"),
        dictgen::InsensitiveStr::Ascii("rolled"),
        dictgen::InsensitiveStr::Ascii("roller"),
        dictgen::InsensitiveStr::Ascii("rolles"),
        dictgen::InsensitiveStr::Ascii("rolling"),
        dictgen::InsensitiveStr::Ascii("rolls"),
        dictgen::InsensitiveStr::Ascii("rols"),
        dictgen::InsensitiveStr::Ascii("ten"),
    ],
    values: &[
        &["contain"],
        &["contained"],
        &["container"],
        &["contains"],
        &["octave"],
        &["octaves"],
        &["contain"],
        &["contained"],
        &["container"],
        &["containers"],
        &["containing"],
        &["contains"],
        &["cotransfer"],
        &["cotransferred"],
        &["cotransfers"],
        &["control"],
        &["control"],
        &["controlled"],
        &["controller"],
        &["controls"],
        &["controlling"],
        &["controls"],
        &["controls"],
        &["cotton"],
    ],
    range: 3..=9,
};

static WORD_COS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COS_CHILDREN),
    value: None,
};

pub static WORD_COS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("emtic"),
        dictgen::InsensitiveStr::Ascii("emtics"),
        dictgen::InsensitiveStr::Ascii("istent"),
        dictgen::InsensitiveStr::Ascii("meticas"),
        dictgen::InsensitiveStr::Ascii("meticos"),
        dictgen::InsensitiveStr::Ascii("nsrain"),
        dictgen::InsensitiveStr::Ascii("nsrained"),
        dictgen::InsensitiveStr::Ascii("ntitutive"),
        dictgen::InsensitiveStr::Ascii("ntrain"),
        dictgen::InsensitiveStr::Ascii("ntrained"),
        dictgen::InsensitiveStr::Ascii("ntraining"),
        dictgen::InsensitiveStr::Ascii("ntrains"),
        dictgen::InsensitiveStr::Ascii("ntraint"),
        dictgen::InsensitiveStr::Ascii("ntraints"),
        dictgen::InsensitiveStr::Ascii("ntructed"),
        dictgen::InsensitiveStr::Ascii("ntructor"),
        dictgen::InsensitiveStr::Ascii("numer"),
        dictgen::InsensitiveStr::Ascii("olation"),
        dictgen::InsensitiveStr::Ascii("ole"),
        dictgen::InsensitiveStr::Ascii("oled"),
        dictgen::InsensitiveStr::Ascii("oles"),
        dictgen::InsensitiveStr::Ascii("oling"),
        dictgen::InsensitiveStr::Ascii("tant"),
        dictgen::InsensitiveStr::Ascii("texpr"),
        dictgen::InsensitiveStr::Ascii("titution"),
        dictgen::InsensitiveStr::Ascii("tomizable"),
        dictgen::InsensitiveStr::Ascii("tomization"),
        dictgen::InsensitiveStr::Ascii("truct"),
        dictgen::InsensitiveStr::Ascii("tructer"),
        dictgen::InsensitiveStr::Ascii("truction"),
        dictgen::InsensitiveStr::Ascii("tructions"),
        dictgen::InsensitiveStr::Ascii("tructor"),
        dictgen::InsensitiveStr::Ascii("tum"),
        dictgen::InsensitiveStr::Ascii("tumary"),
        dictgen::InsensitiveStr::Ascii("tumise"),
        dictgen::InsensitiveStr::Ascii("tumizable"),
        dictgen::InsensitiveStr::Ascii("tumization"),
        dictgen::InsensitiveStr::Ascii("tumizations"),
        dictgen::InsensitiveStr::Ascii("tumize"),
        dictgen::InsensitiveStr::Ascii("tumized"),
        dictgen::InsensitiveStr::Ascii("tums"),
        dictgen::InsensitiveStr::Ascii("utmes"),
    ],
    values: &[
        &["case"],
        &["closed"],
        &["cosmetic"],
        &["cosmetics"],
        &["consistent"],
        &["cosmetics"],
        &["cosmetics"],
        &["constrain"],
        &["constrained"],
        &["constitutive"],
        &["constrain"],
        &["constrained"],
        &["constraining"],
        &["constrains", "constraints"],
        &["constraint"],
        &["constraints"],
        &["constructed"],
        &["constructor"],
        &["consumer"],
        &["consolation"],
        &["console"],
        &["consoled"],
        &["consoles"],
        &["consoling"],
        &["constant"],
        &["constexpr"],
        &["constitution"],
        &["customizable"],
        &["customization"],
        &["construct"],
        &["constructor"],
        &["construction"],
        &["constructions"],
        &["constructor"],
        &["custom", "costume"],
        &["customary"],
        &["costumes"],
        &["customizable"],
        &["customization"],
        &["customization"],
        &["customize"],
        &["customized"],
        &["costumes", "customs"],
        &["costumes"],
    ],
    range: 1..=11,
};

static WORD_COR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_COR_CHILDREN),
    value: None,
};

static WORD_COR_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_CORA_NODE),
    None,
    Some(&WORD_CORC_NODE),
    Some(&WORD_CORD_NODE),
    Some(&WORD_CORE_NODE),
    Some(&WORD_CORF_NODE),
    None,
    None,
    Some(&WORD_CORI_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_CORN_NODE),
    Some(&WORD_CORO_NODE),
    Some(&WORD_CORP_NODE),
    None,
    Some(&WORD_CORR_NODE),
    Some(&WORD_CORS_NODE),
    None,
    Some(&WORD_CORU_NODE),
    Some(&WORD_CORV_NODE),
    Some(&WORD_CORW_NODE),
    None,
    None,
    None,
];

static WORD_CORW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CORW_CHILDREN),
    value: None,
};

pub static WORD_CORW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("bar")],
    values: &[&["crowbar"]],
    range: 3..=3,
};

static WORD_CORV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CORV_CHILDREN),
    value: None,
};

pub static WORD_CORV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ering")],
    values: &[&["covering"]],
    range: 5..=5,
};

static WORD_CORU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CORU_CHILDREN),
    value: None,
};

pub static WORD_CORU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ching"),
        dictgen::InsensitiveStr::Ascii("pt"),
        dictgen::InsensitiveStr::Ascii("pted"),
        dictgen::InsensitiveStr::Ascii("ption"),
        dictgen::InsensitiveStr::Ascii("ptions"),
        dictgen::InsensitiveStr::Ascii("pts"),
        dictgen::InsensitiveStr::Ascii("s"),
    ],
    values: &[
        &["crouching"],
        &["corrupt"],
        &["corrupted"],
        &["corruption"],
        &["corruptions"],
        &["corrupts"],
        &["chorus"],
    ],
    range: 1..=6,
};

static WORD_CORS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CORS_CHILDREN),
    value: None,
};

pub static WORD_CORS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ari"),
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("iar"),
        dictgen::InsensitiveStr::Ascii("or"),
        dictgen::InsensitiveStr::Ascii("pes"),
        dictgen::InsensitiveStr::Ascii("s"),
        dictgen::InsensitiveStr::Ascii("ses"),
        dictgen::InsensitiveStr::Ascii("sfire"),
        dictgen::InsensitiveStr::Ascii("shair"),
        dictgen::InsensitiveStr::Ascii("shairs"),
        dictgen::InsensitiveStr::Ascii("spost"),
    ],
    values: &[
        &["corsair"],
        &[
            "course", "coarse", "core", "corpse", "cors", "corset", "curse", "horse", "norse",
            "torse", "worse",
        ],
        &["corsair"],
        &["cursor"],
        &["corpses"],
        &["cross", "course"],
        &["crosses", "courses"],
        &["crossfire"],
        &["crosshair"],
        &["crosshairs"],
        &["crosspost"],
    ],
    range: 1..=6,
};

static WORD_CORR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_CORR_CHILDREN),
    value: None,
};

static WORD_CORR_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_CORRA_NODE),
    None,
    Some(&WORD_CORRC_NODE),
    Some(&WORD_CORRD_NODE),
    Some(&WORD_CORRE_NODE),
    None,
    None,
    None,
    Some(&WORD_CORRI_NODE),
    None,
    None,
    Some(&WORD_CORRL_NODE),
    None,
    None,
    Some(&WORD_CORRO_NODE),
    Some(&WORD_CORRP_NODE),
    None,
    Some(&WORD_CORRR_NODE),
    Some(&WORD_CORRS_NODE),
    None,
    Some(&WORD_CORRU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_CORRU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CORRU_CHILDREN),
    value: None,
};

pub static WORD_CORRU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("lates"),
        dictgen::InsensitiveStr::Ascii("pcion"),
        dictgen::InsensitiveStr::Ascii("peted"),
        dictgen::InsensitiveStr::Ascii("ptable"),
        dictgen::InsensitiveStr::Ascii("ptin"),
        dictgen::InsensitiveStr::Ascii("ptiuon"),
        dictgen::InsensitiveStr::Ascii("pto"),
        dictgen::InsensitiveStr::Ascii("put"),
    ],
    values: &[
        &["correlates"],
        &["corruption"],
        &["corrupted"],
        &["corruptible"],
        &["corruption"],
        &["corruption"],
        &["corruption"],
        &["corrupt"],
    ],
    range: 3..=6,
};

static WORD_CORRS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CORRS_CHILDREN),
    value: None,
};

pub static WORD_CORRS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eponding"),
        dictgen::InsensitiveStr::Ascii("pond"),
        dictgen::InsensitiveStr::Ascii("ponded"),
        dictgen::InsensitiveStr::Ascii("pondence"),
        dictgen::InsensitiveStr::Ascii("ponding"),
        dictgen::InsensitiveStr::Ascii("ponds"),
    ],
    values: &[
        &["corresponding"],
        &["correspond"],
        &["corresponded"],
        &["correspondence"],
        &["corresponding"],
        &["corresponds"],
    ],
    range: 4..=8,
};

static WORD_CORRR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CORRR_CHILDREN),
    value: None,
};

pub static WORD_CORRR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ect"),
        dictgen::InsensitiveStr::Ascii("ected"),
        dictgen::InsensitiveStr::Ascii("ecting"),
        dictgen::InsensitiveStr::Ascii("ection"),
        dictgen::InsensitiveStr::Ascii("ections"),
        dictgen::InsensitiveStr::Ascii("ectly"),
        dictgen::InsensitiveStr::Ascii("ectness"),
        dictgen::InsensitiveStr::Ascii("ects"),
        dictgen::InsensitiveStr::Ascii("esponding"),
        dictgen::InsensitiveStr::Ascii("esponds"),
        dictgen::InsensitiveStr::Ascii("upt"),
        dictgen::InsensitiveStr::Ascii("upted"),
        dictgen::InsensitiveStr::Ascii("uption"),
    ],
    values: &[
        &["correct"],
        &["corrected"],
        &["correcting"],
        &["correction"],
        &["corrections"],
        &["correctly"],
        &["correctness"],
        &["corrects"],
        &["corresponding"],
        &["corresponds"],
        &["corrupt"],
        &["corrupted"],
        &["corruption"],
    ],
    range: 3..=9,
};

static WORD_CORRP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CORRP_CHILDREN),
    value: None,
};

pub static WORD_CORRP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ution")],
    values: &[&["corruption"]],
    range: 5..=5,
};

static WORD_CORRO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CORRO_CHILDREN),
    value: None,
};

pub static WORD_CORRO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("lated"),
        dictgen::InsensitiveStr::Ascii("lates"),
        dictgen::InsensitiveStr::Ascii("lation"),
        dictgen::InsensitiveStr::Ascii("lations"),
        dictgen::InsensitiveStr::Ascii("llary"),
        dictgen::InsensitiveStr::Ascii("spond"),
        dictgen::InsensitiveStr::Ascii("spondence"),
        dictgen::InsensitiveStr::Ascii("sponding"),
        dictgen::InsensitiveStr::Ascii("sponds"),
    ],
    values: &[
        &["correlated"],
        &["correlates"],
        &["correlation"],
        &["correlations"],
        &["corollary"],
        &["correspond"],
        &["correspondence"],
        &["corresponding"],
        &["corresponds"],
    ],
    range: 5..=9,
};

static WORD_CORRL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CORRL_CHILDREN),
    value: None,
};

pub static WORD_CORRL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eation"),
        dictgen::InsensitiveStr::Ascii("eations"),
    ],
    values: &[&["correlation"], &["correlations"]],
    range: 6..=7,
};

static WORD_CORRI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CORRI_CHILDREN),
    value: None,
};

pub static WORD_CORRI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("door"),
        dictgen::InsensitiveStr::Ascii("doors"),
        dictgen::InsensitiveStr::Ascii("lated"),
        dictgen::InsensitiveStr::Ascii("lates"),
        dictgen::InsensitiveStr::Ascii("lation"),
        dictgen::InsensitiveStr::Ascii("spond"),
        dictgen::InsensitiveStr::Ascii("spondant"),
        dictgen::InsensitiveStr::Ascii("spondants"),
        dictgen::InsensitiveStr::Ascii("sponded"),
        dictgen::InsensitiveStr::Ascii("spondence"),
        dictgen::InsensitiveStr::Ascii("spondences"),
        dictgen::InsensitiveStr::Ascii("sponding"),
        dictgen::InsensitiveStr::Ascii("sponds"),
    ],
    values: &[
        &["corridor"],
        &["corridors"],
        &["correlated"],
        &["correlates"],
        &["correlation"],
        &["correspond"],
        &["correspondent"],
        &["correspondents"],
        &["corresponded"],
        &["correspondence"],
        &["correspondences"],
        &["corresponding"],
        &["corresponds"],
    ],
    range: 4..=10,
};

static WORD_CORRE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_CORRE_CHILDREN),
    value: None,
};

static WORD_CORRE_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    Some(&WORD_CORREC_NODE),
    None,
    Some(&WORD_CORREE_NODE),
    None,
    Some(&WORD_CORREG_NODE),
    None,
    None,
    None,
    Some(&WORD_CORREK_NODE),
    Some(&WORD_CORREL_NODE),
    None,
    Some(&WORD_CORREN_NODE),
    Some(&WORD_CORREO_NODE),
    Some(&WORD_CORREP_NODE),
    None,
    None,
    Some(&WORD_CORRES_NODE),
    Some(&WORD_CORRET_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_CORRET_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CORRET_CHILDREN),
    value: Some(&["correct"]),
};

pub static WORD_CORRET_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("ion"),
        dictgen::InsensitiveStr::Ascii("ly"),
    ],
    values: &[&["corrected"], &["correction"], &["correctly"]],
    range: 2..=3,
};

static WORD_CORRES_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CORRES_CHILDREN),
    value: None,
};

pub static WORD_CORRES_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ond"),
        dictgen::InsensitiveStr::Ascii("onded"),
        dictgen::InsensitiveStr::Ascii("onding"),
        dictgen::InsensitiveStr::Ascii("onds"),
        dictgen::InsensitiveStr::Ascii("opnding"),
        dictgen::InsensitiveStr::Ascii("pdoning"),
        dictgen::InsensitiveStr::Ascii("pend"),
        dictgen::InsensitiveStr::Ascii("pending"),
        dictgen::InsensitiveStr::Ascii("pinding"),
        dictgen::InsensitiveStr::Ascii("pnding"),
        dictgen::InsensitiveStr::Ascii("podence"),
        dictgen::InsensitiveStr::Ascii("poding"),
        dictgen::InsensitiveStr::Ascii("poinding"),
        dictgen::InsensitiveStr::Ascii("pomd"),
        dictgen::InsensitiveStr::Ascii("pomded"),
        dictgen::InsensitiveStr::Ascii("pomdence"),
        dictgen::InsensitiveStr::Ascii("pomdences"),
        dictgen::InsensitiveStr::Ascii("pomdent"),
        dictgen::InsensitiveStr::Ascii("pomdents"),
        dictgen::InsensitiveStr::Ascii("pomding"),
        dictgen::InsensitiveStr::Ascii("pomds"),
        dictgen::InsensitiveStr::Ascii("pon"),
        dictgen::InsensitiveStr::Ascii("pondance"),
        dictgen::InsensitiveStr::Ascii("pondances"),
        dictgen::InsensitiveStr::Ascii("pondant"),
        dictgen::InsensitiveStr::Ascii("pondants"),
        dictgen::InsensitiveStr::Ascii("pondd"),
        dictgen::InsensitiveStr::Ascii("pondece"),
        dictgen::InsensitiveStr::Ascii("pondend"),
        dictgen::InsensitiveStr::Ascii("pondense"),
        dictgen::InsensitiveStr::Ascii("pondente"),
        dictgen::InsensitiveStr::Ascii("ponders"),
        dictgen::InsensitiveStr::Ascii("pondes"),
        dictgen::InsensitiveStr::Ascii("pondg"),
        dictgen::InsensitiveStr::Ascii("pondig"),
        dictgen::InsensitiveStr::Ascii("poned"),
        dictgen::InsensitiveStr::Ascii("ponging"),
        dictgen::InsensitiveStr::Ascii("poning"),
        dictgen::InsensitiveStr::Ascii("pons"),
        dictgen::InsensitiveStr::Ascii("ponsding"),
        dictgen::InsensitiveStr::Ascii("ponsing"),
        dictgen::InsensitiveStr::Ascii("pont"),
        dictgen::InsensitiveStr::Ascii("pontence"),
        dictgen::InsensitiveStr::Ascii("pontences"),
        dictgen::InsensitiveStr::Ascii("pontend"),
        dictgen::InsensitiveStr::Ascii("pontent"),
        dictgen::InsensitiveStr::Ascii("pontents"),
        dictgen::InsensitiveStr::Ascii("ponting"),
        dictgen::InsensitiveStr::Ascii("ponts"),
        dictgen::InsensitiveStr::Ascii("poond"),
        dictgen::InsensitiveStr::Ascii("sponding"),
    ],
    values: &[
        &["correspond"],
        &["corresponded"],
        &["corresponding"],
        &["corresponds"],
        &["corresponding"],
        &["corresponding"],
        &["correspond"],
        &["corresponding"],
        &["corresponding"],
        &["corresponding"],
        &["correspondence"],
        &["corresponding"],
        &["corresponding"],
        &["correspond"],
        &["corresponded"],
        &["correspondence"],
        &["correspondences"],
        &["correspondent"],
        &["correspondents"],
        &["corresponding"],
        &["corresponds"],
        &["correspond"],
        &["correspondence"],
        &["correspondences"],
        &["correspondent"],
        &["correspondents"],
        &["corresponded"],
        &["correspondence"],
        &["correspondent"],
        &["correspondence"],
        &["correspondence"],
        &["corresponds"],
        &["corresponds"],
        &["corresponding"],
        &["corresponding"],
        &["corresponded"],
        &["corresponding"],
        &["corresponding"],
        &["corresponds"],
        &["corresponding"],
        &["corresponding"],
        &["correspond"],
        &["correspondence"],
        &["correspondences"],
        &["correspondent"],
        &["correspondent"],
        &["correspondents"],
        &["corresponding"],
        &["corresponds"],
        &["correspond"],
        &["corresponding"],
    ],
    range: 3..=9,
};

static WORD_CORREP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CORREP_CHILDREN),
    value: None,
};

pub static WORD_CORREP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("onding"),
        dictgen::InsensitiveStr::Ascii("onds"),
        dictgen::InsensitiveStr::Ascii("onsing"),
        dictgen::InsensitiveStr::Ascii("osding"),
        dictgen::InsensitiveStr::Ascii("sondence"),
        dictgen::InsensitiveStr::Ascii("sonding"),
    ],
    values: &[
        &["corresponding"],
        &["corresponds"],
        &["corresponding"],
        &["corresponding"],
        &["correspondence"],
        &["corresponding"],
    ],
    range: 4..=8,
};

static WORD_CORREO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CORREO_CHILDREN),
    value: None,
};

pub static WORD_CORREO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("graph")],
    values: &[&["choreograph"]],
    range: 5..=5,
};

static WORD_CORREN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CORREN_CHILDREN),
    value: None,
};

pub static WORD_CORREN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("spond"),
        dictgen::InsensitiveStr::Ascii("sponded"),
        dictgen::InsensitiveStr::Ascii("spondence"),
        dictgen::InsensitiveStr::Ascii("spondences"),
        dictgen::InsensitiveStr::Ascii("spondent"),
        dictgen::InsensitiveStr::Ascii("spondents"),
        dictgen::InsensitiveStr::Ascii("sponding"),
        dictgen::InsensitiveStr::Ascii("sponds"),
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("ti"),
        dictgen::InsensitiveStr::Ascii("tly"),
    ],
    values: &[
        &["correspond"],
        &["corresponded"],
        &["correspondence"],
        &["correspondences"],
        &["correspondent"],
        &["correspondents"],
        &["corresponding"],
        &["corresponds"],
        &["correct", "current"],
        &["correcting"],
        &["correctly", "currently"],
    ],
    range: 1..=10,
};

static WORD_CORREL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CORREL_CHILDREN),
    value: None,
};

pub static WORD_CORREL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("acion"),
        dictgen::InsensitiveStr::Ascii("asion"),
        dictgen::InsensitiveStr::Ascii("atas"),
        dictgen::InsensitiveStr::Ascii("atd"),
        dictgen::InsensitiveStr::Ascii("atie"),
        dictgen::InsensitiveStr::Ascii("aties"),
        dictgen::InsensitiveStr::Ascii("ato"),
        dictgen::InsensitiveStr::Ascii("atos"),
        dictgen::InsensitiveStr::Ascii("late"),
        dictgen::InsensitiveStr::Ascii("lation"),
        dictgen::InsensitiveStr::Ascii("lations"),
    ],
    values: &[
        &["correlation"],
        &["correlation"],
        &["correlates"],
        &["correlated"],
        &["correlated"],
        &["correlates"],
        &["correlation"],
        &["correlates"],
        &["correlate"],
        &["correlation"],
        &["correlations"],
    ],
    range: 3..=7,
};

static WORD_CORREK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CORREK_CHILDREN),
    value: None,
};

pub static WORD_CORREK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ting"),
        dictgen::InsensitiveStr::Ascii("tions"),
        dictgen::InsensitiveStr::Ascii("tness"),
    ],
    values: &[&["correcting"], &["corrections"], &["correctness"]],
    range: 4..=5,
};

static WORD_CORREG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CORREG_CHILDREN),
    value: None,
};

pub static WORD_CORREG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ated")],
    values: &[&["correlated"]],
    range: 4..=4,
};

static WORD_CORREE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CORREE_CHILDREN),
    value: None,
};

pub static WORD_CORREE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ct"),
        dictgen::InsensitiveStr::Ascii("ctly"),
        dictgen::InsensitiveStr::Ascii("spond"),
        dictgen::InsensitiveStr::Ascii("sponded"),
        dictgen::InsensitiveStr::Ascii("spondence"),
        dictgen::InsensitiveStr::Ascii("spondences"),
        dictgen::InsensitiveStr::Ascii("spondent"),
        dictgen::InsensitiveStr::Ascii("sponding"),
        dictgen::InsensitiveStr::Ascii("sponds"),
    ],
    values: &[
        &["correct"],
        &["correctly"],
        &["correspond"],
        &["corresponded"],
        &["correspondence"],
        &["correspondences"],
        &["correspondent"],
        &["corresponding"],
        &["corresponds"],
    ],
    range: 2..=10,
};

static WORD_CORREC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CORREC_CHILDREN),
    value: None,
};

pub static WORD_CORREC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cion"),
        dictgen::InsensitiveStr::Ascii("iton"),
        dictgen::InsensitiveStr::Ascii("lty"),
        dictgen::InsensitiveStr::Ascii("ly"),
        dictgen::InsensitiveStr::Ascii("pond"),
        dictgen::InsensitiveStr::Ascii("ponded"),
        dictgen::InsensitiveStr::Ascii("ponding"),
        dictgen::InsensitiveStr::Ascii("ponds"),
        dictgen::InsensitiveStr::Ascii("s"),
        dictgen::InsensitiveStr::Ascii("tably"),
        dictgen::InsensitiveStr::Ascii("tely"),
        dictgen::InsensitiveStr::Ascii("ters"),
        dictgen::InsensitiveStr::Ascii("tess"),
        dictgen::InsensitiveStr::Ascii("tin"),
        dictgen::InsensitiveStr::Ascii("tings"),
        dictgen::InsensitiveStr::Ascii("tionals"),
        dictgen::InsensitiveStr::Ascii("tivo"),
        dictgen::InsensitiveStr::Ascii("tivos"),
        dictgen::InsensitiveStr::Ascii("tlly"),
        dictgen::InsensitiveStr::Ascii("tnes"),
        dictgen::InsensitiveStr::Ascii("ton"),
        dictgen::InsensitiveStr::Ascii("tons"),
        dictgen::InsensitiveStr::Ascii("tt"),
        dictgen::InsensitiveStr::Ascii("ttly"),
        dictgen::InsensitiveStr::Ascii("ttness"),
        dictgen::InsensitiveStr::Ascii("tures"),
        dictgen::InsensitiveStr::Ascii("ty"),
        dictgen::InsensitiveStr::Ascii("tyly"),
        dictgen::InsensitiveStr::Ascii("xt"),
        dictgen::InsensitiveStr::Ascii("y"),
    ],
    values: &[
        &["correction"],
        &["corrections"],
        &["correctly"],
        &["correctly"],
        &["correspond"],
        &["corresponded"],
        &["corresponding"],
        &["corresponds"],
        &["corrects"],
        &["correctable"],
        &["correctly"],
        &["correctors"],
        &["correctness"],
        &["correction"],
        &["corrections"],
        &["corrections"],
        &["correction"],
        &["corrections"],
        &["correctly"],
        &["correctness"],
        &["correction"],
        &["corrections"],
        &["correct"],
        &["correctly"],
        &["correctness"],
        &["correctors"],
        &["correctly"],
        &["correctly"],
        &["correct"],
        &["correct"],
    ],
    range: 1..=7,
};

static WORD_CORRD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CORRD_CHILDREN),
    value: None,
};

pub static WORD_CORRD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("inate"),
        dictgen::InsensitiveStr::Ascii("inated"),
        dictgen::InsensitiveStr::Ascii("inates"),
        dictgen::InsensitiveStr::Ascii("inating"),
        dictgen::InsensitiveStr::Ascii("ination"),
        dictgen::InsensitiveStr::Ascii("inator"),
        dictgen::InsensitiveStr::Ascii("inators"),
        dictgen::InsensitiveStr::Ascii("ior"),
    ],
    values: &[
        &["coordinate"],
        &["coordinated"],
        &["coordinates"],
        &["coordinating"],
        &["coordination"],
        &["coordinator"],
        &["coordinators"],
        &["corridor"],
    ],
    range: 3..=7,
};

static WORD_CORRC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CORRC_CHILDREN),
    value: None,
};

pub static WORD_CORRC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ect"),
        dictgen::InsensitiveStr::Ascii("t"),
    ],
    values: &[&["correct"], &["correct"]],
    range: 1..=3,
};

static WORD_CORRA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CORRA_CHILDREN),
    value: None,
};

pub static WORD_CORRA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("lated"),
        dictgen::InsensitiveStr::Ascii("lates"),
        dictgen::InsensitiveStr::Ascii("lation"),
    ],
    values: &[&["correlated"], &["correlates"], &["correlation"]],
    range: 5..=6,
};

static WORD_CORP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CORP_CHILDREN),
    value: None,
};

pub static WORD_CORP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("arate"),
        dictgen::InsensitiveStr::Ascii("aration"),
        dictgen::InsensitiveStr::Ascii("arations"),
        dictgen::InsensitiveStr::Ascii("eration"),
        dictgen::InsensitiveStr::Ascii("erations"),
        dictgen::InsensitiveStr::Ascii("oracion"),
        dictgen::InsensitiveStr::Ascii("oratie"),
        dictgen::InsensitiveStr::Ascii("orativo"),
        dictgen::InsensitiveStr::Ascii("orativos"),
        dictgen::InsensitiveStr::Ascii("oratoin"),
        dictgen::InsensitiveStr::Ascii("oratoins"),
        dictgen::InsensitiveStr::Ascii("ration"),
        dictgen::InsensitiveStr::Ascii("roate"),
        dictgen::InsensitiveStr::Ascii("roations"),
        dictgen::InsensitiveStr::Ascii("roration"),
        dictgen::InsensitiveStr::Ascii("rorations"),
        dictgen::InsensitiveStr::Ascii("sers"),
    ],
    values: &[
        &["corporate"],
        &["corporation"],
        &["corporations"],
        &["corporation"],
        &["corporations"],
        &["corporation"],
        &["corporate"],
        &["corporation"],
        &["corporations"],
        &["corporation"],
        &["corporations"],
        &["corporation"],
        &["corporate"],
        &["corporations"],
        &["corporation"],
        &["corporations"],
        &["corpses"],
    ],
    range: 4..=9,
};

static WORD_CORO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CORO_CHILDREN),
    value: None,
};

pub static WORD_CORO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("llla"),
        dictgen::InsensitiveStr::Ascii("lloa"),
        dictgen::InsensitiveStr::Ascii("rdinate"),
        dictgen::InsensitiveStr::Ascii("rdinates"),
        dictgen::InsensitiveStr::Ascii("rdination"),
        dictgen::InsensitiveStr::Ascii("sbonding"),
        dictgen::InsensitiveStr::Ascii("sion"),
        dictgen::InsensitiveStr::Ascii("spond"),
        dictgen::InsensitiveStr::Ascii("spondance"),
        dictgen::InsensitiveStr::Ascii("sponded"),
        dictgen::InsensitiveStr::Ascii("spondence"),
        dictgen::InsensitiveStr::Ascii("sponding"),
        dictgen::InsensitiveStr::Ascii("sponds"),
        dictgen::InsensitiveStr::Ascii("usel"),
    ],
    values: &[
        &["corolla"],
        &["corolla"],
        &["coordinate"],
        &["coordinates"],
        &["coordination"],
        &["corresponding"],
        &["corrosion"],
        &["correspond"],
        &["correspondence"],
        &["corresponded"],
        &["correspondence"],
        &["corresponding"],
        &["corresponds"],
        &["carousel"],
    ],
    range: 4..=9,
};

static WORD_CORN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CORN_CHILDREN),
    value: None,
};

pub static WORD_CORN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("el"),
        dictgen::InsensitiveStr::Ascii("els"),
        dictgen::InsensitiveStr::Ascii("ithians"),
        dictgen::InsensitiveStr::Ascii("mitted"),
    ],
    values: &[
        &["colonel"],
        &["colonels"],
        &["corinthians"],
        &["committed"],
    ],
    range: 2..=7,
};

static WORD_CORI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CORI_CHILDREN),
    value: None,
};

pub static WORD_CORI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("dal"),
        dictgen::InsensitiveStr::Ascii("nthains"),
        dictgen::InsensitiveStr::Ascii("nthans"),
        dictgen::InsensitiveStr::Ascii("ntheans"),
        dictgen::InsensitiveStr::Ascii("nthianos"),
        dictgen::InsensitiveStr::Ascii("nthias"),
        dictgen::InsensitiveStr::Ascii("nthiens"),
        dictgen::InsensitiveStr::Ascii("nthinans"),
        dictgen::InsensitiveStr::Ascii("nthinas"),
        dictgen::InsensitiveStr::Ascii("nthins"),
        dictgen::InsensitiveStr::Ascii("spond"),
    ],
    values: &[
        &["cordial"],
        &["corinthians"],
        &["corinthians"],
        &["corinthians"],
        &["corinthians"],
        &["corinthians"],
        &["corinthians"],
        &["corinthians"],
        &["corinthians"],
        &["corinthians"],
        &["correspond"],
    ],
    range: 3..=8,
};

static WORD_CORF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CORF_CHILDREN),
    value: None,
};

pub static WORD_CORF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("irms")],
    values: &[&["confirms"]],
    range: 4..=4,
};

static WORD_CORE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CORE_CHILDREN),
    value: None,
};

pub static WORD_CORE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cct"),
        dictgen::InsensitiveStr::Ascii("cctly"),
        dictgen::InsensitiveStr::Ascii("ct"),
        dictgen::InsensitiveStr::Ascii("cted"),
        dictgen::InsensitiveStr::Ascii("cting"),
        dictgen::InsensitiveStr::Ascii("ction"),
        dictgen::InsensitiveStr::Ascii("ctly"),
        dictgen::InsensitiveStr::Ascii("ctness"),
        dictgen::InsensitiveStr::Ascii("cts"),
        dictgen::InsensitiveStr::Ascii("espond"),
        dictgen::InsensitiveStr::Ascii("gated"),
        dictgen::InsensitiveStr::Ascii("late"),
        dictgen::InsensitiveStr::Ascii("lated"),
        dictgen::InsensitiveStr::Ascii("lates"),
        dictgen::InsensitiveStr::Ascii("llation"),
        dictgen::InsensitiveStr::Ascii("ner"),
        dictgen::InsensitiveStr::Ascii("olis"),
        dictgen::InsensitiveStr::Ascii("rct"),
        dictgen::InsensitiveStr::Ascii("rctly"),
        dictgen::InsensitiveStr::Ascii("spond"),
        dictgen::InsensitiveStr::Ascii("sponded"),
        dictgen::InsensitiveStr::Ascii("spondence"),
        dictgen::InsensitiveStr::Ascii("sponding"),
        dictgen::InsensitiveStr::Ascii("sponds"),
    ],
    values: &[
        &["correct"],
        &["correctly"],
        &["correct"],
        &["corrected"],
        &["correcting"],
        &["correction"],
        &["correctly"],
        &["correctness"],
        &["corrects"],
        &["correspond"],
        &["corrugated"],
        &["correlate"],
        &["correlated"],
        &["correlates"],
        &["correlation"],
        &["corner", "coroner"],
        &["coriolis"],
        &["correct"],
        &["correctly"],
        &["correspond"],
        &["corresponded"],
        &["correspondence"],
        &["corresponding"],
        &["corresponds"],
    ],
    range: 2..=9,
};

static WORD_CORD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CORD_CHILDREN),
    value: None,
};

pub static WORD_CORD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("inates"),
        dictgen::InsensitiveStr::Ascii("oroy"),
        dictgen::InsensitiveStr::Ascii("ump"),
    ],
    values: &[&["coordinates"], &["corduroy"], &["coredump"]],
    range: 3..=6,
};

static WORD_CORC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CORC_CHILDREN),
    value: None,
};

pub static WORD_CORC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("odile")],
    values: &[&["crocodile"]],
    range: 5..=5,
};

static WORD_CORA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CORA_CHILDREN),
    value: None,
};

pub static WORD_CORA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("le"),
        dictgen::InsensitiveStr::Ascii("lina"),
        dictgen::InsensitiveStr::Ascii("sir"),
        dictgen::InsensitiveStr::Ascii("tia"),
    ],
    values: &[&["chorale"], &["carolina"], &["corsair"], &["croatia"]],
    range: 2..=4,
};

static WORD_COP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_COP_CHILDREN),
    value: None,
};

static WORD_COP_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    None,
    None,
    Some(&WORD_COPE_NODE),
    None,
    None,
    None,
    Some(&WORD_COPI_NODE),
    None,
    None,
    Some(&WORD_COPL_NODE),
    Some(&WORD_COPM_NODE),
    Some(&WORD_COPN_NODE),
    Some(&WORD_COPO_NODE),
    Some(&WORD_COPP_NODE),
    None,
    Some(&WORD_COPR_NODE),
    Some(&WORD_COPS_NODE),
    None,
    Some(&WORD_COPU_NODE),
    Some(&WORD_COPV_NODE),
    None,
    None,
    Some(&WORD_COPY_NODE),
    None,
];

static WORD_COPY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COPY_CHILDREN),
    value: None,
};

pub static WORD_COPY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("eight"),
        dictgen::InsensitiveStr::Ascii("eighted"),
        dictgen::InsensitiveStr::Ascii("eights"),
        dictgen::InsensitiveStr::Ascii("ied"),
        dictgen::InsensitiveStr::Ascii("irght"),
        dictgen::InsensitiveStr::Ascii("irghted"),
        dictgen::InsensitiveStr::Ascii("irghts"),
        dictgen::InsensitiveStr::Ascii("righed"),
        dictgen::InsensitiveStr::Ascii("rigted"),
        dictgen::InsensitiveStr::Ascii("rigth"),
        dictgen::InsensitiveStr::Ascii("rigthed"),
        dictgen::InsensitiveStr::Ascii("rigths"),
        dictgen::InsensitiveStr::Ascii("ritght"),
        dictgen::InsensitiveStr::Ascii("ritghted"),
        dictgen::InsensitiveStr::Ascii("ritghts"),
        dictgen::InsensitiveStr::Ascii("rught"),
        dictgen::InsensitiveStr::Ascii("rughted"),
        dictgen::InsensitiveStr::Ascii("rughts"),
        dictgen::InsensitiveStr::Ascii("s"),
        dictgen::InsensitiveStr::Ascii("tight"),
        dictgen::InsensitiveStr::Ascii("tighted"),
        dictgen::InsensitiveStr::Ascii("tights"),
        dictgen::InsensitiveStr::Ascii("ting"),
        dictgen::InsensitiveStr::Ascii("write"),
    ],
    values: &[
        &["copied"],
        &["copyright"],
        &["copyrighted"],
        &["copyrights"],
        &["copied"],
        &["copyright"],
        &["copyrighted"],
        &["copyrights"],
        &["copyrighted"],
        &["copyrighted"],
        &["copyright"],
        &["copyrighted"],
        &["copyrights"],
        &["copyright"],
        &["copyrighted"],
        &["copyrights"],
        &["copyright"],
        &["copyrighted"],
        &["copyrights"],
        &["copies"],
        &["copyright"],
        &["copyrighted"],
        &["copyrights"],
        &["copying"],
        &["copyright"],
    ],
    range: 1..=8,
};

static WORD_COPV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COPV_CHILDREN),
    value: None,
};

pub static WORD_COPV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("er")],
    values: &[&["cover"]],
    range: 2..=2,
};

static WORD_COPU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COPU_CHILDREN),
    value: None,
};

pub static WORD_COPU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ling"),
        dictgen::InsensitiveStr::Ascii("right"),
        dictgen::InsensitiveStr::Ascii("righted"),
        dictgen::InsensitiveStr::Ascii("rights"),
        dictgen::InsensitiveStr::Ascii("te"),
        dictgen::InsensitiveStr::Ascii("ted"),
        dictgen::InsensitiveStr::Ascii("ter"),
        dictgen::InsensitiveStr::Ascii("tes"),
    ],
    values: &[
        &["coupling"],
        &["copyright"],
        &["copyrighted"],
        &["copyrights"],
        &["compute"],
        &["computed"],
        &["computer"],
        &["computes"],
    ],
    range: 2..=7,
};

static WORD_COPS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COPS_CHILDREN),
    value: None,
};

pub static WORD_COPS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("truction")],
    values: &[&["construction"]],
    range: 8..=8,
};

static WORD_COPR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COPR_CHILDREN),
    value: None,
};

pub static WORD_COPR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ight"),
        dictgen::InsensitiveStr::Ascii("ighted"),
        dictgen::InsensitiveStr::Ascii("ights"),
        dictgen::InsensitiveStr::Ascii("occessor"),
        dictgen::InsensitiveStr::Ascii("occessors"),
        dictgen::InsensitiveStr::Ascii("ocesor"),
        dictgen::InsensitiveStr::Ascii("orate"),
        dictgen::InsensitiveStr::Ascii("orates"),
        dictgen::InsensitiveStr::Ascii("oration"),
        dictgen::InsensitiveStr::Ascii("orations"),
        dictgen::InsensitiveStr::Ascii("right"),
        dictgen::InsensitiveStr::Ascii("righted"),
        dictgen::InsensitiveStr::Ascii("rights"),
        dictgen::InsensitiveStr::Ascii("ses"),
    ],
    values: &[
        &["copyright"],
        &["copyrighted"],
        &["copyrights"],
        &["coprocessor"],
        &["coprocessors"],
        &["coprocessor"],
        &["corporate"],
        &["corporates"],
        &["corporation"],
        &["corporations"],
        &["copyright"],
        &["copyrighted"],
        &["copyrights"],
        &["corpses"],
    ],
    range: 3..=9,
};

static WORD_COPP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COPP_CHILDREN),
    value: None,
};

pub static WORD_COPP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ermines"),
        dictgen::InsensitiveStr::Ascii("ied"),
        dictgen::InsensitiveStr::Ascii("y"),
    ],
    values: &[&["coppermine"], &["copied"], &["copy", "choppy"]],
    range: 1..=7,
};

static WORD_COPO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COPO_CHILDREN),
    value: None,
};

pub static WORD_COPO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("nent"),
        dictgen::InsensitiveStr::Ascii("nents"),
        dictgen::InsensitiveStr::Ascii("ying"),
    ],
    values: &[&["component"], &["components"], &["copying"]],
    range: 4..=5,
};

static WORD_COPN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COPN_CHILDREN),
    value: None,
};

pub static WORD_COPN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("troller")],
    values: &[&["controller"]],
    range: 7..=7,
};

static WORD_COPM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COPM_CHILDREN),
    value: None,
};

pub static WORD_COPM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("etitors"),
        dictgen::InsensitiveStr::Ascii("ilation"),
        dictgen::InsensitiveStr::Ascii("onent"),
        dictgen::InsensitiveStr::Ascii("ose"),
        dictgen::InsensitiveStr::Ascii("utations"),
    ],
    values: &[
        &["competitors"],
        &["compilation"],
        &["component"],
        &["compose"],
        &["computations"],
    ],
    range: 3..=8,
};

static WORD_COPL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COPL_CHILDREN),
    value: None,
};

pub static WORD_COPL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ete"),
        dictgen::InsensitiveStr::Ascii("eted"),
        dictgen::InsensitiveStr::Ascii("etely"),
        dictgen::InsensitiveStr::Ascii("etes"),
    ],
    values: &[
        &["complete"],
        &["completed"],
        &["completely"],
        &["completes"],
    ],
    range: 3..=5,
};

static WORD_COPI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COPI_CHILDREN),
    value: None,
};

pub static WORD_COPI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("ese"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("ler"),
    ],
    values: &[
        &["copied", "copier", "copies", "copy"],
        &["copies"],
        &["copying"],
        &["compiler"],
    ],
    range: 1..=3,
};

static WORD_COPE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COPE_CHILDREN),
    value: None,
};

pub static WORD_COPE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("hnagen"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("naghen"),
        dictgen::InsensitiveStr::Ascii("nahgen"),
        dictgen::InsensitiveStr::Ascii("ngagen"),
        dictgen::InsensitiveStr::Ascii("ngahen"),
        dictgen::InsensitiveStr::Ascii("nhaagen"),
        dictgen::InsensitiveStr::Ascii("nhaegen"),
        dictgen::InsensitiveStr::Ascii("nhagan"),
        dictgen::InsensitiveStr::Ascii("nhagn"),
        dictgen::InsensitiveStr::Ascii("nhague"),
        dictgen::InsensitiveStr::Ascii("nhaguen"),
        dictgen::InsensitiveStr::Ascii("nhagun"),
        dictgen::InsensitiveStr::Ascii("nhangen"),
        dictgen::InsensitiveStr::Ascii("nhaven"),
        dictgen::InsensitiveStr::Ascii("nhegan"),
    ],
    values: &[
        &["copenhagen"],
        &["copying"],
        &["copenhagen"],
        &["copenhagen"],
        &["copenhagen"],
        &["copenhagen"],
        &["copenhagen"],
        &["copenhagen"],
        &["copenhagen"],
        &["copenhagen"],
        &["copenhagen"],
        &["copenhagen"],
        &["copenhagen"],
        &["copenhagen"],
        &["copenhagen"],
        &["copenhagen"],
    ],
    range: 3..=7,
};

static WORD_COO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_COO_CHILDREN),
    value: None,
};

static WORD_COO_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    None,
    Some(&WORD_COOD_NODE),
    Some(&WORD_COOE_NODE),
    None,
    Some(&WORD_COOG_NODE),
    None,
    None,
    None,
    Some(&WORD_COOK_NODE),
    Some(&WORD_COOL_NODE),
    Some(&WORD_COOM_NODE),
    Some(&WORD_COON_NODE),
    Some(&WORD_COOO_NODE),
    Some(&WORD_COOP_NODE),
    None,
    Some(&WORD_COOR_NODE),
    None,
    Some(&WORD_COOT_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_COOT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COOT_CHILDREN),
    value: None,
};

pub static WORD_COOT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("dinate"),
        dictgen::InsensitiveStr::Ascii("dinated"),
        dictgen::InsensitiveStr::Ascii("dinates"),
        dictgen::InsensitiveStr::Ascii("dinating"),
        dictgen::InsensitiveStr::Ascii("dination"),
    ],
    values: &[
        &["coordinate"],
        &["coordinated"],
        &["coordinates"],
        &["coordinating"],
        &["coordination"],
    ],
    range: 6..=8,
};

static WORD_COOR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_COOR_CHILDREN),
    value: None,
};

static WORD_COOR_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    None,
    Some(&WORD_COORD_NODE),
    Some(&WORD_COORE_NODE),
    None,
    None,
    None,
    Some(&WORD_COORI_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_COORP_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_COORP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COORP_CHILDREN),
    value: None,
};

pub static WORD_COORP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eration"),
        dictgen::InsensitiveStr::Ascii("erations"),
    ],
    values: &[
        &["cooperation", "corporation"],
        &["corporations", "cooperations"],
    ],
    range: 7..=8,
};

static WORD_COORI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COORI_CHILDREN),
    value: None,
};

pub static WORD_COORI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("date"),
        dictgen::InsensitiveStr::Ascii("dated"),
        dictgen::InsensitiveStr::Ascii("dates"),
        dictgen::InsensitiveStr::Ascii("dnate"),
        dictgen::InsensitiveStr::Ascii("dnated"),
        dictgen::InsensitiveStr::Ascii("dnates"),
        dictgen::InsensitiveStr::Ascii("dnation"),
        dictgen::InsensitiveStr::Ascii("dnator"),
        dictgen::InsensitiveStr::Ascii("nate"),
        dictgen::InsensitiveStr::Ascii("nates"),
        dictgen::InsensitiveStr::Ascii("nation"),
    ],
    values: &[
        &["coordinate"],
        &["coordinated"],
        &["coordinates"],
        &["coordinate"],
        &["coordinated"],
        &["coordinates"],
        &["coordination"],
        &["coordinator"],
        &["coordinate"],
        &["coordinates"],
        &["coordination"],
    ],
    range: 4..=7,
};

static WORD_COORE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COORE_CHILDREN),
    value: None,
};

pub static WORD_COORE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("spond"),
        dictgen::InsensitiveStr::Ascii("sponded"),
        dictgen::InsensitiveStr::Ascii("spondend"),
        dictgen::InsensitiveStr::Ascii("spondent"),
        dictgen::InsensitiveStr::Ascii("sponding"),
        dictgen::InsensitiveStr::Ascii("sponds"),
    ],
    values: &[
        &["correspond"],
        &["corresponded"],
        &["correspondent"],
        &["correspondent"],
        &["corresponding"],
        &["corresponds"],
    ],
    range: 5..=8,
};

static WORD_COORD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COORD_CHILDREN),
    value: None,
};

pub static WORD_COORD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("anate"),
        dictgen::InsensitiveStr::Ascii("anates"),
        dictgen::InsensitiveStr::Ascii("ate"),
        dictgen::InsensitiveStr::Ascii("enate"),
        dictgen::InsensitiveStr::Ascii("enated"),
        dictgen::InsensitiveStr::Ascii("enates"),
        dictgen::InsensitiveStr::Ascii("enation"),
        dictgen::InsensitiveStr::Ascii("iante"),
        dictgen::InsensitiveStr::Ascii("ianted"),
        dictgen::InsensitiveStr::Ascii("iantes"),
        dictgen::InsensitiveStr::Ascii("iantion"),
        dictgen::InsensitiveStr::Ascii("iantor"),
        dictgen::InsensitiveStr::Ascii("iate"),
        dictgen::InsensitiveStr::Ascii("iates"),
        dictgen::InsensitiveStr::Ascii("iinates"),
        dictgen::InsensitiveStr::Ascii("inacion"),
        dictgen::InsensitiveStr::Ascii("inador"),
        dictgen::InsensitiveStr::Ascii("inants"),
        dictgen::InsensitiveStr::Ascii("inar"),
        dictgen::InsensitiveStr::Ascii("inare"),
        dictgen::InsensitiveStr::Ascii("inater"),
        dictgen::InsensitiveStr::Ascii("inaters"),
        dictgen::InsensitiveStr::Ascii("inatess"),
        dictgen::InsensitiveStr::Ascii("inatior"),
        dictgen::InsensitiveStr::Ascii("inato"),
        dictgen::InsensitiveStr::Ascii("inaton"),
        dictgen::InsensitiveStr::Ascii("inatore"),
        dictgen::InsensitiveStr::Ascii("inats"),
        dictgen::InsensitiveStr::Ascii("indate"),
        dictgen::InsensitiveStr::Ascii("indates"),
        dictgen::InsensitiveStr::Ascii("ine"),
        dictgen::InsensitiveStr::Ascii("ines"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("ingate"),
        dictgen::InsensitiveStr::Ascii("ingates"),
        dictgen::InsensitiveStr::Ascii("ingly"),
        dictgen::InsensitiveStr::Ascii("iniate"),
        dictgen::InsensitiveStr::Ascii("iniates"),
        dictgen::InsensitiveStr::Ascii("inite"),
        dictgen::InsensitiveStr::Ascii("inites"),
        dictgen::InsensitiveStr::Ascii("innate"),
        dictgen::InsensitiveStr::Ascii("innates"),
        dictgen::InsensitiveStr::Ascii("intae"),
        dictgen::InsensitiveStr::Ascii("intaes"),
        dictgen::InsensitiveStr::Ascii("intate"),
        dictgen::InsensitiveStr::Ascii("intates"),
        dictgen::InsensitiveStr::Ascii("inte"),
        dictgen::InsensitiveStr::Ascii("intes"),
        dictgen::InsensitiveStr::Ascii("itate"),
        dictgen::InsensitiveStr::Ascii("onate"),
        dictgen::InsensitiveStr::Ascii("onated"),
        dictgen::InsensitiveStr::Ascii("onates"),
        dictgen::InsensitiveStr::Ascii("onation"),
        dictgen::InsensitiveStr::Ascii("onator"),
    ],
    values: &[
        &["coordinate"],
        &["coordinates"],
        &["cordinate"],
        &["coordinate"],
        &["coordinated"],
        &["coordinates"],
        &["coordination"],
        &["coordinate"],
        &["coordinated"],
        &["coordinates"],
        &["coordination"],
        &["coordinator"],
        &["coordinate"],
        &["coordinates"],
        &["coordinates"],
        &["coordination"],
        &["coordinator"],
        &["coordinates"],
        &["coordinator"],
        &["coordinate"],
        &["coordinator"],
        &["coordinates"],
        &["coordinates"],
        &["coordinator"],
        &["coordination"],
        &["coordination"],
        &["coordinate"],
        &["coordinates"],
        &["coordinate"],
        &["coordinates"],
        &["coordinate"],
        &["coordinates"],
        &["according"],
        &["coordinate"],
        &["coordinates"],
        &["accordingly"],
        &["coordinate"],
        &["coordinates"],
        &["coordinate"],
        &["coordinates"],
        &["coordinate"],
        &["coordinates"],
        &["coordinate"],
        &["coordinates"],
        &["coordinate"],
        &["coordinates"],
        &["coordinate"],
        &["coordinates"],
        &["coordinate"],
        &["coordinate"],
        &["coordinated"],
        &["coordinates"],
        &["coordination"],
        &["coordinator"],
    ],
    range: 3..=7,
};

static WORD_COOP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COOP_CHILDREN),
    value: None,
};

pub static WORD_COOP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aretive"),
        dictgen::InsensitiveStr::Ascii("earte"),
        dictgen::InsensitiveStr::Ascii("eartes"),
        dictgen::InsensitiveStr::Ascii("eracion"),
        dictgen::InsensitiveStr::Ascii("erativo"),
        dictgen::InsensitiveStr::Ascii("eratve"),
        dictgen::InsensitiveStr::Ascii("oration"),
        dictgen::InsensitiveStr::Ascii("orative"),
    ],
    values: &[
        &["cooperative"],
        &["cooperate"],
        &["cooperates"],
        &["cooperation"],
        &["cooperation"],
        &["cooperative"],
        &["cooperation"],
        &["cooperative"],
    ],
    range: 5..=7,
};

static WORD_COOO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COOO_CHILDREN),
    value: None,
};

pub static WORD_COOO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("rdinate"),
        dictgen::InsensitiveStr::Ascii("rdinates"),
    ],
    values: &[&["coordinate"], &["coordinates"]],
    range: 7..=8,
};

static WORD_COON_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COON_CHILDREN),
    value: None,
};

pub static WORD_COON_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("stantly"),
        dictgen::InsensitiveStr::Ascii("structed"),
    ],
    values: &[&["constantly"], &["constructed"]],
    range: 7..=8,
};

static WORD_COOM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COOM_CHILDREN),
    value: None,
};

pub static WORD_COOM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("and"),
        dictgen::InsensitiveStr::Ascii("mand"),
        dictgen::InsensitiveStr::Ascii("on"),
    ],
    values: &[&["command"], &["command"], &["common"]],
    range: 2..=4,
};

static WORD_COOL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COOL_CHILDREN),
    value: None,
};

pub static WORD_COOL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("dows"),
        dictgen::InsensitiveStr::Ascii("dwons"),
        dictgen::InsensitiveStr::Ascii("ent"),
        dictgen::InsensitiveStr::Ascii("ot"),
        dictgen::InsensitiveStr::Ascii("ots"),
    ],
    values: &[
        &["cooldowns"],
        &["cooldowns"],
        &["coolant"],
        &["culotte"],
        &["culottes"],
    ],
    range: 2..=5,
};

static WORD_COOK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COOK_CHILDREN),
    value: None,
};

pub static WORD_COOK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("oo")],
    values: &[&["cuckoo"]],
    range: 2..=2,
};

static WORD_COOG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COOG_CHILDREN),
    value: None,
};

pub static WORD_COOG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("er")],
    values: &[&["cougar"]],
    range: 2..=2,
};

static WORD_COOE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COOE_CHILDREN),
    value: None,
};

pub static WORD_COOE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("fficient"),
        dictgen::InsensitiveStr::Ascii("fficients"),
    ],
    values: &[&["coefficient"], &["coefficients"]],
    range: 8..=9,
};

static WORD_COOD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COOD_CHILDREN),
    value: None,
};

pub static WORD_COOD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("inate"),
        dictgen::InsensitiveStr::Ascii("inates"),
        dictgen::InsensitiveStr::Ascii("rinate"),
        dictgen::InsensitiveStr::Ascii("rinates"),
    ],
    values: &[
        &["coordinate"],
        &["coordinates"],
        &["coordinate"],
        &["coordinates"],
    ],
    range: 5..=7,
};

static WORD_CON_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_CON_CHILDREN),
    value: None,
};

static WORD_CON_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_CONA_NODE),
    Some(&WORD_CONB_NODE),
    Some(&WORD_CONC_NODE),
    Some(&WORD_COND_NODE),
    Some(&WORD_CONE_NODE),
    Some(&WORD_CONF_NODE),
    Some(&WORD_CONG_NODE),
    None,
    Some(&WORD_CONI_NODE),
    Some(&WORD_CONJ_NODE),
    None,
    Some(&WORD_CONL_NODE),
    Some(&WORD_CONM_NODE),
    Some(&WORD_CONN_NODE),
    Some(&WORD_CONO_NODE),
    Some(&WORD_CONP_NODE),
    Some(&WORD_CONQ_NODE),
    Some(&WORD_CONR_NODE),
    Some(&WORD_CONS_NODE),
    Some(&WORD_CONT_NODE),
    Some(&WORD_CONU_NODE),
    Some(&WORD_CONV_NODE),
    None,
    None,
    Some(&WORD_CONY_NODE),
    None,
];

static WORD_CONY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONY_CHILDREN),
    value: None,
};

pub static WORD_CONY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ak")],
    values: &[&["cognac"]],
    range: 2..=2,
};

static WORD_CONV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_CONV_CHILDREN),
    value: None,
};

static WORD_CONV_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_CONVA_NODE),
    None,
    Some(&WORD_CONVC_NODE),
    None,
    Some(&WORD_CONVE_NODE),
    None,
    None,
    None,
    Some(&WORD_CONVI_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_CONVO_NODE),
    None,
    None,
    Some(&WORD_CONVR_NODE),
    Some(&WORD_CONVS_NODE),
    None,
    Some(&WORD_CONVU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_CONVU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONVU_CHILDREN),
    value: None,
};

pub static WORD_CONVU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("lated"),
        dictgen::InsensitiveStr::Ascii("luted"),
    ],
    values: &[&["convoluted"], &["convoluted"]],
    range: 5..=5,
};

static WORD_CONVS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONVS_CHILDREN),
    value: None,
};

pub static WORD_CONVS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eration"),
        dictgen::InsensitiveStr::Ascii("erion"),
    ],
    values: &[&["conservation"], &["conversion"]],
    range: 5..=7,
};

static WORD_CONVR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONVR_CHILDREN),
    value: None,
};

pub static WORD_CONVR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("t")],
    values: &[&["convert"]],
    range: 1..=1,
};

static WORD_CONVO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONVO_CHILDREN),
    value: None,
};

pub static WORD_CONVO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("luded"),
        dictgen::InsensitiveStr::Ascii("rsation"),
        dictgen::InsensitiveStr::Ascii("rsations"),
        dictgen::InsensitiveStr::Ascii("ulted"),
        dictgen::InsensitiveStr::Ascii("ultion"),
        dictgen::InsensitiveStr::Ascii("ultions"),
        dictgen::InsensitiveStr::Ascii("vle"),
        dictgen::InsensitiveStr::Ascii("vled"),
        dictgen::InsensitiveStr::Ascii("vling"),
    ],
    values: &[
        &["convoluted"],
        &["conversation"],
        &["conversations"],
        &["convoluted"],
        &["convolution"],
        &["convolutions"],
        &["convolve"],
        &["convolved"],
        &["convolving"],
    ],
    range: 3..=8,
};

static WORD_CONVI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONVI_CHILDREN),
    value: None,
};

pub static WORD_CONVI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ccion"),
        dictgen::InsensitiveStr::Ascii("ced"),
        dictgen::InsensitiveStr::Ascii("citon"),
        dictgen::InsensitiveStr::Ascii("citons"),
        dictgen::InsensitiveStr::Ascii("cto"),
        dictgen::InsensitiveStr::Ascii("enant"),
        dictgen::InsensitiveStr::Ascii("ence"),
        dictgen::InsensitiveStr::Ascii("encece"),
        dictgen::InsensitiveStr::Ascii("enence"),
        dictgen::InsensitiveStr::Ascii("enent"),
        dictgen::InsensitiveStr::Ascii("enently"),
        dictgen::InsensitiveStr::Ascii("enience"),
        dictgen::InsensitiveStr::Ascii("enient"),
        dictgen::InsensitiveStr::Ascii("eniently"),
        dictgen::InsensitiveStr::Ascii("ent"),
        dictgen::InsensitiveStr::Ascii("ently"),
        dictgen::InsensitiveStr::Ascii("guration"),
        dictgen::InsensitiveStr::Ascii("gure"),
        dictgen::InsensitiveStr::Ascii("luted"),
        dictgen::InsensitiveStr::Ascii("nation"),
        dictgen::InsensitiveStr::Ascii("nceing"),
        dictgen::InsensitiveStr::Ascii("ncente"),
        dictgen::InsensitiveStr::Ascii("ncersi"),
        dictgen::InsensitiveStr::Ascii("ncted"),
        dictgen::InsensitiveStr::Ascii("ne"),
        dictgen::InsensitiveStr::Ascii("neance"),
        dictgen::InsensitiveStr::Ascii("neances"),
        dictgen::InsensitiveStr::Ascii("ned"),
        dictgen::InsensitiveStr::Ascii("neient"),
        dictgen::InsensitiveStr::Ascii("nence"),
        dictgen::InsensitiveStr::Ascii("nences"),
        dictgen::InsensitiveStr::Ascii("nent"),
        dictgen::InsensitiveStr::Ascii("nently"),
        dictgen::InsensitiveStr::Ascii("ngi"),
        dictgen::InsensitiveStr::Ascii("niance"),
        dictgen::InsensitiveStr::Ascii("niances"),
        dictgen::InsensitiveStr::Ascii("nience"),
        dictgen::InsensitiveStr::Ascii("niences"),
        dictgen::InsensitiveStr::Ascii("niency"),
        dictgen::InsensitiveStr::Ascii("niencys"),
        dictgen::InsensitiveStr::Ascii("nient"),
        dictgen::InsensitiveStr::Ascii("niently"),
        dictgen::InsensitiveStr::Ascii("ning"),
        dictgen::InsensitiveStr::Ascii("nse"),
        dictgen::InsensitiveStr::Ascii("nsing"),
        dictgen::InsensitiveStr::Ascii("nve"),
        dictgen::InsensitiveStr::Ascii("nved"),
        dictgen::InsensitiveStr::Ascii("nving"),
        dictgen::InsensitiveStr::Ascii("rted"),
        dictgen::InsensitiveStr::Ascii("rtible"),
        dictgen::InsensitiveStr::Ascii("rting"),
        dictgen::InsensitiveStr::Ascii("sed"),
    ],
    values: &[
        &["conviction"],
        &["convinced"],
        &["conviction"],
        &["convictions"],
        &["conviction"],
        &["convenient"],
        &["convince", "convenience"],
        &["convenience"],
        &["convenience"],
        &["convenient"],
        &["conveniently"],
        &["convenience"],
        &["convenient"],
        &["conveniently"],
        &["convenient", "convent"],
        &["conveniently"],
        &["configuration"],
        &["configure"],
        &["convoluted"],
        &["combination"],
        &["convincing"],
        &["convenient"],
        &["convinces"],
        &["convince"],
        &["convince", "combine"],
        &["convenience"],
        &["conveniences"],
        &["combined", "convinced"],
        &["convenient"],
        &["convenience"],
        &["conveniences"],
        &["convenient"],
        &["conveniently"],
        &["convincing"],
        &["convenience"],
        &["conveniences"],
        &["convenience"],
        &["conveniences"],
        &["convenience"],
        &["conveniences"],
        &["convenient"],
        &["conveniently"],
        &["combining"],
        &["convinces"],
        &["convincing"],
        &["convince"],
        &["convinced"],
        &["convincing"],
        &["converted"],
        &["convertible"],
        &["converting"],
        &["convinced"],
    ],
    range: 2..=8,
};

static WORD_CONVE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_CONVE_CHILDREN),
    value: None,
};

static WORD_CONVE_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_CONVEI_NODE),
    None,
    None,
    Some(&WORD_CONVEL_NODE),
    None,
    Some(&WORD_CONVEN_NODE),
    None,
    None,
    None,
    Some(&WORD_CONVER_NODE),
    Some(&WORD_CONVES_NODE),
    Some(&WORD_CONVET_NODE),
    None,
    None,
    None,
    Some(&WORD_CONVEX_NODE),
    Some(&WORD_CONVEY_NODE),
    None,
];

static WORD_CONVEY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONVEY_CHILDREN),
    value: None,
};

pub static WORD_CONVEY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("d"),
        dictgen::InsensitiveStr::Ascii("ered"),
    ],
    values: &[&["conveyed"], &["conveyed"]],
    range: 1..=4,
};

static WORD_CONVEX_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONVEX_CHILDREN),
    value: None,
};

pub static WORD_CONVEX_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("e")],
    values: &[&["convex", "convexes"]],
    range: 1..=1,
};

static WORD_CONVET_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONVET_CHILDREN),
    value: Some(&["convert"]),
};

pub static WORD_CONVET_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("er"),
        dictgen::InsensitiveStr::Ascii("ers"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("ion"),
        dictgen::InsensitiveStr::Ascii("ions"),
        dictgen::InsensitiveStr::Ascii("s"),
    ],
    values: &[
        &["converted"],
        &["converter"],
        &["converters"],
        &["converting"],
        &["convention"],
        &["conventions"],
        &["converts"],
    ],
    range: 1..=4,
};

static WORD_CONVES_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONVES_CHILDREN),
    value: None,
};

pub static WORD_CONVES_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ion"),
        dictgen::InsensitiveStr::Ascii("ions"),
        dictgen::InsensitiveStr::Ascii("ration"),
    ],
    values: &[&["conversion"], &["conversions"], &["conservation"]],
    range: 3..=6,
};

static WORD_CONVER_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_CONVER_CHILDREN),
    value: Some(&["convert"]),
};

static WORD_CONVER_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_CONVERA_NODE),
    None,
    None,
    Some(&WORD_CONVERD_NODE),
    Some(&WORD_CONVERE_NODE),
    None,
    Some(&WORD_CONVERG_NODE),
    None,
    Some(&WORD_CONVERI_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_CONVERN_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_CONVERS_NODE),
    Some(&WORD_CONVERT_NODE),
    None,
    Some(&WORD_CONVERV_NODE),
    None,
    None,
    Some(&WORD_CONVERY_NODE),
    Some(&WORD_CONVERZ_NODE),
];

static WORD_CONVERZ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONVERZ_CHILDREN),
    value: None,
};

pub static WORD_CONVERZ_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[dictgen::InsensitiveStr::Ascii("ation")],
        values: &[&["conservation"]],
        range: 5..=5,
    };

static WORD_CONVERY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONVERY_CHILDREN),
    value: Some(&["convert"]),
};

pub static WORD_CONVERY_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[dictgen::InsensitiveStr::Ascii("ing")],
        values: &[&["converting"]],
        range: 3..=3,
    };

static WORD_CONVERV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONVERV_CHILDREN),
    value: None,
};

pub static WORD_CONVERV_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("able"),
            dictgen::InsensitiveStr::Ascii("ation"),
            dictgen::InsensitiveStr::Ascii("atism"),
            dictgen::InsensitiveStr::Ascii("ative"),
            dictgen::InsensitiveStr::Ascii("atives"),
            dictgen::InsensitiveStr::Ascii("e"),
            dictgen::InsensitiveStr::Ascii("ed"),
            dictgen::InsensitiveStr::Ascii("er"),
            dictgen::InsensitiveStr::Ascii("ers"),
            dictgen::InsensitiveStr::Ascii("es"),
            dictgen::InsensitiveStr::Ascii("ing"),
        ],
        values: &[
            &["conservable"],
            &["conservation", "conversation"],
            &["conservatism"],
            &["conservative"],
            &["conservatives"],
            &["conserve", "converse"],
            &["conserved", "conversed"],
            &["conserver", "converter"],
            &["conservers"],
            &["conserves", "converses"],
            &["conserving", "conversing"],
        ],
        range: 1..=6,
    };

static WORD_CONVERT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONVERT_CHILDREN),
    value: None,
};

pub static WORD_CONVERT_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("able"),
            dictgen::InsensitiveStr::Ascii("ables"),
            dictgen::InsensitiveStr::Ascii("ation"),
            dictgen::InsensitiveStr::Ascii("ations"),
            dictgen::InsensitiveStr::Ascii("erd"),
            dictgen::InsensitiveStr::Ascii("et"),
            dictgen::InsensitiveStr::Ascii("iable"),
            dictgen::InsensitiveStr::Ascii("ibile"),
            dictgen::InsensitiveStr::Ascii("ie"),
            dictgen::InsensitiveStr::Ascii("ion"),
            dictgen::InsensitiveStr::Ascii("ions"),
            dictgen::InsensitiveStr::Ascii("ire"),
            dictgen::InsensitiveStr::Ascii("irea"),
            dictgen::InsensitiveStr::Ascii("irle"),
            dictgen::InsensitiveStr::Ascii("irme"),
            dictgen::InsensitiveStr::Ascii("irte"),
            dictgen::InsensitiveStr::Ascii("is"),
            dictgen::InsensitiveStr::Ascii("r"),
        ],
        values: &[
            &["convertible"],
            &["convertibles"],
            &["conversation", "conversion"],
            &["conversations", "conversions"],
            &["converted", "converter"],
            &["converted"],
            &["convertible"],
            &["convertible"],
            &["convertible"],
            &["conversion"],
            &["conversions"],
            &["converter"],
            &["converter"],
            &["convertible"],
            &["converter"],
            &["converter"],
            &["converts"],
            &["converter"],
        ],
        range: 1..=6,
    };

static WORD_CONVERS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONVERS_CHILDREN),
    value: Some(&["converts", "converse", "convert"]),
};

pub static WORD_CONVERS_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("acion"),
            dictgen::InsensitiveStr::Ascii("acional"),
            dictgen::InsensitiveStr::Ascii("aion"),
            dictgen::InsensitiveStr::Ascii("aiton"),
            dictgen::InsensitiveStr::Ascii("are"),
            dictgen::InsensitiveStr::Ascii("atin"),
            dictgen::InsensitiveStr::Ascii("atino"),
            dictgen::InsensitiveStr::Ascii("ationa"),
            dictgen::InsensitiveStr::Ascii("ationable"),
            dictgen::InsensitiveStr::Ascii("ationg"),
            dictgen::InsensitiveStr::Ascii("ationy"),
            dictgen::InsensitiveStr::Ascii("atiosn"),
            dictgen::InsensitiveStr::Ascii("atism"),
            dictgen::InsensitiveStr::Ascii("atives"),
            dictgen::InsensitiveStr::Ascii("atoin"),
            dictgen::InsensitiveStr::Ascii("eley"),
            dictgen::InsensitiveStr::Ascii("ie"),
            dictgen::InsensitiveStr::Ascii("in"),
            dictgen::InsensitiveStr::Ascii("ino"),
            dictgen::InsensitiveStr::Ascii("iones"),
            dictgen::InsensitiveStr::Ascii("ley"),
            dictgen::InsensitiveStr::Ascii("ly"),
            dictgen::InsensitiveStr::Ascii("oin"),
            dictgen::InsensitiveStr::Ascii("on"),
            dictgen::InsensitiveStr::Ascii("ons"),
            dictgen::InsensitiveStr::Ascii("sion"),
            dictgen::InsensitiveStr::Ascii("t"),
            dictgen::InsensitiveStr::Ascii("taion"),
            dictgen::InsensitiveStr::Ascii("taional"),
            dictgen::InsensitiveStr::Ascii("taions"),
            dictgen::InsensitiveStr::Ascii("tion"),
            dictgen::InsensitiveStr::Ascii("tions"),
            dictgen::InsensitiveStr::Ascii("ton"),
            dictgen::InsensitiveStr::Ascii("tons"),
        ],
        values: &[
            &["conversation"],
            &["conversational"],
            &["conversion"],
            &["conversations"],
            &["converse"],
            &["conversations"],
            &["conservation"],
            &["conservation"],
            &["conversational"],
            &["conservation"],
            &["conservation"],
            &["conservation"],
            &["conservatism"],
            &["conservatives"],
            &["conversations"],
            &["conversely"],
            &["converse"],
            &["conversions"],
            &["conversions"],
            &["conversions"],
            &["conversely"],
            &["conversely"],
            &["conversions", "conversion"],
            &["conversion"],
            &["conversions"],
            &["conversion"],
            &["converts", "convert"],
            &["conversation"],
            &["conversational"],
            &["conversations"],
            &["conversion", "conversation"],
            &["conversions", "conversations"],
            &["conversation", "conversion"],
            &["conversations", "conversions"],
        ],
        range: 1..=9,
    };

static WORD_CONVERN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONVERN_CHILDREN),
    value: None,
};

pub static WORD_CONVERN_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[dictgen::InsensitiveStr::Ascii("ing")],
        values: &[&["converting"]],
        range: 3..=3,
    };

static WORD_CONVERI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONVERI_CHILDREN),
    value: None,
};

pub static WORD_CONVERI_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("ng"),
            dictgen::InsensitiveStr::Ascii("on"),
            dictgen::InsensitiveStr::Ascii("ons"),
            dictgen::InsensitiveStr::Ascii("son"),
            dictgen::InsensitiveStr::Ascii("tble"),
        ],
        values: &[
            &["converting", "covering"],
            &["conversion"],
            &["conversions"],
            &["conversions", "conversion"],
            &["convertible"],
        ],
        range: 2..=4,
    };

static WORD_CONVERG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONVERG_CHILDREN),
    value: None,
};

pub static WORD_CONVERG_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("ance"),
            dictgen::InsensitiveStr::Ascii("ens"),
        ],
        values: &[&["convergence"], &["converse"]],
        range: 3..=4,
    };

static WORD_CONVERE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONVERE_CHILDREN),
    value: None,
};

pub static WORD_CONVERE_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("d"),
            dictgen::InsensitiveStr::Ascii("sly"),
            dictgen::InsensitiveStr::Ascii("ted"),
        ],
        values: &[&["converted", "covered"], &["conversely"], &["converted"]],
        range: 1..=3,
    };

static WORD_CONVERD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONVERD_CHILDREN),
    value: None,
};

pub static WORD_CONVERD_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[dictgen::InsensitiveStr::Ascii("ation")],
        values: &[&["conservation"]],
        range: 5..=5,
    };

static WORD_CONVERA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONVERA_CHILDREN),
    value: None,
};

pub static WORD_CONVERA_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("ge"),
            dictgen::InsensitiveStr::Ascii("stion"),
            dictgen::InsensitiveStr::Ascii("stions"),
        ],
        values: &[
            &["converge", "coverage"],
            &["conversations"],
            &["conservation"],
        ],
        range: 2..=6,
    };

static WORD_CONVEN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONVEN_CHILDREN),
    value: None,
};

pub static WORD_CONVEN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ant"),
        dictgen::InsensitiveStr::Ascii("cen"),
        dictgen::InsensitiveStr::Ascii("cion"),
        dictgen::InsensitiveStr::Ascii("cional"),
        dictgen::InsensitiveStr::Ascii("cionally"),
        dictgen::InsensitiveStr::Ascii("ction"),
        dictgen::InsensitiveStr::Ascii("ctional"),
        dictgen::InsensitiveStr::Ascii("ctionally"),
        dictgen::InsensitiveStr::Ascii("eince"),
        dictgen::InsensitiveStr::Ascii("iance"),
        dictgen::InsensitiveStr::Ascii("iant"),
        dictgen::InsensitiveStr::Ascii("iantly"),
        dictgen::InsensitiveStr::Ascii("iece"),
        dictgen::InsensitiveStr::Ascii("iente"),
        dictgen::InsensitiveStr::Ascii("iet"),
        dictgen::InsensitiveStr::Ascii("ietly"),
        dictgen::InsensitiveStr::Ascii("ince"),
        dictgen::InsensitiveStr::Ascii("inent"),
        dictgen::InsensitiveStr::Ascii("ion"),
        dictgen::InsensitiveStr::Ascii("ions"),
        dictgen::InsensitiveStr::Ascii("it"),
        dictgen::InsensitiveStr::Ascii("se"),
        dictgen::InsensitiveStr::Ascii("sion"),
        dictgen::InsensitiveStr::Ascii("tial"),
        dictgen::InsensitiveStr::Ascii("tient"),
        dictgen::InsensitiveStr::Ascii("tinal"),
        dictgen::InsensitiveStr::Ascii("tionnal"),
        dictgen::InsensitiveStr::Ascii("to"),
        dictgen::InsensitiveStr::Ascii("vient"),
    ],
    values: &[
        &["covenant"],
        &["convenience"],
        &["convention"],
        &["conventional"],
        &["conventionally"],
        &["convention", "convection"],
        &["conventional"],
        &["conventionally"],
        &["convenience"],
        &["convenience"],
        &["convenient"],
        &["conveniently"],
        &["convenience"],
        &["convenience"],
        &["convenient"],
        &["conveniently"],
        &["convenience"],
        &["convenient"],
        &["convention"],
        &["conventions"],
        &["convenient"],
        &["convince"],
        &["convention", "conversion"],
        &["conventional"],
        &["convenient"],
        &["conventional"],
        &["conventional"],
        &["convention"],
        &["convenient"],
    ],
    range: 2..=9,
};

static WORD_CONVEL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONVEL_CHILDREN),
    value: None,
};

pub static WORD_CONVEL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("uted")],
    values: &[&["convoluted"]],
    range: 4..=4,
};

static WORD_CONVEI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONVEI_CHILDREN),
    value: None,
};

pub static WORD_CONVEI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ence"),
        dictgen::InsensitiveStr::Ascii("nence"),
        dictgen::InsensitiveStr::Ascii("nences"),
        dictgen::InsensitiveStr::Ascii("nent"),
        dictgen::InsensitiveStr::Ascii("nently"),
        dictgen::InsensitiveStr::Ascii("nience"),
        dictgen::InsensitiveStr::Ascii("nient"),
    ],
    values: &[
        &["convenience"],
        &["convenience"],
        &["conveniences"],
        &["convenient"],
        &["conveniently"],
        &["convenience"],
        &["convenient"],
    ],
    range: 4..=6,
};

static WORD_CONVC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONVC_CHILDREN),
    value: None,
};

pub static WORD_CONVC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ition")],
    values: &[&["convictions"]],
    range: 5..=5,
};

static WORD_CONVA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONVA_CHILDREN),
    value: None,
};

pub static WORD_CONVA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("less"),
        dictgen::InsensitiveStr::Ascii("luted"),
        dictgen::InsensitiveStr::Ascii("x"),
        dictgen::InsensitiveStr::Ascii("xiity"),
        dictgen::InsensitiveStr::Ascii("xly"),
        dictgen::InsensitiveStr::Ascii("xness"),
    ],
    values: &[
        &["convalesce"],
        &["convoluted"],
        &["convex"],
        &["convexity"],
        &["convexly"],
        &["convexness"],
    ],
    range: 1..=5,
};

static WORD_CONU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONU_CHILDREN),
    value: None,
};

pub static WORD_CONU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ntry"),
        dictgen::InsensitiveStr::Ascii("smer"),
    ],
    values: &[&["country"], &["consumer"]],
    range: 4..=4,
};

static WORD_CONT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_CONT_CHILDREN),
    value: None,
};

static WORD_CONT_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_CONTA_NODE),
    None,
    None,
    None,
    Some(&WORD_CONTE_NODE),
    None,
    None,
    None,
    Some(&WORD_CONTI_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_CONTN_NODE),
    Some(&WORD_CONTO_NODE),
    None,
    None,
    Some(&WORD_CONTR_NODE),
    Some(&WORD_CONTS_NODE),
    Some(&WORD_CONTT_NODE),
    Some(&WORD_CONTU_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_CONTZ_NODE),
];

static WORD_CONTZ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONTZ_CHILDREN),
    value: None,
};

pub static WORD_CONTZ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ains")],
    values: &[&["contains"]],
    range: 4..=4,
};

static WORD_CONTU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONTU_CHILDREN),
    value: None,
};

pub static WORD_CONTU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ining"),
        dictgen::InsensitiveStr::Ascii("inity"),
        dictgen::InsensitiveStr::Ascii("r"),
    ],
    values: &[&["continuing"], &["continuity"], &["contour"]],
    range: 1..=5,
};

static WORD_CONTT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONTT_CHILDREN),
    value: None,
};

pub static WORD_CONTT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ribute"),
        dictgen::InsensitiveStr::Ascii("ributed"),
        dictgen::InsensitiveStr::Ascii("ributes"),
        dictgen::InsensitiveStr::Ascii("ributing"),
        dictgen::InsensitiveStr::Ascii("ribution"),
        dictgen::InsensitiveStr::Ascii("ributions"),
    ],
    values: &[
        &["contribute"],
        &["contributed"],
        &["contributes"],
        &["contributing"],
        &["contribution"],
        &["contributions"],
    ],
    range: 6..=9,
};

static WORD_CONTS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONTS_CHILDREN),
    value: None,
};

pub static WORD_CONTS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ruction"),
        dictgen::InsensitiveStr::Ascii("ructor"),
        dictgen::InsensitiveStr::Ascii("tant"),
        dictgen::InsensitiveStr::Ascii("tants"),
        dictgen::InsensitiveStr::Ascii("traint"),
        dictgen::InsensitiveStr::Ascii("truct"),
        dictgen::InsensitiveStr::Ascii("tructed"),
        dictgen::InsensitiveStr::Ascii("tructing"),
        dictgen::InsensitiveStr::Ascii("truction"),
        dictgen::InsensitiveStr::Ascii("tructor"),
        dictgen::InsensitiveStr::Ascii("tructors"),
        dictgen::InsensitiveStr::Ascii("tructs"),
    ],
    values: &[
        &["construction"],
        &["constructor"],
        &["constant"],
        &["constants"],
        &["constraint"],
        &["construct"],
        &["constructed"],
        &["constructing"],
        &["construction"],
        &["constructor"],
        &["constructors"],
        &["constructs"],
    ],
    range: 4..=8,
};

static WORD_CONTR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_CONTR_CHILDREN),
    value: None,
};

static WORD_CONTR_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_CONTRA_NODE),
    Some(&WORD_CONTRB_NODE),
    None,
    None,
    Some(&WORD_CONTRE_NODE),
    None,
    None,
    None,
    Some(&WORD_CONTRI_NODE),
    None,
    None,
    Some(&WORD_CONTRL_NODE),
    None,
    None,
    Some(&WORD_CONTRO_NODE),
    None,
    None,
    Some(&WORD_CONTRR_NODE),
    Some(&WORD_CONTRS_NODE),
    Some(&WORD_CONTRT_NODE),
    Some(&WORD_CONTRU_NODE),
    None,
    None,
    None,
    Some(&WORD_CONTRY_NODE),
    None,
];

static WORD_CONTRY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONTRY_CHILDREN),
    value: Some(&["country"]),
};

pub static WORD_CONTRY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ie")],
    values: &[&["countryie"]],
    range: 2..=2,
};

static WORD_CONTRU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONTRU_CHILDREN),
    value: None,
};

pub static WORD_CONTRU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("bite"),
        dictgen::InsensitiveStr::Ascii("bute"),
        dictgen::InsensitiveStr::Ascii("butes"),
        dictgen::InsensitiveStr::Ascii("ct"),
        dictgen::InsensitiveStr::Ascii("cted"),
        dictgen::InsensitiveStr::Ascii("cting"),
        dictgen::InsensitiveStr::Ascii("ction"),
        dictgen::InsensitiveStr::Ascii("ctions"),
        dictgen::InsensitiveStr::Ascii("ctor"),
        dictgen::InsensitiveStr::Ascii("ctors"),
        dictgen::InsensitiveStr::Ascii("cts"),
    ],
    values: &[
        &["contributes"],
        &["contribute"],
        &["contributes"],
        &["construct"],
        &["constructed"],
        &["contracting", "constructing"],
        &["construction"],
        &["contractions", "constructions"],
        &["constructor"],
        &["contractors", "constructors"],
        &["constructs"],
    ],
    range: 2..=6,
};

static WORD_CONTRT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONTRT_CHILDREN),
    value: None,
};

pub static WORD_CONTRT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("oller")],
    values: &[&["controller"]],
    range: 5..=5,
};

static WORD_CONTRS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONTRS_CHILDREN),
    value: None,
};

pub static WORD_CONTRS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("ted"),
        dictgen::InsensitiveStr::Ascii("ting"),
        dictgen::InsensitiveStr::Ascii("ts"),
    ],
    values: &[
        &["contrast"],
        &["contrasted"],
        &["contrasting"],
        &["contrasts"],
    ],
    range: 1..=4,
};

static WORD_CONTRR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONTRR_CHILDREN),
    value: None,
};

pub static WORD_CONTRR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ol"),
        dictgen::InsensitiveStr::Ascii("ols"),
    ],
    values: &[&["control"], &["controls"]],
    range: 2..=3,
};

static WORD_CONTRO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONTRO_CHILDREN),
    value: Some(&["control"]),
};

pub static WORD_CONTRO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ception"),
        dictgen::InsensitiveStr::Ascii("ceptives"),
        dictgen::InsensitiveStr::Ascii("dicting"),
        dictgen::InsensitiveStr::Ascii("diction"),
        dictgen::InsensitiveStr::Ascii("dictions"),
        dictgen::InsensitiveStr::Ascii("lable"),
        dictgen::InsensitiveStr::Ascii("las"),
        dictgen::InsensitiveStr::Ascii("le"),
        dictgen::InsensitiveStr::Ascii("led"),
        dictgen::InsensitiveStr::Ascii("lelr"),
        dictgen::InsensitiveStr::Ascii("lelrs"),
        dictgen::InsensitiveStr::Ascii("ler"),
        dictgen::InsensitiveStr::Ascii("lers"),
        dictgen::InsensitiveStr::Ascii("les"),
        dictgen::InsensitiveStr::Ascii("leurs"),
        dictgen::InsensitiveStr::Ascii("ling"),
        dictgen::InsensitiveStr::Ascii("ll"),
        dictgen::InsensitiveStr::Ascii("lleras"),
        dictgen::InsensitiveStr::Ascii("llerd"),
        dictgen::InsensitiveStr::Ascii("lles"),
        dictgen::InsensitiveStr::Ascii("llled"),
        dictgen::InsensitiveStr::Ascii("lller"),
        dictgen::InsensitiveStr::Ascii("lllers"),
        dictgen::InsensitiveStr::Ascii("llling"),
        dictgen::InsensitiveStr::Ascii("llor"),
        dictgen::InsensitiveStr::Ascii("llore"),
        dictgen::InsensitiveStr::Ascii("lls"),
        dictgen::InsensitiveStr::Ascii("nl"),
        dictgen::InsensitiveStr::Ascii("nls"),
        dictgen::InsensitiveStr::Ascii("oler"),
        dictgen::InsensitiveStr::Ascii("vercial"),
        dictgen::InsensitiveStr::Ascii("vercy"),
        dictgen::InsensitiveStr::Ascii("verial"),
        dictgen::InsensitiveStr::Ascii("veries"),
        dictgen::InsensitiveStr::Ascii("verisal"),
        dictgen::InsensitiveStr::Ascii("versa"),
        dictgen::InsensitiveStr::Ascii("versal"),
        dictgen::InsensitiveStr::Ascii("versary"),
        dictgen::InsensitiveStr::Ascii("versey"),
        dictgen::InsensitiveStr::Ascii("versials"),
        dictgen::InsensitiveStr::Ascii("versity"),
        dictgen::InsensitiveStr::Ascii("vertial"),
        dictgen::InsensitiveStr::Ascii("very"),
        dictgen::InsensitiveStr::Ascii("vesy"),
    ],
    values: &[
        &["contraception"],
        &["contraceptives"],
        &["contradicting"],
        &["contradiction"],
        &["contradictions"],
        &["controllable"],
        &["controls"],
        &["control", "controlled", "controller", "controls"],
        &["controlled"],
        &["controllers"],
        &["controllers"],
        &["controller"],
        &["controls", "controllers"],
        &["controls", "controllers"],
        &["controllers"],
        &["controlling"],
        &["control"],
        &["controllers"],
        &["controlled"],
        &["controls"],
        &["controlled"],
        &["controller"],
        &["controllers"],
        &["controlling"],
        &["controller"],
        &["controllers"],
        &["controls"],
        &["control"],
        &["controls"],
        &["controller"],
        &["controversial"],
        &["controversy"],
        &["controversial"],
        &["controversies"],
        &["controversial"],
        &["controversial"],
        &["controversial"],
        &["controversy"],
        &["controversy"],
        &["controversial"],
        &["controversy"],
        &["controversial"],
        &["controversy"],
        &["controversy"],
    ],
    range: 2..=8,
};

static WORD_CONTRL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONTRL_CHILDREN),
    value: Some(&["control"]),
};

pub static WORD_CONTRL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ler")],
    values: &[&["controller"]],
    range: 3..=3,
};

static WORD_CONTRI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONTRI_CHILDREN),
    value: None,
};

pub static WORD_CONTRI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("bte"),
        dictgen::InsensitiveStr::Ascii("bted"),
        dictgen::InsensitiveStr::Ascii("btes"),
        dictgen::InsensitiveStr::Ascii("bucion"),
        dictgen::InsensitiveStr::Ascii("bue"),
        dictgen::InsensitiveStr::Ascii("bued"),
        dictgen::InsensitiveStr::Ascii("buem"),
        dictgen::InsensitiveStr::Ascii("buent"),
        dictgen::InsensitiveStr::Ascii("buer"),
        dictgen::InsensitiveStr::Ascii("bues"),
        dictgen::InsensitiveStr::Ascii("buie"),
        dictgen::InsensitiveStr::Ascii("buit"),
        dictgen::InsensitiveStr::Ascii("buito"),
        dictgen::InsensitiveStr::Ascii("buitor"),
        dictgen::InsensitiveStr::Ascii("buo"),
        dictgen::InsensitiveStr::Ascii("buter"),
        dictgen::InsensitiveStr::Ascii("buters"),
        dictgen::InsensitiveStr::Ascii("buteurs"),
        dictgen::InsensitiveStr::Ascii("butie"),
        dictgen::InsensitiveStr::Ascii("butin"),
        dictgen::InsensitiveStr::Ascii("butiors"),
        dictgen::InsensitiveStr::Ascii("butivo"),
        dictgen::InsensitiveStr::Ascii("buto"),
        dictgen::InsensitiveStr::Ascii("butons"),
        dictgen::InsensitiveStr::Ascii("butos"),
        dictgen::InsensitiveStr::Ascii("buts"),
        dictgen::InsensitiveStr::Ascii("buye"),
        dictgen::InsensitiveStr::Ascii("buyes"),
        dictgen::InsensitiveStr::Ascii("ception"),
        dictgen::InsensitiveStr::Ascii("ceptives"),
        dictgen::InsensitiveStr::Ascii("cted"),
        dictgen::InsensitiveStr::Ascii("cting"),
        dictgen::InsensitiveStr::Ascii("ction"),
        dictgen::InsensitiveStr::Ascii("ctions"),
        dictgen::InsensitiveStr::Ascii("dict"),
        dictgen::InsensitiveStr::Ascii("dicted"),
        dictgen::InsensitiveStr::Ascii("dictory"),
        dictgen::InsensitiveStr::Ascii("dicts"),
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("nution"),
        dictgen::InsensitiveStr::Ascii("nutions"),
        dictgen::InsensitiveStr::Ascii("tutions"),
        dictgen::InsensitiveStr::Ascii("ubte"),
        dictgen::InsensitiveStr::Ascii("ubted"),
        dictgen::InsensitiveStr::Ascii("ubtes"),
        dictgen::InsensitiveStr::Ascii("ubting"),
        dictgen::InsensitiveStr::Ascii("ubtion"),
        dictgen::InsensitiveStr::Ascii("ubtions"),
        dictgen::InsensitiveStr::Ascii("versial"),
        dictgen::InsensitiveStr::Ascii("versy"),
    ],
    values: &[
        &["contribute"],
        &["contributed"],
        &["contributes"],
        &["contribution"],
        &["contribute"],
        &["contributed"],
        &["contribute"],
        &["contribute"],
        &["contribute"],
        &["contributes"],
        &["contribute"],
        &["contribute"],
        &["contribution"],
        &["contributor"],
        &["contributor"],
        &["contributor"],
        &["contributors"],
        &["contributes"],
        &["contribute"],
        &["contribution"],
        &["contributors"],
        &["contribution"],
        &["contribution"],
        &["contributors"],
        &["contributors"],
        &["contributes"],
        &["contribute"],
        &["contributes"],
        &["contraception"],
        &["contraceptives"],
        &["contracted"],
        &["contracting"],
        &["contraction"],
        &["contractions"],
        &["contradict"],
        &["contradicted"],
        &["contradictory"],
        &["contradicts"],
        &["countries"],
        &["contribution"],
        &["contributions"],
        &["contributions"],
        &["contributes", "contribute"],
        &["contributed"],
        &["contributes"],
        &["contributing"],
        &["contribution"],
        &["contributions"],
        &["controversial"],
        &["controversy"],
    ],
    range: 2..=8,
};

static WORD_CONTRE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONTRE_CHILDREN),
    value: None,
};

pub static WORD_CONTRE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ception"),
        dictgen::InsensitiveStr::Ascii("dict"),
        dictgen::InsensitiveStr::Ascii("te"),
        dictgen::InsensitiveStr::Ascii("tely"),
        dictgen::InsensitiveStr::Ascii("versial"),
        dictgen::InsensitiveStr::Ascii("versy"),
    ],
    values: &[
        &["contraception"],
        &["contradict"],
        &["concrete"],
        &["concretely"],
        &["controversial"],
        &["controversy"],
    ],
    range: 2..=7,
};

static WORD_CONTRB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONTRB_CHILDREN),
    value: None,
};

pub static WORD_CONTRB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ution")],
    values: &[&["contribution"]],
    range: 5..=5,
};

static WORD_CONTRA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONTRA_CHILDREN),
    value: None,
};

pub static WORD_CONTRA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("bution"),
        dictgen::InsensitiveStr::Ascii("ccion"),
        dictgen::InsensitiveStr::Ascii("ceptie"),
        dictgen::InsensitiveStr::Ascii("ceptivo"),
        dictgen::InsensitiveStr::Ascii("ceptivos"),
        dictgen::InsensitiveStr::Ascii("ciction"),
        dictgen::InsensitiveStr::Ascii("cictions"),
        dictgen::InsensitiveStr::Ascii("cing"),
        dictgen::InsensitiveStr::Ascii("cition"),
        dictgen::InsensitiveStr::Ascii("citions"),
        dictgen::InsensitiveStr::Ascii("cr"),
        dictgen::InsensitiveStr::Ascii("cs"),
        dictgen::InsensitiveStr::Ascii("ctar"),
        dictgen::InsensitiveStr::Ascii("cter"),
        dictgen::InsensitiveStr::Ascii("cters"),
        dictgen::InsensitiveStr::Ascii("ctin"),
        dictgen::InsensitiveStr::Ascii("cto"),
        dictgen::InsensitiveStr::Ascii("ctos"),
        dictgen::InsensitiveStr::Ascii("ddice"),
        dictgen::InsensitiveStr::Ascii("dically"),
        dictgen::InsensitiveStr::Ascii("diccion"),
        dictgen::InsensitiveStr::Ascii("dice"),
        dictgen::InsensitiveStr::Ascii("dices"),
        dictgen::InsensitiveStr::Ascii("dicing"),
        dictgen::InsensitiveStr::Ascii("dicion"),
        dictgen::InsensitiveStr::Ascii("dicitng"),
        dictgen::InsensitiveStr::Ascii("diciton"),
        dictgen::InsensitiveStr::Ascii("dicitons"),
        dictgen::InsensitiveStr::Ascii("dicory"),
        dictgen::InsensitiveStr::Ascii("dics"),
        dictgen::InsensitiveStr::Ascii("dictary"),
        dictgen::InsensitiveStr::Ascii("dictie"),
        dictgen::InsensitiveStr::Ascii("dictin"),
        dictgen::InsensitiveStr::Ascii("dictiong"),
        dictgen::InsensitiveStr::Ascii("dicton"),
        dictgen::InsensitiveStr::Ascii("dictons"),
        dictgen::InsensitiveStr::Ascii("dtion"),
        dictgen::InsensitiveStr::Ascii("in"),
        dictgen::InsensitiveStr::Ascii("ined"),
        dictgen::InsensitiveStr::Ascii("iner"),
        dictgen::InsensitiveStr::Ascii("iners"),
        dictgen::InsensitiveStr::Ascii("ining"),
        dictgen::InsensitiveStr::Ascii("ins"),
        dictgen::InsensitiveStr::Ascii("int"),
        dictgen::InsensitiveStr::Ascii("inted"),
        dictgen::InsensitiveStr::Ascii("intes"),
        dictgen::InsensitiveStr::Ascii("ints"),
        dictgen::InsensitiveStr::Ascii("itns"),
        dictgen::InsensitiveStr::Ascii("se"),
        dictgen::InsensitiveStr::Ascii("ticted"),
        dictgen::InsensitiveStr::Ascii("ticting"),
        dictgen::InsensitiveStr::Ascii("veining"),
        dictgen::InsensitiveStr::Ascii("vercial"),
        dictgen::InsensitiveStr::Ascii("versial"),
        dictgen::InsensitiveStr::Ascii("versy"),
    ],
    values: &[
        &["contribution"],
        &["contraction"],
        &["contraceptives"],
        &["contraception"],
        &["contraceptives"],
        &["contradiction"],
        &["contradictions"],
        &["contracting"],
        &["contradiction"],
        &["contradictions"],
        &["contractor"],
        &["contracts"],
        &["contractor"],
        &["contractor"],
        &["contractors"],
        &["contraction"],
        &["contraction"],
        &["contracts"],
        &["contradicted"],
        &["contradictory"],
        &["contradiction"],
        &["contradicted"],
        &["contradicts"],
        &["contradicting"],
        &["contradiction"],
        &["contradicting"],
        &["contradiction"],
        &["contradictions"],
        &["contradictory"],
        &["contradicts"],
        &["contradictory"],
        &["contradicted"],
        &["contradiction"],
        &["contradicting"],
        &["contradiction"],
        &["contradicts"],
        &["contraction"],
        &["constrain"],
        &["contained", "constrained"],
        &["container", "constrained"],
        &["containers"],
        &["constraining"],
        &["constrains", "constraints"],
        &["constraint"],
        &["constrained"],
        &["constraints"],
        &["constraints"],
        &["constraints"],
        &["contrast"],
        &["contradicted"],
        &["contradicting"],
        &["contravening"],
        &["controversial"],
        &["controversial"],
        &["controversy"],
    ],
    range: 2..=8,
};

static WORD_CONTO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONTO_CHILDREN),
    value: None,
};

pub static WORD_CONTO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("l"),
        dictgen::InsensitiveStr::Ascii("ler"),
        dictgen::InsensitiveStr::Ascii("ller"),
        dictgen::InsensitiveStr::Ascii("llers"),
        dictgen::InsensitiveStr::Ascii("lls"),
        dictgen::InsensitiveStr::Ascii("ls"),
        dictgen::InsensitiveStr::Ascii("ngency"),
        dictgen::InsensitiveStr::Ascii("rl"),
        dictgen::InsensitiveStr::Ascii("rled"),
        dictgen::InsensitiveStr::Ascii("rller"),
        dictgen::InsensitiveStr::Ascii("rls"),
        dictgen::InsensitiveStr::Ascii("roller"),
    ],
    values: &[
        &["control"],
        &["controller"],
        &["controller"],
        &["controllers"],
        &["controls"],
        &["controls"],
        &["contingency"],
        &["control"],
        &["controlled"],
        &["controllers"],
        &["controls"],
        &["controller"],
    ],
    range: 1..=6,
};

static WORD_CONTN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONTN_CHILDREN),
    value: None,
};

pub static WORD_CONTN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("et"),
        dictgen::InsensitiveStr::Ascii("iue"),
        dictgen::InsensitiveStr::Ascii("iued"),
        dictgen::InsensitiveStr::Ascii("iues"),
        dictgen::InsensitiveStr::Ascii("t"),
    ],
    values: &[
        &["content"],
        &["continue"],
        &["continued"],
        &["continues"],
        &["content"],
    ],
    range: 1..=4,
};

static WORD_CONTI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_CONTI_CHILDREN),
    value: None,
};

static WORD_CONTI_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_CONTIA_NODE),
    Some(&WORD_CONTIB_NODE),
    None,
    None,
    Some(&WORD_CONTIE_NODE),
    None,
    Some(&WORD_CONTIG_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_CONTIM_NODE),
    Some(&WORD_CONTIN_NODE),
    Some(&WORD_CONTIO_NODE),
    None,
    None,
    Some(&WORD_CONTIR_NODE),
    None,
    Some(&WORD_CONTIT_NODE),
    Some(&WORD_CONTIU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_CONTIU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONTIU_CHILDREN),
    value: None,
};

pub static WORD_CONTIU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ation"),
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("guous"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("nal"),
        dictgen::InsensitiveStr::Ascii("nally"),
        dictgen::InsensitiveStr::Ascii("nation"),
        dictgen::InsensitiveStr::Ascii("ning"),
        dictgen::InsensitiveStr::Ascii("nity"),
    ],
    values: &[
        &["continuation"],
        &["continue"],
        &["contiguous"],
        &["continuing"],
        &["continual"],
        &["continually"],
        &["continuation"],
        &["containing"],
        &["continuity"],
    ],
    range: 1..=6,
};

static WORD_CONTIT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONTIT_CHILDREN),
    value: None,
};

pub static WORD_CONTIT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ion"),
        dictgen::InsensitiveStr::Ascii("ions"),
        dictgen::InsensitiveStr::Ascii("nent"),
    ],
    values: &[&["condition"], &["conditions"], &["contingent"]],
    range: 3..=4,
};

static WORD_CONTIR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONTIR_CHILDREN),
    value: None,
};

pub static WORD_CONTIR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("buted"),
        dictgen::InsensitiveStr::Ascii("bution"),
        dictgen::InsensitiveStr::Ascii("butors"),
    ],
    values: &[&["contributed"], &["contribution"], &["contributors"]],
    range: 5..=6,
};

static WORD_CONTIO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONTIO_CHILDREN),
    value: None,
};

pub static WORD_CONTIO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("us"),
        dictgen::InsensitiveStr::Ascii("usly"),
    ],
    values: &[&["continuous"], &["continuously"]],
    range: 2..=4,
};

static WORD_CONTIN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_CONTIN_CHILDREN),
    value: None,
};

static WORD_CONTIN_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_CONTINA_NODE),
    None,
    None,
    None,
    Some(&WORD_CONTINE_NODE),
    None,
    Some(&WORD_CONTING_NODE),
    None,
    Some(&WORD_CONTINI_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_CONTINO_NODE),
    None,
    None,
    None,
    Some(&WORD_CONTINS_NODE),
    Some(&WORD_CONTINT_NODE),
    Some(&WORD_CONTINU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_CONTINU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONTINU_CHILDREN),
    value: None,
};

pub static WORD_CONTINU_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("acion"),
            dictgen::InsensitiveStr::Ascii("aly"),
            dictgen::InsensitiveStr::Ascii("are"),
            dictgen::InsensitiveStr::Ascii("arla"),
            dictgen::InsensitiveStr::Ascii("arlo"),
            dictgen::InsensitiveStr::Ascii("asse"),
            dictgen::InsensitiveStr::Ascii("ati"),
            dictgen::InsensitiveStr::Ascii("ating"),
            dictgen::InsensitiveStr::Ascii("ativo"),
            dictgen::InsensitiveStr::Ascii("ato"),
            dictgen::InsensitiveStr::Ascii("eing"),
            dictgen::InsensitiveStr::Ascii("ely"),
            dictgen::InsensitiveStr::Ascii("em"),
            dictgen::InsensitiveStr::Ascii("emos"),
            dictgen::InsensitiveStr::Ascii("ent"),
            dictgen::InsensitiveStr::Ascii("eous"),
            dictgen::InsensitiveStr::Ascii("esly"),
            dictgen::InsensitiveStr::Ascii("ety"),
            dictgen::InsensitiveStr::Ascii("ining"),
            dictgen::InsensitiveStr::Ascii("ious"),
            dictgen::InsensitiveStr::Ascii("m"),
            dictgen::InsensitiveStr::Ascii("nes"),
            dictgen::InsensitiveStr::Ascii("ning"),
            dictgen::InsensitiveStr::Ascii("nity"),
            dictgen::InsensitiveStr::Ascii("ons"),
            dictgen::InsensitiveStr::Ascii("oous"),
            dictgen::InsensitiveStr::Ascii("os"),
            dictgen::InsensitiveStr::Ascii("osly"),
            dictgen::InsensitiveStr::Ascii("ousiy"),
            dictgen::InsensitiveStr::Ascii("ousle"),
            dictgen::InsensitiveStr::Ascii("re"),
            dictgen::InsensitiveStr::Ascii("s"),
            dictgen::InsensitiveStr::Ascii("se"),
            dictgen::InsensitiveStr::Ascii("sly"),
            dictgen::InsensitiveStr::Ascii("t"),
            dictgen::InsensitiveStr::Ascii("tation"),
            dictgen::InsensitiveStr::Ascii("te"),
            dictgen::InsensitiveStr::Ascii("ting"),
            dictgen::InsensitiveStr::Ascii("tity"),
            dictgen::InsensitiveStr::Ascii("tiy"),
            dictgen::InsensitiveStr::Ascii("u"),
            dictgen::InsensitiveStr::Ascii("uing"),
            dictgen::InsensitiveStr::Ascii("uity"),
            dictgen::InsensitiveStr::Ascii("uum"),
        ],
        values: &[
            &["continuation"],
            &["continually"],
            &["continue"],
            &["continual"],
            &["continual"],
            &["continues"],
            &["continuity"],
            &["continuation"],
            &["continuation"],
            &["continuation"],
            &["continuing"],
            &["continually"],
            &["continuum"],
            &["continues"],
            &["contingent"],
            &["continuous"],
            &["continuously"],
            &["continuity"],
            &["continuing"],
            &["continuous"],
            &["continuum"],
            &["continents"],
            &["continuing"],
            &["continuity"],
            &["continuous"],
            &["continuous"],
            &["continuous"],
            &["continuously"],
            &["continuously"],
            &["continuously"],
            &["continue"],
            &["continues", "continue", "continuous"],
            &["continues", "continuous"],
            &["continuously"],
            &["continuity"],
            &["continuation"],
            &["continue"],
            &["continuing"],
            &["continuity"],
            &["continuity"],
            &["continuous"],
            &["continuing"],
            &["continuity"],
            &["continuum"],
        ],
        range: 1..=6,
    };

static WORD_CONTINT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONTINT_CHILDREN),
    value: None,
};

pub static WORD_CONTINT_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[dictgen::InsensitiveStr::Ascii("ent")],
        values: &[&["contingent"]],
        range: 3..=3,
    };

static WORD_CONTINS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONTINS_CHILDREN),
    value: Some(&["contains"]),
};

pub static WORD_CONTINS_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[],
        values: &[],
        range: 0..=0,
    };

static WORD_CONTINO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONTINO_CHILDREN),
    value: None,
};

pub static WORD_CONTINO_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("ue"),
            dictgen::InsensitiveStr::Ascii("uos"),
            dictgen::InsensitiveStr::Ascii("us"),
            dictgen::InsensitiveStr::Ascii("usly"),
        ],
        values: &[
            &["continue"],
            &["continuous"],
            &["continuous"],
            &["continuously"],
        ],
        range: 2..=4,
    };

static WORD_CONTINI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONTINI_CHILDREN),
    value: None,
};

pub static WORD_CONTINI_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("ent"),
            dictgen::InsensitiveStr::Ascii("ng"),
            dictgen::InsensitiveStr::Ascii("ous"),
            dictgen::InsensitiveStr::Ascii("ously"),
            dictgen::InsensitiveStr::Ascii("uty"),
        ],
        values: &[
            &["contingent"],
            &["containing", "continuing"],
            &["continuous"],
            &["continuously"],
            &["continuity"],
        ],
        range: 2..=5,
    };

static WORD_CONTING_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONTING_CHILDREN),
    value: None,
};

pub static WORD_CONTING_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("ancy"),
            dictgen::InsensitiveStr::Ascii("ecy"),
            dictgen::InsensitiveStr::Ascii("eny"),
            dictgen::InsensitiveStr::Ascii("ient"),
            dictgen::InsensitiveStr::Ascii("incy"),
            dictgen::InsensitiveStr::Ascii("ing"),
            dictgen::InsensitiveStr::Ascii("ous"),
            dictgen::InsensitiveStr::Ascii("uous"),
        ],
        values: &[
            &["contingency"],
            &["contingency"],
            &["contingency"],
            &["contingent"],
            &["contingency"],
            &["containing"],
            &["contiguous"],
            &["contiguous"],
        ],
        range: 3..=4,
    };

static WORD_CONTINE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONTINE_CHILDREN),
    value: Some(&["continue", "contain"]),
};

pub static WORD_CONTINE_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("d"),
            dictgen::InsensitiveStr::Ascii("nal"),
            dictgen::InsensitiveStr::Ascii("net"),
            dictgen::InsensitiveStr::Ascii("nets"),
            dictgen::InsensitiveStr::Ascii("ns"),
            dictgen::InsensitiveStr::Ascii("ntais"),
            dictgen::InsensitiveStr::Ascii("ntes"),
            dictgen::InsensitiveStr::Ascii("ntial"),
            dictgen::InsensitiveStr::Ascii("ntul"),
            dictgen::InsensitiveStr::Ascii("ous"),
            dictgen::InsensitiveStr::Ascii("ously"),
            dictgen::InsensitiveStr::Ascii("s"),
            dictgen::InsensitiveStr::Ascii("tal"),
        ],
        values: &[
            &["continued"],
            &["continental"],
            &["continents"],
            &["continents"],
            &["continents"],
            &["continents"],
            &["continents"],
            &["continental"],
            &["continental"],
            &["continuous"],
            &["continuously"],
            &["continents"],
            &["continental"],
        ],
        range: 1..=5,
    };

static WORD_CONTINA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONTINA_CHILDREN),
    value: None,
};

pub static WORD_CONTINA_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("ing"),
            dictgen::InsensitiveStr::Ascii("nt"),
            dictgen::InsensitiveStr::Ascii("nts"),
            dictgen::InsensitiveStr::Ascii("tion"),
        ],
        values: &[
            &["containing"],
            &["continental"],
            &["continents"],
            &["continuation"],
        ],
        range: 2..=4,
    };

static WORD_CONTIM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONTIM_CHILDREN),
    value: None,
};

pub static WORD_CONTIM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("plate"),
        dictgen::InsensitiveStr::Ascii("plating"),
    ],
    values: &[&["contemplate"], &["contemplating"]],
    range: 5..=7,
};

static WORD_CONTIG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONTIG_CHILDREN),
    value: None,
};

pub static WORD_CONTIG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ent"),
        dictgen::InsensitiveStr::Ascii("ents"),
        dictgen::InsensitiveStr::Ascii("ious"),
        dictgen::InsensitiveStr::Ascii("iously"),
        dictgen::InsensitiveStr::Ascii("nent"),
        dictgen::InsensitiveStr::Ascii("nuous"),
        dictgen::InsensitiveStr::Ascii("ous"),
        dictgen::InsensitiveStr::Ascii("uious"),
        dictgen::InsensitiveStr::Ascii("uos"),
    ],
    values: &[
        &["contingent"],
        &["continents"],
        &["contagious", "contiguous"],
        &["contiguously"],
        &["contingent"],
        &["contiguous"],
        &["contiguous"],
        &["contiguous"],
        &["contiguous"],
    ],
    range: 3..=6,
};

static WORD_CONTIE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONTIE_CHILDREN),
    value: None,
};

pub static WORD_CONTIE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ntous")],
    values: &[&["contentious"]],
    range: 5..=5,
};

static WORD_CONTIB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONTIB_CHILDREN),
    value: None,
};

pub static WORD_CONTIB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ute"),
        dictgen::InsensitiveStr::Ascii("uted"),
        dictgen::InsensitiveStr::Ascii("utes"),
        dictgen::InsensitiveStr::Ascii("uting"),
        dictgen::InsensitiveStr::Ascii("utor"),
    ],
    values: &[
        &["contribute"],
        &["contributed"],
        &["contributes"],
        &["contributing"],
        &["contributor"],
    ],
    range: 3..=5,
};

static WORD_CONTIA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONTIA_CHILDREN),
    value: None,
};

pub static WORD_CONTIA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ins"),
        dictgen::InsensitiveStr::Ascii("n"),
        dictgen::InsensitiveStr::Ascii("ned"),
        dictgen::InsensitiveStr::Ascii("ner"),
        dictgen::InsensitiveStr::Ascii("ners"),
        dictgen::InsensitiveStr::Ascii("ning"),
        dictgen::InsensitiveStr::Ascii("nment"),
        dictgen::InsensitiveStr::Ascii("ns"),
    ],
    values: &[
        &["contains"],
        &["contain"],
        &["contained"],
        &["container"],
        &["containers"],
        &["containing"],
        &["containment"],
        &["contains"],
    ],
    range: 1..=5,
};

static WORD_CONTE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_CONTE_CHILDREN),
    value: None,
};

static WORD_CONTE_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    Some(&WORD_CONTEC_NODE),
    Some(&WORD_CONTED_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_CONTEI_NODE),
    None,
    None,
    None,
    Some(&WORD_CONTEM_NODE),
    Some(&WORD_CONTEN_NODE),
    None,
    None,
    None,
    Some(&WORD_CONTER_NODE),
    Some(&WORD_CONTES_NODE),
    Some(&WORD_CONTET_NODE),
    None,
    None,
    None,
    Some(&WORD_CONTEX_NODE),
    None,
    None,
];

static WORD_CONTEX_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONTEX_CHILDREN),
    value: Some(&["context"]),
};

pub static WORD_CONTEX_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ta"),
        dictgen::InsensitiveStr::Ascii("tes"),
        dictgen::InsensitiveStr::Ascii("tful"),
        dictgen::InsensitiveStr::Ascii("tl"),
        dictgen::InsensitiveStr::Ascii("tos"),
        dictgen::InsensitiveStr::Ascii("tuel"),
        dictgen::InsensitiveStr::Ascii("tura"),
        dictgen::InsensitiveStr::Ascii("ual"),
    ],
    values: &[
        &["contextual", "context"],
        &["contexts"],
        &["contextual"],
        &["contextual"],
        &["contexts"],
        &["contextual"],
        &["contextual"],
        &["contextual"],
    ],
    range: 2..=4,
};

static WORD_CONTET_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONTET_CHILDREN),
    value: Some(&["contest", "content", "context"]),
};

pub static WORD_CONTET_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("s")],
    values: &[&["contents", "contexts"]],
    range: 1..=1,
};

static WORD_CONTES_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONTES_CHILDREN),
    value: None,
};

pub static WORD_CONTES_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("s"),
        dictgen::InsensitiveStr::Ascii("tais"),
        dictgen::InsensitiveStr::Ascii("tans"),
        dictgen::InsensitiveStr::Ascii("tas"),
        dictgen::InsensitiveStr::Ascii("tase"),
        dictgen::InsensitiveStr::Ascii("taste"),
        dictgen::InsensitiveStr::Ascii("tat"),
        dictgen::InsensitiveStr::Ascii("tents"),
        dictgen::InsensitiveStr::Ascii("tes"),
        dictgen::InsensitiveStr::Ascii("tion"),
        dictgen::InsensitiveStr::Ascii("tors"),
    ],
    values: &[
        &["contests"],
        &["contests"],
        &["contests"],
        &["contests"],
        &["contests"],
        &["contestants"],
        &["contestants"],
        &["contestants"],
        &["contests"],
        &["contention"],
        &["contests"],
    ],
    range: 1..=5,
};

static WORD_CONTER_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONTER_CHILDREN),
    value: Some(&["conteur", "counter"]),
};

pub static WORD_CONTER_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("mporaneous"),
        dictgen::InsensitiveStr::Ascii("part"),
        dictgen::InsensitiveStr::Ascii("parts"),
        dictgen::InsensitiveStr::Ascii("s"),
        dictgen::InsensitiveStr::Ascii("sink"),
    ],
    values: &[
        &["contemporaneous"],
        &["counterpart"],
        &["counterparts"],
        &["conteurs", "counters"],
        &["countersink"],
    ],
    range: 1..=10,
};

static WORD_CONTEN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONTEN_CHILDREN),
    value: Some(&["contain"]),
};

pub static WORD_CONTEN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ants"),
        dictgen::InsensitiveStr::Ascii("ce"),
        dictgen::InsensitiveStr::Ascii("cion"),
        dictgen::InsensitiveStr::Ascii("cious"),
        dictgen::InsensitiveStr::Ascii("dor"),
        dictgen::InsensitiveStr::Ascii("dors"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("ental"),
        dictgen::InsensitiveStr::Ascii("ents"),
        dictgen::InsensitiveStr::Ascii("er"),
        dictgen::InsensitiveStr::Ascii("ers"),
        dictgen::InsensitiveStr::Ascii("eurs"),
        dictgen::InsensitiveStr::Ascii("gency"),
        dictgen::InsensitiveStr::Ascii("gent"),
        dictgen::InsensitiveStr::Ascii("ht"),
        dictgen::InsensitiveStr::Ascii("intal"),
        dictgen::InsensitiveStr::Ascii("plate"),
        dictgen::InsensitiveStr::Ascii("plating"),
        dictgen::InsensitiveStr::Ascii("s"),
        dictgen::InsensitiveStr::Ascii("se"),
        dictgen::InsensitiveStr::Ascii("sion"),
        dictgen::InsensitiveStr::Ascii("sious"),
        dictgen::InsensitiveStr::Ascii("st"),
        dictgen::InsensitiveStr::Ascii("tants"),
        dictgen::InsensitiveStr::Ascii("tas"),
        dictgen::InsensitiveStr::Ascii("tended"),
        dictgen::InsensitiveStr::Ascii("tes"),
        dictgen::InsensitiveStr::Ascii("tino"),
        dictgen::InsensitiveStr::Ascii("tios"),
        dictgen::InsensitiveStr::Ascii("tn"),
        dictgen::InsensitiveStr::Ascii("tos"),
        dictgen::InsensitiveStr::Ascii("tous"),
        dictgen::InsensitiveStr::Ascii("tss"),
        dictgen::InsensitiveStr::Ascii("tuous"),
    ],
    values: &[
        &["continents"],
        &["contents"],
        &["contention"],
        &["contentious"],
        &["contender"],
        &["contenders"],
        &["contained", "contend"],
        &["continental"],
        &["continents"],
        &["container"],
        &["containers"],
        &["contenders"],
        &["contingency"],
        &["contingent"],
        &["content"],
        &["continental"],
        &["contemplate"],
        &["contemplating"],
        &["contents", "contains"],
        &["contenders"],
        &["contention"],
        &["contentious"],
        &["contents"],
        &["contestants"],
        &["contents"],
        &["contended"],
        &["contents"],
        &["contention"],
        &["contentious"],
        &["content"],
        &["contents"],
        &["contentious"],
        &["contents"],
        &["contentious"],
    ],
    range: 1..=7,
};

static WORD_CONTEM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONTEM_CHILDREN),
    value: None,
};

pub static WORD_CONTEM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("palte"),
        dictgen::InsensitiveStr::Ascii("pate"),
        dictgen::InsensitiveStr::Ascii("perary"),
        dictgen::InsensitiveStr::Ascii("plare"),
        dictgen::InsensitiveStr::Ascii("plat"),
        dictgen::InsensitiveStr::Ascii("ple"),
        dictgen::InsensitiveStr::Ascii("poary"),
        dictgen::InsensitiveStr::Ascii("poraneus"),
        dictgen::InsensitiveStr::Ascii("porany"),
        dictgen::InsensitiveStr::Ascii("poray"),
        dictgen::InsensitiveStr::Ascii("pory"),
        dictgen::InsensitiveStr::Ascii("t"),
    ],
    values: &[
        &["contemplate"],
        &["contemplate"],
        &["contemporary"],
        &["contemplate"],
        &["contempt"],
        &["contemplate"],
        &["contemporary"],
        &["contemporaneous"],
        &["contemporary"],
        &["contemporary"],
        &["contemporary"],
        &["contempt"],
    ],
    range: 1..=8,
};

static WORD_CONTEI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONTEI_CHILDREN),
    value: None,
};

pub static WORD_CONTEI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("n"),
        dictgen::InsensitiveStr::Ascii("ned"),
        dictgen::InsensitiveStr::Ascii("ners"),
        dictgen::InsensitiveStr::Ascii("ning"),
        dictgen::InsensitiveStr::Ascii("ns"),
    ],
    values: &[
        &["contain"],
        &["contained"],
        &["contenders"],
        &["containing"],
        &["contains"],
    ],
    range: 1..=4,
};

static WORD_CONTED_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONTED_CHILDREN),
    value: Some(&["counted", "counter", "countered"]),
};

pub static WORD_CONTED_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[],
    values: &[],
    range: 0..=0,
};

static WORD_CONTEC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONTEC_CHILDREN),
    value: None,
};

pub static WORD_CONTEC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("tion"),
        dictgen::InsensitiveStr::Ascii("tual"),
    ],
    values: &[
        &["contact", "context", "connect"],
        &["contention"],
        &["contextual"],
    ],
    range: 1..=4,
};

static WORD_CONTA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_CONTA_CHILDREN),
    value: None,
};

static WORD_CONTA_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    Some(&WORD_CONTAC_NODE),
    None,
    None,
    None,
    Some(&WORD_CONTAG_NODE),
    None,
    Some(&WORD_CONTAI_NODE),
    None,
    None,
    None,
    Some(&WORD_CONTAM_NODE),
    Some(&WORD_CONTAN_NODE),
    None,
    None,
    None,
    Some(&WORD_CONTAR_NODE),
    Some(&WORD_CONTAS_NODE),
    Some(&WORD_CONTAT_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_CONTAT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONTAT_CHILDREN),
    value: None,
};

pub static WORD_CONTAT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("enate"),
        dictgen::InsensitiveStr::Ascii("enated"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("ining"),
    ],
    values: &[
        &["concatenate"],
        &["concatenated"],
        &["contacting", "containing"],
        &["containing"],
    ],
    range: 3..=6,
};

static WORD_CONTAS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONTAS_CHILDREN),
    value: None,
};

pub static WORD_CONTAS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("t")],
    values: &[&["contacts", "contrast", "contest"]],
    range: 1..=1,
};

static WORD_CONTAR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONTAR_CHILDREN),
    value: None,
};

pub static WORD_CONTAR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("y")],
    values: &[&["contrary"]],
    range: 1..=1,
};

static WORD_CONTAN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONTAN_CHILDREN),
    value: Some(&["contain"]),
};

pub static WORD_CONTAN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cting"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("er"),
        dictgen::InsensitiveStr::Ascii("ers"),
        dictgen::InsensitiveStr::Ascii("imate"),
        dictgen::InsensitiveStr::Ascii("imated"),
        dictgen::InsensitiveStr::Ascii("imation"),
        dictgen::InsensitiveStr::Ascii("iments"),
        dictgen::InsensitiveStr::Ascii("ined"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("ins"),
        dictgen::InsensitiveStr::Ascii("s"),
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("ti"),
        dictgen::InsensitiveStr::Ascii("ting"),
        dictgen::InsensitiveStr::Ascii("ts"),
    ],
    values: &[
        &["contracting"],
        &["contained"],
        &["container"],
        &["containers"],
        &["contaminated"],
        &["contaminated"],
        &["contamination"],
        &["containment"],
        &["contained"],
        &["containing"],
        &["contains"],
        &["contains"],
        &["constant", "content"],
        &["contacting"],
        &["contacting"],
        &["constants", "contents"],
    ],
    range: 1..=7,
};

static WORD_CONTAM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONTAM_CHILDREN),
    value: None,
};

pub static WORD_CONTAM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("inacion"),
        dictgen::InsensitiveStr::Ascii("inanted"),
        dictgen::InsensitiveStr::Ascii("inatie"),
        dictgen::InsensitiveStr::Ascii("inato"),
        dictgen::InsensitiveStr::Ascii("inaton"),
        dictgen::InsensitiveStr::Ascii("inen"),
        dictgen::InsensitiveStr::Ascii("inent"),
        dictgen::InsensitiveStr::Ascii("inents"),
        dictgen::InsensitiveStr::Ascii("inted"),
        dictgen::InsensitiveStr::Ascii("poraries"),
        dictgen::InsensitiveStr::Ascii("porary"),
    ],
    values: &[
        &["contamination"],
        &["contaminated"],
        &["contaminated"],
        &["contamination"],
        &["contamination"],
        &["containment"],
        &["containment"],
        &["containment"],
        &["contaminated"],
        &["contemporaries"],
        &["contemporary"],
    ],
    range: 4..=8,
};

static WORD_CONTAI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONTAI_CHILDREN),
    value: None,
};

pub static WORD_CONTAI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("enr"),
        dictgen::InsensitiveStr::Ascii("enrs"),
        dictgen::InsensitiveStr::Ascii("er"),
        dictgen::InsensitiveStr::Ascii("gous"),
        dictgen::InsensitiveStr::Ascii("ls"),
        dictgen::InsensitiveStr::Ascii("minate"),
        dictgen::InsensitiveStr::Ascii("minated"),
        dictgen::InsensitiveStr::Ascii("minating"),
        dictgen::InsensitiveStr::Ascii("na"),
        dictgen::InsensitiveStr::Ascii("nd"),
        dictgen::InsensitiveStr::Ascii("ne"),
        dictgen::InsensitiveStr::Ascii("nees"),
        dictgen::InsensitiveStr::Ascii("nered"),
        dictgen::InsensitiveStr::Ascii("nerr"),
        dictgen::InsensitiveStr::Ascii("nes"),
        dictgen::InsensitiveStr::Ascii("ng"),
        dictgen::InsensitiveStr::Ascii("nging"),
        dictgen::InsensitiveStr::Ascii("nig"),
        dictgen::InsensitiveStr::Ascii("nin"),
        dictgen::InsensitiveStr::Ascii("nined"),
        dictgen::InsensitiveStr::Ascii("nings"),
        dictgen::InsensitiveStr::Ascii("nining"),
        dictgen::InsensitiveStr::Ascii("ninng"),
        dictgen::InsensitiveStr::Ascii("nint"),
        dictgen::InsensitiveStr::Ascii("nmemt"),
        dictgen::InsensitiveStr::Ascii("nn"),
        dictgen::InsensitiveStr::Ascii("nner"),
        dictgen::InsensitiveStr::Ascii("nners"),
        dictgen::InsensitiveStr::Ascii("nns"),
        dictgen::InsensitiveStr::Ascii("nors"),
        dictgen::InsensitiveStr::Ascii("nr"),
        dictgen::InsensitiveStr::Ascii("nrs"),
        dictgen::InsensitiveStr::Ascii("nt"),
        dictgen::InsensitiveStr::Ascii("nted"),
        dictgen::InsensitiveStr::Ascii("nter"),
        dictgen::InsensitiveStr::Ascii("nters"),
        dictgen::InsensitiveStr::Ascii("nting"),
        dictgen::InsensitiveStr::Ascii("nts"),
        dictgen::InsensitiveStr::Ascii("nuations"),
        dictgen::InsensitiveStr::Ascii("re"),
        dictgen::InsensitiveStr::Ascii("s"),
        dictgen::InsensitiveStr::Ascii("sn"),
        dictgen::InsensitiveStr::Ascii("un"),
    ],
    values: &[
        &["contained"],
        &["container"],
        &["containers"],
        &["container"],
        &["contagious"],
        &["contains"],
        &["contaminate"],
        &["contaminated"],
        &["contaminating"],
        &["contain"],
        &["contained"],
        &["contain", "contained", "container", "contains"],
        &["containers"],
        &["contained"],
        &["container"],
        &["contains", "contained", "container"],
        &["containing"],
        &["containing"],
        &["containing"],
        &["containing"],
        &["contained"],
        &["containing"],
        &["containing"],
        &["containing"],
        &["containing"],
        &["containment"],
        &["contain"],
        &["container"],
        &["containers"],
        &["contains"],
        &["containers"],
        &["container"],
        &["containers"],
        &["contain", "content"],
        &["contained"],
        &["container"],
        &["containers"],
        &["containing"],
        &["contains"],
        &["continuations"],
        &["containers"],
        &["contains"],
        &["contains"],
        &["contain"],
    ],
    range: 1..=8,
};

static WORD_CONTAG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONTAG_CHILDREN),
    value: None,
};

pub static WORD_CONTAG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("en"),
        dictgen::InsensitiveStr::Ascii("eous"),
        dictgen::InsensitiveStr::Ascii("ios"),
        dictgen::InsensitiveStr::Ascii("iosa"),
        dictgen::InsensitiveStr::Ascii("ioso"),
        dictgen::InsensitiveStr::Ascii("iosum"),
    ],
    values: &[
        &["contagion"],
        &["contagious"],
        &["contagious"],
        &["contagious"],
        &["contagious"],
        &["contagious"],
    ],
    range: 2..=5,
};

static WORD_CONTAC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONTAC_CHILDREN),
    value: None,
};

pub static WORD_CONTAC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("entaion"),
        dictgen::InsensitiveStr::Ascii("s"),
        dictgen::InsensitiveStr::Ascii("tes"),
        dictgen::InsensitiveStr::Ascii("tion"),
        dictgen::InsensitiveStr::Ascii("tos"),
    ],
    values: &[
        &["concatenation"],
        &["contacts"],
        &["contacts"],
        &["contacting"],
        &["contacts"],
    ],
    range: 1..=7,
};

static WORD_CONS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_CONS_CHILDREN),
    value: None,
};

static WORD_CONS_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_CONSA_NODE),
    None,
    Some(&WORD_CONSC_NODE),
    Some(&WORD_CONSD_NODE),
    Some(&WORD_CONSE_NODE),
    Some(&WORD_CONSF_NODE),
    None,
    None,
    Some(&WORD_CONSI_NODE),
    None,
    None,
    Some(&WORD_CONSL_NODE),
    None,
    Some(&WORD_CONSN_NODE),
    Some(&WORD_CONSO_NODE),
    Some(&WORD_CONSP_NODE),
    Some(&WORD_CONSQ_NODE),
    Some(&WORD_CONSR_NODE),
    None,
    Some(&WORD_CONST_NODE),
    Some(&WORD_CONSU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_CONSU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONSU_CHILDREN),
    value: None,
};

pub static WORD_CONSU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("der"),
        dictgen::InsensitiveStr::Ascii("eling"),
        dictgen::InsensitiveStr::Ascii("elling"),
        dictgen::InsensitiveStr::Ascii("emr"),
        dictgen::InsensitiveStr::Ascii("lant"),
        dictgen::InsensitiveStr::Ascii("lation"),
        dictgen::InsensitiveStr::Ascii("ltaion"),
        dictgen::InsensitiveStr::Ascii("ltanti"),
        dictgen::InsensitiveStr::Ascii("ltat"),
        dictgen::InsensitiveStr::Ascii("ltata"),
        dictgen::InsensitiveStr::Ascii("ltate"),
        dictgen::InsensitiveStr::Ascii("ltati"),
        dictgen::InsensitiveStr::Ascii("ltating"),
        dictgen::InsensitiveStr::Ascii("ltato"),
        dictgen::InsensitiveStr::Ascii("ltent"),
        dictgen::InsensitiveStr::Ascii("ltunt"),
        dictgen::InsensitiveStr::Ascii("mate"),
        dictgen::InsensitiveStr::Ascii("mated"),
        dictgen::InsensitiveStr::Ascii("mating"),
        dictgen::InsensitiveStr::Ascii("mation"),
        dictgen::InsensitiveStr::Ascii("mbale"),
        dictgen::InsensitiveStr::Ascii("mbales"),
        dictgen::InsensitiveStr::Ascii("mend"),
        dictgen::InsensitiveStr::Ascii("ments"),
        dictgen::InsensitiveStr::Ascii("merisim"),
        dictgen::InsensitiveStr::Ascii("mersim"),
        dictgen::InsensitiveStr::Ascii("mibles"),
        dictgen::InsensitiveStr::Ascii("mirem"),
        dictgen::InsensitiveStr::Ascii("mires"),
        dictgen::InsensitiveStr::Ascii("mirse"),
        dictgen::InsensitiveStr::Ascii("miste"),
        dictgen::InsensitiveStr::Ascii("mmed"),
        dictgen::InsensitiveStr::Ascii("mmer"),
        dictgen::InsensitiveStr::Ascii("mmers"),
        dictgen::InsensitiveStr::Ascii("mmes"),
        dictgen::InsensitiveStr::Ascii("mpion"),
        dictgen::InsensitiveStr::Ascii("ms"),
        dictgen::InsensitiveStr::Ascii("mtion"),
    ],
    values: &[
        &["consider"],
        &["consulting"],
        &["counselling"],
        &["consumer"],
        &["consultant"],
        &["consolation"],
        &["consultation"],
        &["consultation"],
        &["consultant"],
        &["consultant"],
        &["consultant"],
        &["consultant"],
        &["consultation"],
        &["consultation"],
        &["consultant"],
        &["consultant"],
        &["consummate"],
        &["consummated"],
        &["consummating"],
        &["consumption", "consummation"],
        &["consumables"],
        &["consumables"],
        &["consumed"],
        &["consumes"],
        &["consumerism"],
        &["consumerism"],
        &["consumables"],
        &["consumerism"],
        &["consumerism"],
        &["consumerism"],
        &["consumes"],
        &["consumed"],
        &["consumer"],
        &["consumers"],
        &["consumes"],
        &["consumption"],
        &["consumes"],
        &["consumption"],
    ],
    range: 2..=7,
};

static WORD_CONST_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_CONST_CHILDREN),
    value: None,
};

static WORD_CONST_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_CONSTA_NODE),
    None,
    Some(&WORD_CONSTC_NODE),
    None,
    Some(&WORD_CONSTE_NODE),
    None,
    None,
    None,
    Some(&WORD_CONSTI_NODE),
    None,
    None,
    Some(&WORD_CONSTL_NODE),
    None,
    Some(&WORD_CONSTN_NODE),
    None,
    None,
    None,
    Some(&WORD_CONSTR_NODE),
    None,
    Some(&WORD_CONSTT_NODE),
    Some(&WORD_CONSTU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_CONSTU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONSTU_CHILDREN),
    value: None,
};

pub static WORD_CONSTU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ct"),
        dictgen::InsensitiveStr::Ascii("cted"),
        dictgen::InsensitiveStr::Ascii("cter"),
        dictgen::InsensitiveStr::Ascii("cters"),
        dictgen::InsensitiveStr::Ascii("cting"),
        dictgen::InsensitiveStr::Ascii("ction"),
        dictgen::InsensitiveStr::Ascii("ctions"),
        dictgen::InsensitiveStr::Ascii("ctor"),
        dictgen::InsensitiveStr::Ascii("ctors"),
        dictgen::InsensitiveStr::Ascii("cts"),
        dictgen::InsensitiveStr::Ascii("rct"),
        dictgen::InsensitiveStr::Ascii("rcted"),
        dictgen::InsensitiveStr::Ascii("rction"),
        dictgen::InsensitiveStr::Ascii("rctor"),
        dictgen::InsensitiveStr::Ascii("red"),
    ],
    values: &[
        &["construct"],
        &["constructed"],
        &["constructor"],
        &["constructors"],
        &["constructing"],
        &["construction"],
        &["constructions"],
        &["constructor"],
        &["constructors"],
        &["constructs"],
        &["construct"],
        &["constructed"],
        &["construction"],
        &["constructor"],
        &["construed"],
    ],
    range: 2..=6,
};

static WORD_CONSTT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONSTT_CHILDREN),
    value: None,
};

pub static WORD_CONSTT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ruct"),
        dictgen::InsensitiveStr::Ascii("ructer"),
        dictgen::InsensitiveStr::Ascii("ructers"),
        dictgen::InsensitiveStr::Ascii("ruction"),
        dictgen::InsensitiveStr::Ascii("ructor"),
        dictgen::InsensitiveStr::Ascii("ructors"),
    ],
    values: &[
        &["construct"],
        &["constructor"],
        &["constructors"],
        &["construction"],
        &["constructor"],
        &["constructors"],
    ],
    range: 4..=7,
};

static WORD_CONSTR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_CONSTR_CHILDREN),
    value: None,
};

static WORD_CONSTR_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_CONSTRA_NODE),
    None,
    Some(&WORD_CONSTRC_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_CONSTRI_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_CONSTRO_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_CONSTRU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_CONSTRU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONSTRU_CHILDREN),
    value: None,
};

pub static WORD_CONSTRU_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("c"),
            dictgen::InsensitiveStr::Ascii("ccion"),
            dictgen::InsensitiveStr::Ascii("ced"),
            dictgen::InsensitiveStr::Ascii("ces"),
            dictgen::InsensitiveStr::Ascii("cing"),
            dictgen::InsensitiveStr::Ascii("cion"),
            dictgen::InsensitiveStr::Ascii("citon"),
            dictgen::InsensitiveStr::Ascii("cive"),
            dictgen::InsensitiveStr::Ascii("cor"),
            dictgen::InsensitiveStr::Ascii("cs"),
            dictgen::InsensitiveStr::Ascii("ctcor"),
            dictgen::InsensitiveStr::Ascii("cteds"),
            dictgen::InsensitiveStr::Ascii("cter"),
            dictgen::InsensitiveStr::Ascii("cters"),
            dictgen::InsensitiveStr::Ascii("ctes"),
            dictgen::InsensitiveStr::Ascii("cticon"),
            dictgen::InsensitiveStr::Ascii("ctie"),
            dictgen::InsensitiveStr::Ascii("ctief"),
            dictgen::InsensitiveStr::Ascii("cties"),
            dictgen::InsensitiveStr::Ascii("ctieve"),
            dictgen::InsensitiveStr::Ascii("ctifs"),
            dictgen::InsensitiveStr::Ascii("ctiin"),
            dictgen::InsensitiveStr::Ascii("ctiong"),
            dictgen::InsensitiveStr::Ascii("ctivo"),
            dictgen::InsensitiveStr::Ascii("cto"),
            dictgen::InsensitiveStr::Ascii("ctos"),
            dictgen::InsensitiveStr::Ascii("ctred"),
            dictgen::InsensitiveStr::Ascii("ctt"),
            dictgen::InsensitiveStr::Ascii("ctted"),
            dictgen::InsensitiveStr::Ascii("ctting"),
            dictgen::InsensitiveStr::Ascii("cttor"),
            dictgen::InsensitiveStr::Ascii("cttors"),
            dictgen::InsensitiveStr::Ascii("ctts"),
            dictgen::InsensitiveStr::Ascii("ctued"),
            dictgen::InsensitiveStr::Ascii("ctur"),
            dictgen::InsensitiveStr::Ascii("cture"),
            dictgen::InsensitiveStr::Ascii("cturs"),
            dictgen::InsensitiveStr::Ascii("ctus"),
            dictgen::InsensitiveStr::Ascii("de"),
            dictgen::InsensitiveStr::Ascii("int"),
            dictgen::InsensitiveStr::Ascii("its"),
            dictgen::InsensitiveStr::Ascii("ktor"),
            dictgen::InsensitiveStr::Ascii("nctor"),
            dictgen::InsensitiveStr::Ascii("rtors"),
            dictgen::InsensitiveStr::Ascii("st"),
            dictgen::InsensitiveStr::Ascii("sts"),
            dictgen::InsensitiveStr::Ascii("t"),
            dictgen::InsensitiveStr::Ascii("tced"),
            dictgen::InsensitiveStr::Ascii("ted"),
            dictgen::InsensitiveStr::Ascii("ter"),
            dictgen::InsensitiveStr::Ascii("ters"),
            dictgen::InsensitiveStr::Ascii("ting"),
            dictgen::InsensitiveStr::Ascii("tion"),
            dictgen::InsensitiveStr::Ascii("tor"),
            dictgen::InsensitiveStr::Ascii("tors"),
        ],
        values: &[
            &["construct"],
            &["construction"],
            &["constructed", "construed"],
            &["constructs"],
            &["constructing"],
            &["construction"],
            &["construction"],
            &["constructive"],
            &["constructor"],
            &["constructs"],
            &["constructor"],
            &["constructs"],
            &["constructor"],
            &["constructors"],
            &["constructs"],
            &["construction"],
            &["constructive"],
            &["constructive"],
            &["constructs"],
            &["constructive"],
            &["constructs"],
            &["constructing"],
            &["constructing", "construction"],
            &["construction"],
            &["construction"],
            &["constructs"],
            &["constructed"],
            &["construct"],
            &["constructed"],
            &["constructing"],
            &["constructor"],
            &["constructors"],
            &["constructs"],
            &["constructed"],
            &["constructor"],
            &["constructor"],
            &["constructors"],
            &["constructs"],
            &["construed"],
            &["constraint"],
            &["constructs"],
            &["constructor"],
            &["constructor"],
            &["constructors"],
            &["constructs", "construct"],
            &["constructs"],
            &["constructs", "construct"],
            &["constructed"],
            &["constructed"],
            &["constructor"],
            &["constructors"],
            &["constructing"],
            &["construction"],
            &["constructor"],
            &["constructors"],
        ],
        range: 1..=6,
    };

static WORD_CONSTRO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONSTRO_CHILDREN),
    value: None,
};

pub static WORD_CONSTRO_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("l"),
            dictgen::InsensitiveStr::Ascii("llers"),
        ],
        values: &[&["control"], &["controllers"]],
        range: 1..=5,
    };

static WORD_CONSTRI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONSTRI_CHILDREN),
    value: None,
};

pub static WORD_CONSTRI_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("ant"),
            dictgen::InsensitiveStr::Ascii("ants"),
            dictgen::InsensitiveStr::Ascii("nt"),
            dictgen::InsensitiveStr::Ascii("nts"),
        ],
        values: &[
            &["constraint"],
            &["constraints"],
            &["constraint"],
            &["constraints"],
        ],
        range: 2..=4,
    };

static WORD_CONSTRC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONSTRC_CHILDREN),
    value: None,
};

pub static WORD_CONSTRC_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("t"),
            dictgen::InsensitiveStr::Ascii("ted"),
            dictgen::InsensitiveStr::Ascii("ting"),
            dictgen::InsensitiveStr::Ascii("tion"),
            dictgen::InsensitiveStr::Ascii("tions"),
            dictgen::InsensitiveStr::Ascii("ts"),
            dictgen::InsensitiveStr::Ascii("uct"),
            dictgen::InsensitiveStr::Ascii("ut"),
            dictgen::InsensitiveStr::Ascii("uted"),
            dictgen::InsensitiveStr::Ascii("ution"),
            dictgen::InsensitiveStr::Ascii("utor"),
            dictgen::InsensitiveStr::Ascii("utors"),
            dictgen::InsensitiveStr::Ascii("uts"),
        ],
        values: &[
            &["construct", "constrict"],
            &["constructed", "constricted"],
            &["constructing", "constricting"],
            &["construction", "constriction"],
            &["constructions", "constrictions"],
            &["constructs", "constricts"],
            &["construct"],
            &["construct"],
            &["constructed"],
            &["construction"],
            &["constructor"],
            &["constructors"],
            &["constructs"],
        ],
        range: 1..=5,
    };

static WORD_CONSTRA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONSTRA_CHILDREN),
    value: None,
};

pub static WORD_CONSTRA_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("ct"),
            dictgen::InsensitiveStr::Ascii("cted"),
            dictgen::InsensitiveStr::Ascii("cting"),
            dictgen::InsensitiveStr::Ascii("ction"),
            dictgen::InsensitiveStr::Ascii("ctions"),
            dictgen::InsensitiveStr::Ascii("ctor"),
            dictgen::InsensitiveStr::Ascii("ctors"),
            dictgen::InsensitiveStr::Ascii("cts"),
            dictgen::InsensitiveStr::Ascii("ing"),
            dictgen::InsensitiveStr::Ascii("inst"),
            dictgen::InsensitiveStr::Ascii("insts"),
            dictgen::InsensitiveStr::Ascii("inted"),
            dictgen::InsensitiveStr::Ascii("intes"),
            dictgen::InsensitiveStr::Ascii("inting"),
            dictgen::InsensitiveStr::Ascii("it"),
            dictgen::InsensitiveStr::Ascii("its"),
            dictgen::InsensitiveStr::Ascii("ns"),
            dictgen::InsensitiveStr::Ascii("nsi"),
            dictgen::InsensitiveStr::Ascii("nt"),
            dictgen::InsensitiveStr::Ascii("nts"),
            dictgen::InsensitiveStr::Ascii("st"),
            dictgen::InsensitiveStr::Ascii("sts"),
            dictgen::InsensitiveStr::Ascii("t"),
            dictgen::InsensitiveStr::Ascii("ting"),
            dictgen::InsensitiveStr::Ascii("tints"),
            dictgen::InsensitiveStr::Ascii("ucts"),
        ],
        values: &[
            &["construct"],
            &["constructed"],
            &["constructing"],
            &["construction", "constriction", "contraction"],
            &["constrictions", "constructions", "contractions"],
            &["constructor"],
            &["constructors"],
            &["constructs"],
            &["constraining", "constraint"],
            &["constraint", "constraints"],
            &["constraints"],
            &["constrained"],
            &["constraints"],
            &["constraining"],
            &["constraints", "constraint"],
            &["constraints"],
            &["constrains"],
            &["constraints"],
            &["constraint"],
            &["constraints"],
            &["contrast"],
            &["contrasts"],
            &["constraint"],
            &["constraint"],
            &["constraints"],
            &["constructs"],
        ],
        range: 1..=6,
    };

static WORD_CONSTN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONSTN_CHILDREN),
    value: None,
};

pub static WORD_CONSTN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("atly")],
    values: &[&["constantly"]],
    range: 4..=4,
};

static WORD_CONSTL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONSTL_CHILDREN),
    value: None,
};

pub static WORD_CONSTL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("y")],
    values: &[&["costly"]],
    range: 1..=1,
};

static WORD_CONSTI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONSTI_CHILDREN),
    value: None,
};

pub static WORD_CONSTI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("llation"),
        dictgen::InsensitiveStr::Ascii("ng"),
        dictgen::InsensitiveStr::Ascii("nually"),
        dictgen::InsensitiveStr::Ascii("stency"),
        dictgen::InsensitiveStr::Ascii("sts"),
        dictgen::InsensitiveStr::Ascii("tently"),
        dictgen::InsensitiveStr::Ascii("tition"),
        dictgen::InsensitiveStr::Ascii("titional"),
        dictgen::InsensitiveStr::Ascii("tuant"),
        dictgen::InsensitiveStr::Ascii("tuante"),
        dictgen::InsensitiveStr::Ascii("tuants"),
        dictgen::InsensitiveStr::Ascii("tuates"),
        dictgen::InsensitiveStr::Ascii("tucion"),
        dictgen::InsensitiveStr::Ascii("tucional"),
        dictgen::InsensitiveStr::Ascii("tude"),
        dictgen::InsensitiveStr::Ascii("tue"),
        dictgen::InsensitiveStr::Ascii("tued"),
        dictgen::InsensitiveStr::Ascii("tuem"),
        dictgen::InsensitiveStr::Ascii("tuer"),
        dictgen::InsensitiveStr::Ascii("tues"),
        dictgen::InsensitiveStr::Ascii("tuie"),
        dictgen::InsensitiveStr::Ascii("tuient"),
        dictgen::InsensitiveStr::Ascii("tuinte"),
        dictgen::InsensitiveStr::Ascii("tuintes"),
        dictgen::InsensitiveStr::Ascii("tuion"),
        dictgen::InsensitiveStr::Ascii("tuional"),
        dictgen::InsensitiveStr::Ascii("tuit"),
        dictgen::InsensitiveStr::Ascii("tuite"),
        dictgen::InsensitiveStr::Ascii("tutent"),
        dictgen::InsensitiveStr::Ascii("tutents"),
        dictgen::InsensitiveStr::Ascii("tutie"),
        dictgen::InsensitiveStr::Ascii("tutiei"),
        dictgen::InsensitiveStr::Ascii("tutinal"),
        dictgen::InsensitiveStr::Ascii("tutionnal"),
        dictgen::InsensitiveStr::Ascii("tutn"),
        dictgen::InsensitiveStr::Ascii("tutues"),
        dictgen::InsensitiveStr::Ascii("tuye"),
        dictgen::InsensitiveStr::Ascii("utents"),
    ],
    values: &[
        &["constellation"],
        &["consisting"],
        &["continually"],
        &["consistency"],
        &["consists"],
        &["consistently"],
        &["constitution"],
        &["constitutional"],
        &["constituent"],
        &["constituents"],
        &["constituents"],
        &["constitutes"],
        &["constitution"],
        &["constitutional"],
        &["constitute"],
        &["constitutes", "constitute"],
        &["constitute"],
        &["constitute"],
        &["constitute"],
        &["constitutes"],
        &["constitute"],
        &["constitute"],
        &["constituents"],
        &["constituents"],
        &["constitution"],
        &["constitutional"],
        &["constitute"],
        &["constitute"],
        &["constituent"],
        &["constitutes", "constituents"],
        &["constitutes"],
        &["constitute"],
        &["constitutional"],
        &["constitutional"],
        &["constituents"],
        &["constitute"],
        &["constitute"],
        &["constituents"],
    ],
    range: 2..=9,
};

static WORD_CONSTE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONSTE_CHILDREN),
    value: None,
};

pub static WORD_CONSTE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ntly"),
        dictgen::InsensitiveStr::Ascii("xt"),
    ],
    values: &[&["constantly"], &["context"]],
    range: 2..=4,
};

static WORD_CONSTC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONSTC_CHILDREN),
    value: None,
};

pub static WORD_CONSTC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("urts")],
    values: &[&["constructs"]],
    range: 4..=4,
};

static WORD_CONSTA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONSTA_CHILDREN),
    value: None,
};

pub static WORD_CONSTA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("in"),
        dictgen::InsensitiveStr::Ascii("ined"),
        dictgen::InsensitiveStr::Ascii("ining"),
        dictgen::InsensitiveStr::Ascii("ins"),
        dictgen::InsensitiveStr::Ascii("int"),
        dictgen::InsensitiveStr::Ascii("inte"),
        dictgen::InsensitiveStr::Ascii("inted"),
        dictgen::InsensitiveStr::Ascii("ints"),
        dictgen::InsensitiveStr::Ascii("llation"),
        dictgen::InsensitiveStr::Ascii("llations"),
        dictgen::InsensitiveStr::Ascii("n"),
        dictgen::InsensitiveStr::Ascii("nd"),
        dictgen::InsensitiveStr::Ascii("ndly"),
        dictgen::InsensitiveStr::Ascii("nly"),
        dictgen::InsensitiveStr::Ascii("ns"),
        dictgen::InsensitiveStr::Ascii("nst"),
        dictgen::InsensitiveStr::Ascii("ntins"),
        dictgen::InsensitiveStr::Ascii("ntivs"),
        dictgen::InsensitiveStr::Ascii("ntsm"),
        dictgen::InsensitiveStr::Ascii("nty"),
        dictgen::InsensitiveStr::Ascii("rin"),
        dictgen::InsensitiveStr::Ascii("rint"),
        dictgen::InsensitiveStr::Ascii("rints"),
        dictgen::InsensitiveStr::Ascii("rnation"),
        dictgen::InsensitiveStr::Ascii("snt"),
        dictgen::InsensitiveStr::Ascii("st"),
        dictgen::InsensitiveStr::Ascii("tn"),
        dictgen::InsensitiveStr::Ascii("tnly"),
        dictgen::InsensitiveStr::Ascii("tns"),
        dictgen::InsensitiveStr::Ascii("tnt"),
        dictgen::InsensitiveStr::Ascii("tnts"),
    ],
    values: &[
        &["constrain", "contain"],
        &["constrained", "contained"],
        &["constraining", "containing"],
        &["constrains", "contains"],
        &["constraint"],
        &["constrained", "constraint", "constraints"],
        &["constrained", "contained"],
        &["constraints"],
        &["constellation"],
        &["constellations"],
        &["constant"],
        &["constant"],
        &["constantly"],
        &["constantly"],
        &["constants", "constance", "constant"],
        &["constants"],
        &["constants"],
        &["constants"],
        &["constants"],
        &["constantly"],
        &["constrain"],
        &["constraint"],
        &["constraint", "constraints"],
        &["consternation"],
        &["constants"],
        &["constants"],
        &["constant"],
        &["constantly"],
        &["constants"],
        &["constant"],
        &["constants"],
    ],
    range: 1..=8,
};

static WORD_CONSR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONSR_CHILDREN),
    value: None,
};

pub static WORD_CONSR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("tuct"),
        dictgen::InsensitiveStr::Ascii("tucted"),
        dictgen::InsensitiveStr::Ascii("tuctor"),
        dictgen::InsensitiveStr::Ascii("tuctors"),
        dictgen::InsensitiveStr::Ascii("tucts"),
        dictgen::InsensitiveStr::Ascii("uction"),
        dictgen::InsensitiveStr::Ascii("uctions"),
        dictgen::InsensitiveStr::Ascii("uctor"),
        dictgen::InsensitiveStr::Ascii("uctors"),
    ],
    values: &[
        &["construct"],
        &["constructed"],
        &["constructor"],
        &["constructors"],
        &["constructs"],
        &["construction"],
        &["constructions"],
        &["constructor"],
        &["constructors"],
    ],
    range: 4..=7,
};

static WORD_CONSQ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONSQ_CHILDREN),
    value: None,
};

pub static WORD_CONSQ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("euences"),
        dictgen::InsensitiveStr::Ascii("uence"),
        dictgen::InsensitiveStr::Ascii("uences"),
        dictgen::InsensitiveStr::Ascii("uent"),
        dictgen::InsensitiveStr::Ascii("uently"),
    ],
    values: &[
        &["consequence"],
        &["consequence"],
        &["consequences"],
        &["consequent"],
        &["consequently"],
    ],
    range: 4..=7,
};

static WORD_CONSP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONSP_CHILDREN),
    value: None,
};

pub static WORD_CONSP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ericies"),
        dictgen::InsensitiveStr::Ascii("irace"),
        dictgen::InsensitiveStr::Ascii("iraces"),
        dictgen::InsensitiveStr::Ascii("iracize"),
        dictgen::InsensitiveStr::Ascii("iracys"),
        dictgen::InsensitiveStr::Ascii("irancy"),
        dictgen::InsensitiveStr::Ascii("iriator"),
        dictgen::InsensitiveStr::Ascii("iricies"),
        dictgen::InsensitiveStr::Ascii("iricy"),
        dictgen::InsensitiveStr::Ascii("riacies"),
        dictgen::InsensitiveStr::Ascii("riacy"),
    ],
    values: &[
        &["conspiracies"],
        &["conspiracies"],
        &["conspiracies"],
        &["conspiracies"],
        &["conspiracies"],
        &["conspiracy"],
        &["conspirator"],
        &["conspiracies"],
        &["conspiracy"],
        &["conspiracies"],
        &["conspiracy"],
    ],
    range: 5..=7,
};

static WORD_CONSO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONSO_CHILDREN),
    value: None,
};

pub static WORD_CONSO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("l"),
        dictgen::InsensitiveStr::Ascii("lacion"),
        dictgen::InsensitiveStr::Ascii("lato"),
        dictgen::InsensitiveStr::Ascii("ldiate"),
        dictgen::InsensitiveStr::Ascii("ldiated"),
        dictgen::InsensitiveStr::Ascii("lidad"),
        dictgen::InsensitiveStr::Ascii("lidare"),
        dictgen::InsensitiveStr::Ascii("lide"),
        dictgen::InsensitiveStr::Ascii("litated"),
        dictgen::InsensitiveStr::Ascii("lodate"),
        dictgen::InsensitiveStr::Ascii("lodated"),
        dictgen::InsensitiveStr::Ascii("ltation"),
        dictgen::InsensitiveStr::Ascii("mation"),
        dictgen::InsensitiveStr::Ascii("nent"),
        dictgen::InsensitiveStr::Ascii("nents"),
        dictgen::InsensitiveStr::Ascii("rcium"),
    ],
    values: &[
        &["console"],
        &["consolation"],
        &["consolation"],
        &["consolidate"],
        &["consolidated"],
        &["consolidated"],
        &["consolidate"],
        &["consolidate"],
        &["consolidate"],
        &["consolidate"],
        &["consolidated"],
        &["consultation"],
        &["consolation"],
        &["consonant"],
        &["consonants"],
        &["consortium"],
    ],
    range: 1..=7,
};

static WORD_CONSN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONSN_CHILDREN),
    value: None,
};

pub static WORD_CONSN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("tant"),
        dictgen::InsensitiveStr::Ascii("tantly"),
        dictgen::InsensitiveStr::Ascii("tants"),
    ],
    values: &[&["constant"], &["constantly"], &["constants"]],
    range: 4..=6,
};

static WORD_CONSL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONSL_CHILDREN),
    value: None,
};

pub static WORD_CONSL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("utant"),
        dictgen::InsensitiveStr::Ascii("utants"),
        dictgen::InsensitiveStr::Ascii("uting"),
    ],
    values: &[&["consultant"], &["consultant"], &["consulting"]],
    range: 5..=6,
};

static WORD_CONSI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_CONSI_CHILDREN),
    value: None,
};

static WORD_CONSI_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    Some(&WORD_CONSIC_NODE),
    Some(&WORD_CONSID_NODE),
    Some(&WORD_CONSIE_NODE),
    Some(&WORD_CONSIF_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_CONSIL_NODE),
    None,
    None,
    Some(&WORD_CONSIO_NODE),
    Some(&WORD_CONSIP_NODE),
    Some(&WORD_CONSIQ_NODE),
    Some(&WORD_CONSIR_NODE),
    Some(&WORD_CONSIS_NODE),
    Some(&WORD_CONSIT_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_CONSIT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONSIT_CHILDREN),
    value: Some(&["consist"]),
};

pub static WORD_CONSIT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ant"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("ency"),
        dictgen::InsensitiveStr::Ascii("ent"),
        dictgen::InsensitiveStr::Ascii("ently"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("ional"),
        dictgen::InsensitiveStr::Ascii("s"),
        dictgen::InsensitiveStr::Ascii("uencies"),
        dictgen::InsensitiveStr::Ascii("uency"),
        dictgen::InsensitiveStr::Ascii("uent"),
        dictgen::InsensitiveStr::Ascii("uents"),
        dictgen::InsensitiveStr::Ascii("ute"),
        dictgen::InsensitiveStr::Ascii("uted"),
        dictgen::InsensitiveStr::Ascii("utents"),
        dictgen::InsensitiveStr::Ascii("utes"),
        dictgen::InsensitiveStr::Ascii("uting"),
        dictgen::InsensitiveStr::Ascii("ution"),
        dictgen::InsensitiveStr::Ascii("utional"),
        dictgen::InsensitiveStr::Ascii("utuent"),
        dictgen::InsensitiveStr::Ascii("utuents"),
        dictgen::InsensitiveStr::Ascii("utute"),
        dictgen::InsensitiveStr::Ascii("ututed"),
        dictgen::InsensitiveStr::Ascii("ututes"),
        dictgen::InsensitiveStr::Ascii("ututing"),
    ],
    values: &[
        &["consistent"],
        &["consisted"],
        &["consistency"],
        &["consistent"],
        &["consistently"],
        &["consisting"],
        &["conditional"],
        &["consists"],
        &["constituencies"],
        &["constituency"],
        &["constituent"],
        &["constituents"],
        &["constitute"],
        &["constituted"],
        &["constituents"],
        &["constitutes"],
        &["constituting"],
        &["constitution"],
        &["constitutional"],
        &["constituent"],
        &["constituents"],
        &["constitute"],
        &["constituted"],
        &["constitutes"],
        &["constituting"],
    ],
    range: 1..=7,
};

static WORD_CONSIS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONSIS_CHILDREN),
    value: None,
};

pub static WORD_CONSIS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ant"),
        dictgen::InsensitiveStr::Ascii("ent"),
        dictgen::InsensitiveStr::Ascii("ently"),
        dictgen::InsensitiveStr::Ascii("ntency"),
        dictgen::InsensitiveStr::Ascii("tance"),
        dictgen::InsensitiveStr::Ascii("tancy"),
        dictgen::InsensitiveStr::Ascii("tant"),
        dictgen::InsensitiveStr::Ascii("tantly"),
        dictgen::InsensitiveStr::Ascii("ten"),
        dictgen::InsensitiveStr::Ascii("tencey"),
        dictgen::InsensitiveStr::Ascii("tend"),
        dictgen::InsensitiveStr::Ascii("tendly"),
        dictgen::InsensitiveStr::Ascii("tendt"),
        dictgen::InsensitiveStr::Ascii("tendtly"),
        dictgen::InsensitiveStr::Ascii("tenly"),
        dictgen::InsensitiveStr::Ascii("tens"),
        dictgen::InsensitiveStr::Ascii("tensy"),
        dictgen::InsensitiveStr::Ascii("tentcy"),
        dictgen::InsensitiveStr::Ascii("tenty"),
        dictgen::InsensitiveStr::Ascii("teny"),
        dictgen::InsensitiveStr::Ascii("tes"),
        dictgen::InsensitiveStr::Ascii("tuents"),
    ],
    values: &[
        &["consistent"],
        &["consistent"],
        &["consistently"],
        &["consistency"],
        &["consistency"],
        &["consistency"],
        &["consistent"],
        &["consistently"],
        &["consistent"],
        &["consistency"],
        &["consistent"],
        &["consistently"],
        &["consistent"],
        &["consistently"],
        &["consistently"],
        &["consists"],
        &["consistency"],
        &["consistently"],
        &["consistently"],
        &["consistency", "consistent"],
        &["consists", "consisted"],
        &["constituents"],
    ],
    range: 3..=7,
};

static WORD_CONSIR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONSIR_CHILDREN),
    value: None,
};

pub static WORD_CONSIR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("ed"),
    ],
    values: &[&["conspire", "consider"], &["conspired", "considered"]],
    range: 1..=2,
};

static WORD_CONSIQ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONSIQ_CHILDREN),
    value: None,
};

pub static WORD_CONSIQ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("uently")],
    values: &[&["consequently"]],
    range: 6..=6,
};

static WORD_CONSIP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONSIP_CHILDREN),
    value: None,
};

pub static WORD_CONSIP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("racies"),
        dictgen::InsensitiveStr::Ascii("racy"),
    ],
    values: &[&["conspiracies"], &["conspiracy"]],
    range: 4..=6,
};

static WORD_CONSIO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONSIO_CHILDREN),
    value: None,
};

pub static WORD_CONSIO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("us")],
    values: &[&["conscious"]],
    range: 2..=2,
};

static WORD_CONSIL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONSIL_CHILDREN),
    value: None,
};

pub static WORD_CONSIL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ation"),
        dictgen::InsensitiveStr::Ascii("idate"),
        dictgen::InsensitiveStr::Ascii("idated"),
    ],
    values: &[&["consolation"], &["consolidate"], &["consolidated"]],
    range: 5..=6,
};

static WORD_CONSIF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONSIF_CHILDREN),
    value: None,
};

pub static WORD_CONSIF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("er"),
        dictgen::InsensitiveStr::Ascii("ered"),
    ],
    values: &[&["consider"], &["considered"]],
    range: 2..=4,
};

static WORD_CONSIE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONSIE_CHILDREN),
    value: None,
};

pub static WORD_CONSIE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("r"),
        dictgen::InsensitiveStr::Ascii("rs"),
    ],
    values: &[&["consider"], &["considers"]],
    range: 1..=2,
};

static WORD_CONSID_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONSID_CHILDREN),
    value: None,
};

pub static WORD_CONSID_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("der"),
        dictgen::InsensitiveStr::Ascii("deration"),
        dictgen::InsensitiveStr::Ascii("dered"),
        dictgen::InsensitiveStr::Ascii("dering"),
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("erabe"),
        dictgen::InsensitiveStr::Ascii("erabely"),
        dictgen::InsensitiveStr::Ascii("erabile"),
        dictgen::InsensitiveStr::Ascii("erablely"),
        dictgen::InsensitiveStr::Ascii("erabley"),
        dictgen::InsensitiveStr::Ascii("erablly"),
        dictgen::InsensitiveStr::Ascii("eracion"),
        dictgen::InsensitiveStr::Ascii("erais"),
        dictgen::InsensitiveStr::Ascii("erant"),
        dictgen::InsensitiveStr::Ascii("erarle"),
        dictgen::InsensitiveStr::Ascii("erarte"),
        dictgen::InsensitiveStr::Ascii("eras"),
        dictgen::InsensitiveStr::Ascii("eraste"),
        dictgen::InsensitiveStr::Ascii("eratie"),
        dictgen::InsensitiveStr::Ascii("eratin"),
        dictgen::InsensitiveStr::Ascii("erato"),
        dictgen::InsensitiveStr::Ascii("eratoin"),
        dictgen::InsensitiveStr::Ascii("erble"),
        dictgen::InsensitiveStr::Ascii("erbly"),
        dictgen::InsensitiveStr::Ascii("erd"),
        dictgen::InsensitiveStr::Ascii("ere"),
        dictgen::InsensitiveStr::Ascii("ereis"),
        dictgen::InsensitiveStr::Ascii("eren"),
        dictgen::InsensitiveStr::Ascii("eres"),
        dictgen::InsensitiveStr::Ascii("eret"),
        dictgen::InsensitiveStr::Ascii("eribly"),
        dictgen::InsensitiveStr::Ascii("erion"),
        dictgen::InsensitiveStr::Ascii("erions"),
        dictgen::InsensitiveStr::Ascii("erstion"),
        dictgen::InsensitiveStr::Ascii("erstions"),
        dictgen::InsensitiveStr::Ascii("ert"),
        dictgen::InsensitiveStr::Ascii("ertaion"),
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("red"),
    ],
    values: &[
        &["consider"],
        &["consideration"],
        &["considered"],
        &["considering"],
        &["coincide", "consider"],
        &["considerate"],
        &["considerable"],
        &["considerable"],
        &["considerably"],
        &["considerably"],
        &["considerably"],
        &["consideration"],
        &["considers"],
        &["considerate"],
        &["considerable"],
        &["considerate"],
        &["considers"],
        &["considerate"],
        &["considerate"],
        &["considerations"],
        &["consideration"],
        &["considerations"],
        &["considerable"],
        &["considerably"],
        &["considered"],
        &["consider", "considered"],
        &["considers"],
        &["considered"],
        &["considered", "considers"],
        &["considerate"],
        &["considerably"],
        &["consideration"],
        &["considerations"],
        &["considerations"],
        &["considerations"],
        &["considerate", "considered", "consider"],
        &["considerations"],
        &["coincides", "considers"],
        &["considered"],
    ],
    range: 1..=8,
};

static WORD_CONSIC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONSIC_CHILDREN),
    value: None,
};

pub static WORD_CONSIC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("ence"),
        dictgen::InsensitiveStr::Ascii("iousness"),
        dictgen::InsensitiveStr::Ascii("ous"),
        dictgen::InsensitiveStr::Ascii("ousness"),
    ],
    values: &[
        &["concise"],
        &["conscience"],
        &["consciousness"],
        &["conscious"],
        &["consciousness"],
    ],
    range: 1..=8,
};

static WORD_CONSF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONSF_CHILDREN),
    value: None,
};

pub static WORD_CONSF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("icated")],
    values: &[&["confiscated"]],
    range: 6..=6,
};

static WORD_CONSE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_CONSE_CHILDREN),
    value: None,
};

static WORD_CONSE_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_CONSEA_NODE),
    None,
    Some(&WORD_CONSEC_NODE),
    None,
    Some(&WORD_CONSEE_NODE),
    None,
    Some(&WORD_CONSEG_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_CONSEL_NODE),
    None,
    Some(&WORD_CONSEN_NODE),
    None,
    Some(&WORD_CONSEP_NODE),
    Some(&WORD_CONSEQ_NODE),
    Some(&WORD_CONSER_NODE),
    Some(&WORD_CONSES_NODE),
    None,
    None,
    Some(&WORD_CONSEV_NODE),
    None,
    None,
    None,
    None,
];

static WORD_CONSEV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONSEV_CHILDREN),
    value: None,
};

pub static WORD_CONSEV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ible")],
    values: &[&["conceivable"]],
    range: 4..=4,
};

static WORD_CONSES_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONSES_CHILDREN),
    value: None,
};

pub static WORD_CONSES_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("tently")],
    values: &[&["consistently"]],
    range: 6..=6,
};

static WORD_CONSER_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONSER_CHILDREN),
    value: None,
};

pub static WORD_CONSER_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("n"),
        dictgen::InsensitiveStr::Ascii("ned"),
        dictgen::InsensitiveStr::Ascii("ning"),
        dictgen::InsensitiveStr::Ascii("vacion"),
        dictgen::InsensitiveStr::Ascii("vanti"),
        dictgen::InsensitiveStr::Ascii("vare"),
        dictgen::InsensitiveStr::Ascii("vatie"),
        dictgen::InsensitiveStr::Ascii("vaties"),
        dictgen::InsensitiveStr::Ascii("vatisim"),
        dictgen::InsensitiveStr::Ascii("vativeky"),
        dictgen::InsensitiveStr::Ascii("vativo"),
        dictgen::InsensitiveStr::Ascii("vativs"),
        dictgen::InsensitiveStr::Ascii("vativsm"),
        dictgen::InsensitiveStr::Ascii("vato"),
        dictgen::InsensitiveStr::Ascii("vaton"),
        dictgen::InsensitiveStr::Ascii("vice"),
        dictgen::InsensitiveStr::Ascii("vies"),
        dictgen::InsensitiveStr::Ascii("vitave"),
        dictgen::InsensitiveStr::Ascii("vite"),
        dictgen::InsensitiveStr::Ascii("vitism"),
        dictgen::InsensitiveStr::Ascii("vitive"),
        dictgen::InsensitiveStr::Ascii("vitives"),
    ],
    values: &[
        &["concern"],
        &["concerned"],
        &["concerning"],
        &["conservation"],
        &["conservation"],
        &["conserve"],
        &["conservatives"],
        &["conservatives"],
        &["conservatism"],
        &["conservatively"],
        &["conservation"],
        &["conservatism"],
        &["conservatism"],
        &["conservation"],
        &["conservation"],
        &["conserve"],
        &["conserve"],
        &["conservatives"],
        &["conserve"],
        &["conservatism"],
        &["conservative"],
        &["conservatives"],
    ],
    range: 1..=8,
};

static WORD_CONSEQ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONSEQ_CHILDREN),
    value: None,
};

pub static WORD_CONSEQ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eunces"),
        dictgen::InsensitiveStr::Ascii("uece"),
        dictgen::InsensitiveStr::Ascii("uencies"),
        dictgen::InsensitiveStr::Ascii("uenes"),
        dictgen::InsensitiveStr::Ascii("uense"),
        dictgen::InsensitiveStr::Ascii("uenses"),
        dictgen::InsensitiveStr::Ascii("uental"),
        dictgen::InsensitiveStr::Ascii("uente"),
        dictgen::InsensitiveStr::Ascii("uentely"),
        dictgen::InsensitiveStr::Ascii("uentually"),
        dictgen::InsensitiveStr::Ascii("uenty"),
        dictgen::InsensitiveStr::Ascii("ueseces"),
        dictgen::InsensitiveStr::Ascii("uetive"),
        dictgen::InsensitiveStr::Ascii("unce"),
        dictgen::InsensitiveStr::Ascii("uneces"),
        dictgen::InsensitiveStr::Ascii("utive"),
        dictgen::InsensitiveStr::Ascii("utively"),
    ],
    values: &[
        &["consequence"],
        &["consequence"],
        &["consequence"],
        &["consequence"],
        &["consequences"],
        &["consequences"],
        &["consequently"],
        &["consequence"],
        &["consequently"],
        &["consequently"],
        &["consequently"],
        &["consequences"],
        &["consecutive"],
        &["consequence"],
        &["consequence"],
        &["consecutive"],
        &["consecutively"],
    ],
    range: 4..=9,
};

static WORD_CONSEP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONSEP_CHILDREN),
    value: None,
};

pub static WORD_CONSEP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("ts"),
    ],
    values: &[&["concept"], &["concepts"]],
    range: 1..=2,
};

static WORD_CONSEN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONSEN_CHILDREN),
    value: None,
};

pub static WORD_CONSEN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ding"),
        dictgen::InsensitiveStr::Ascii("quently"),
        dictgen::InsensitiveStr::Ascii("sis"),
        dictgen::InsensitiveStr::Ascii("suarlo"),
        dictgen::InsensitiveStr::Ascii("suel"),
        dictgen::InsensitiveStr::Ascii("sul"),
        dictgen::InsensitiveStr::Ascii("tious"),
        dictgen::InsensitiveStr::Ascii("tiously"),
        dictgen::InsensitiveStr::Ascii("trate"),
        dictgen::InsensitiveStr::Ascii("trated"),
        dictgen::InsensitiveStr::Ascii("trates"),
        dictgen::InsensitiveStr::Ascii("trating"),
        dictgen::InsensitiveStr::Ascii("tration"),
        dictgen::InsensitiveStr::Ascii("trations"),
        dictgen::InsensitiveStr::Ascii("usal"),
    ],
    values: &[
        &["consenting"],
        &["consequently"],
        &["consensus"],
        &["consensual"],
        &["consensual"],
        &["consensual"],
        &["conscientious"],
        &["conscientiously"],
        &["concentrate"],
        &["concentrated"],
        &["concentrates"],
        &["concentrating"],
        &["concentration"],
        &["concentrations"],
        &["consensual"],
    ],
    range: 3..=8,
};

static WORD_CONSEL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONSEL_CHILDREN),
    value: None,
};

pub static WORD_CONSEL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ation")],
    values: &[&["consolation"]],
    range: 5..=5,
};

static WORD_CONSEG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONSEG_CHILDREN),
    value: None,
};

pub static WORD_CONSEG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("uence")],
    values: &[&["consequence"]],
    range: 5..=5,
};

static WORD_CONSEE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONSEE_CHILDREN),
    value: None,
};

pub static WORD_CONSEE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("d"),
        dictgen::InsensitiveStr::Ascii("dd"),
        dictgen::InsensitiveStr::Ascii("ded"),
        dictgen::InsensitiveStr::Ascii("ds"),
    ],
    values: &[&["concede"], &["conceded"], &["conceded"], &["concedes"]],
    range: 1..=3,
};

static WORD_CONSEC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONSEC_CHILDREN),
    value: None,
};

pub static WORD_CONSEC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("tive"),
        dictgen::InsensitiveStr::Ascii("tively"),
        dictgen::InsensitiveStr::Ascii("tuive"),
        dictgen::InsensitiveStr::Ascii("tutive"),
        dictgen::InsensitiveStr::Ascii("tuve"),
        dictgen::InsensitiveStr::Ascii("uence"),
        dictgen::InsensitiveStr::Ascii("uences"),
        dictgen::InsensitiveStr::Ascii("uentes"),
        dictgen::InsensitiveStr::Ascii("uently"),
        dictgen::InsensitiveStr::Ascii("uitively"),
        dictgen::InsensitiveStr::Ascii("utevily"),
    ],
    values: &[
        &["consecutive"],
        &["consecutively"],
        &["consecutive"],
        &["consecutive"],
        &["consecutive"],
        &["consequence"],
        &["consequences"],
        &["consequences"],
        &["consequently"],
        &["consecutively"],
        &["consecutively"],
    ],
    range: 4..=8,
};

static WORD_CONSEA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONSEA_CHILDREN),
    value: None,
};

pub static WORD_CONSEA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("ted"),
    ],
    values: &[&["conceit"], &["conceited"]],
    range: 1..=3,
};

static WORD_CONSD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONSD_CHILDREN),
    value: None,
};

pub static WORD_CONSD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ider"),
        dictgen::InsensitiveStr::Ascii("idered"),
        dictgen::InsensitiveStr::Ascii("ieration"),
        dictgen::InsensitiveStr::Ascii("iered"),
        dictgen::InsensitiveStr::Ascii("ired"),
    ],
    values: &[
        &["consider"],
        &["considered"],
        &["considerations"],
        &["considered"],
        &["considered"],
    ],
    range: 4..=8,
};

static WORD_CONSC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONSC_CHILDREN),
    value: None,
};

pub static WORD_CONSC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ent"),
        dictgen::InsensitiveStr::Ascii("iencious"),
        dictgen::InsensitiveStr::Ascii("iense"),
        dictgen::InsensitiveStr::Ascii("iouly"),
        dictgen::InsensitiveStr::Ascii("iouness"),
        dictgen::InsensitiveStr::Ascii("iousely"),
        dictgen::InsensitiveStr::Ascii("iouslly"),
        dictgen::InsensitiveStr::Ascii("ioussness"),
        dictgen::InsensitiveStr::Ascii("truct"),
        dictgen::InsensitiveStr::Ascii("tructed"),
        dictgen::InsensitiveStr::Ascii("tructing"),
        dictgen::InsensitiveStr::Ascii("truction"),
        dictgen::InsensitiveStr::Ascii("tructions"),
        dictgen::InsensitiveStr::Ascii("tructive"),
        dictgen::InsensitiveStr::Ascii("tructor"),
        dictgen::InsensitiveStr::Ascii("tructors"),
        dictgen::InsensitiveStr::Ascii("tructs"),
    ],
    values: &[
        &["consent"],
        &["conscientious"],
        &["conscience"],
        &["consciously"],
        &["consciousness"],
        &["consciously"],
        &["consciously"],
        &["consciousness"],
        &["construct"],
        &["constructed"],
        &["constructing"],
        &["construction"],
        &["constructions"],
        &["constructive"],
        &["constructor"],
        &["constructors"],
        &["constructs"],
    ],
    range: 3..=9,
};

static WORD_CONSA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONSA_CHILDREN),
    value: None,
};

pub static WORD_CONSA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("nts")],
    values: &[&["constants"]],
    range: 3..=3,
};

static WORD_CONR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONR_CHILDREN),
    value: None,
};

pub static WORD_CONR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ete"),
        dictgen::InsensitiveStr::Ascii("ol"),
        dictgen::InsensitiveStr::Ascii("oller"),
        dictgen::InsensitiveStr::Ascii("respond"),
        dictgen::InsensitiveStr::Ascii("respondence"),
        dictgen::InsensitiveStr::Ascii("respondences"),
        dictgen::InsensitiveStr::Ascii("respondent"),
        dictgen::InsensitiveStr::Ascii("respondents"),
        dictgen::InsensitiveStr::Ascii("responding"),
        dictgen::InsensitiveStr::Ascii("respondingly"),
        dictgen::InsensitiveStr::Ascii("responds"),
        dictgen::InsensitiveStr::Ascii("rol"),
        dictgen::InsensitiveStr::Ascii("rupt"),
        dictgen::InsensitiveStr::Ascii("ruptable"),
        dictgen::InsensitiveStr::Ascii("rupted"),
        dictgen::InsensitiveStr::Ascii("ruptible"),
        dictgen::InsensitiveStr::Ascii("ruption"),
        dictgen::InsensitiveStr::Ascii("ruptions"),
        dictgen::InsensitiveStr::Ascii("rupts"),
        dictgen::InsensitiveStr::Ascii("tib"),
        dictgen::InsensitiveStr::Ascii("tibs"),
        dictgen::InsensitiveStr::Ascii("tibuting"),
    ],
    values: &[
        &["concrete"],
        &["control"],
        &["controller"],
        &["correspond"],
        &["correspondence"],
        &["correspondences"],
        &["correspondent"],
        &["correspondents"],
        &["corresponding"],
        &["correspondingly"],
        &["corresponds"],
        &["control"],
        &["corrupt"],
        &["corruptible"],
        &["corrupted"],
        &["corruptible"],
        &["corruption"],
        &["corruptions"],
        &["corrupts"],
        &["contrib"],
        &["contribs"],
        &["contributing"],
    ],
    range: 2..=12,
};

static WORD_CONQ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONQ_CHILDREN),
    value: None,
};

pub static WORD_CONQ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eur"),
        dictgen::InsensitiveStr::Ascii("euring"),
        dictgen::InsensitiveStr::Ascii("ouring"),
        dictgen::InsensitiveStr::Ascii("ueor"),
        dictgen::InsensitiveStr::Ascii("uerd"),
        dictgen::InsensitiveStr::Ascii("uerer"),
        dictgen::InsensitiveStr::Ascii("uerers"),
        dictgen::InsensitiveStr::Ascii("uerring"),
        dictgen::InsensitiveStr::Ascii("uoring"),
        dictgen::InsensitiveStr::Ascii("ure"),
        dictgen::InsensitiveStr::Ascii("ured"),
    ],
    values: &[
        &["conquer"],
        &["conquering"],
        &["conquering"],
        &["conquer"],
        &["conquered"],
        &["conqueror"],
        &["conquerors"],
        &["conquering"],
        &["conquering"],
        &["conquer"],
        &["conquered"],
    ],
    range: 3..=7,
};

static WORD_CONP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONP_CHILDREN),
    value: None,
};

pub static WORD_CONP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ares"),
        dictgen::InsensitiveStr::Ascii("assionate"),
        dictgen::InsensitiveStr::Ascii("ensating"),
        dictgen::InsensitiveStr::Ascii("ensation"),
        dictgen::InsensitiveStr::Ascii("etitions"),
        dictgen::InsensitiveStr::Ascii("lete"),
        dictgen::InsensitiveStr::Ascii("leted"),
        dictgen::InsensitiveStr::Ascii("letes"),
        dictgen::InsensitiveStr::Ascii("leting"),
        dictgen::InsensitiveStr::Ascii("letion"),
        dictgen::InsensitiveStr::Ascii("lications"),
        dictgen::InsensitiveStr::Ascii("limentary"),
        dictgen::InsensitiveStr::Ascii("limented"),
        dictgen::InsensitiveStr::Ascii("limenting"),
        dictgen::InsensitiveStr::Ascii("rehension"),
        dictgen::InsensitiveStr::Ascii("ress"),
        dictgen::InsensitiveStr::Ascii("ressed"),
        dictgen::InsensitiveStr::Ascii("romising"),
        dictgen::InsensitiveStr::Ascii("siracy"),
    ],
    values: &[
        &["compares"],
        &["compassionate"],
        &["compensating"],
        &["compensation"],
        &["competitions"],
        &["complete"],
        &["completed"],
        &["completes"],
        &["completing"],
        &["completion"],
        &["complications"],
        &["complimentary"],
        &["complimented"],
        &["complimenting"],
        &["comprehension"],
        &["compress"],
        &["compressed"],
        &["compromising"],
        &["conspiracy"],
    ],
    range: 4..=9,
};

static WORD_CONO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONO_CHILDREN),
    value: None,
};

pub static WORD_CONO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("lization"),
        dictgen::InsensitiveStr::Ascii("ntation"),
        dictgen::InsensitiveStr::Ascii("suer"),
        dictgen::InsensitiveStr::Ascii("tation"),
        dictgen::InsensitiveStr::Ascii("tations"),
        dictgen::InsensitiveStr::Ascii("trol"),
        dictgen::InsensitiveStr::Ascii("troled"),
        dictgen::InsensitiveStr::Ascii("troling"),
        dictgen::InsensitiveStr::Ascii("trolled"),
        dictgen::InsensitiveStr::Ascii("trols"),
    ],
    values: &[
        &["colonization"],
        &["connotation"],
        &["connoisseur"],
        &["connotation"],
        &["connotations"],
        &["control"],
        &["controlled"],
        &["controlling"],
        &["controlled"],
        &["controls"],
    ],
    range: 4..=8,
};

static WORD_CONN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_CONN_CHILDREN),
    value: None,
};

static WORD_CONN_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_CONNA_NODE),
    None,
    Some(&WORD_CONNC_NODE),
    None,
    Some(&WORD_CONNE_NODE),
    None,
    None,
    None,
    Some(&WORD_CONNI_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_CONNN_NODE),
    Some(&WORD_CONNO_NODE),
    None,
    None,
    None,
    Some(&WORD_CONNS_NODE),
    Some(&WORD_CONNT_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_CONNT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONNT_CHILDREN),
    value: None,
};

pub static WORD_CONNT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ents"),
        dictgen::InsensitiveStr::Ascii("roller"),
    ],
    values: &[&["contents"], &["controller"]],
    range: 4..=6,
};

static WORD_CONNS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONNS_CHILDREN),
    value: None,
};

pub static WORD_CONNS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("train"),
        dictgen::InsensitiveStr::Ascii("trained"),
        dictgen::InsensitiveStr::Ascii("traint"),
    ],
    values: &[&["constrain"], &["constrained"], &["constraint"]],
    range: 5..=7,
};

static WORD_CONNO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONNO_CHILDREN),
    value: None,
};

pub static WORD_CONNO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("nation"),
        dictgen::InsensitiveStr::Ascii("nations"),
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("tacion"),
        dictgen::InsensitiveStr::Ascii("taion"),
    ],
    values: &[
        &["connotation"],
        &["connotations"],
        &["cannot"],
        &["connotation"],
        &["connotation"],
    ],
    range: 1..=7,
};

static WORD_CONNN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONNN_CHILDREN),
    value: None,
};

pub static WORD_CONNN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ect"),
        dictgen::InsensitiveStr::Ascii("ected"),
        dictgen::InsensitiveStr::Ascii("ecting"),
        dictgen::InsensitiveStr::Ascii("ection"),
        dictgen::InsensitiveStr::Ascii("ections"),
        dictgen::InsensitiveStr::Ascii("ects"),
    ],
    values: &[
        &["connect"],
        &["connected"],
        &["connecting"],
        &["connection"],
        &["connections"],
        &["connects"],
    ],
    range: 3..=7,
};

static WORD_CONNI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONNI_CHILDREN),
    value: None,
};

pub static WORD_CONNI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("tations")],
    values: &[&["connotations"]],
    range: 7..=7,
};

static WORD_CONNE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONNE_CHILDREN),
    value: None,
};

pub static WORD_CONNE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cetd"),
        dictgen::InsensitiveStr::Ascii("cion"),
        dictgen::InsensitiveStr::Ascii("cions"),
        dictgen::InsensitiveStr::Ascii("citcut"),
        dictgen::InsensitiveStr::Ascii("citon"),
        dictgen::InsensitiveStr::Ascii("citons"),
        dictgen::InsensitiveStr::Ascii("cor"),
        dictgen::InsensitiveStr::Ascii("cotr"),
        dictgen::InsensitiveStr::Ascii("cs"),
        dictgen::InsensitiveStr::Ascii("cstatus"),
        dictgen::InsensitiveStr::Ascii("ctd"),
        dictgen::InsensitiveStr::Ascii("cte"),
        dictgen::InsensitiveStr::Ascii("ctec"),
        dictgen::InsensitiveStr::Ascii("ctes"),
        dictgen::InsensitiveStr::Ascii("ctet"),
        dictgen::InsensitiveStr::Ascii("ctibity"),
        dictgen::InsensitiveStr::Ascii("cticon"),
        dictgen::InsensitiveStr::Ascii("cticuit"),
        dictgen::InsensitiveStr::Ascii("cticunts"),
        dictgen::InsensitiveStr::Ascii("cties"),
        dictgen::InsensitiveStr::Ascii("ctin"),
        dictgen::InsensitiveStr::Ascii("ctino"),
        dictgen::InsensitiveStr::Ascii("ctinos"),
        dictgen::InsensitiveStr::Ascii("ctins"),
        dictgen::InsensitiveStr::Ascii("ctiom"),
        dictgen::InsensitiveStr::Ascii("ctioms"),
        dictgen::InsensitiveStr::Ascii("ctiona"),
        dictgen::InsensitiveStr::Ascii("ctionas"),
        dictgen::InsensitiveStr::Ascii("ctiong"),
        dictgen::InsensitiveStr::Ascii("ctit"),
        dictgen::InsensitiveStr::Ascii("ctivety"),
        dictgen::InsensitiveStr::Ascii("ctivitiy"),
        dictgen::InsensitiveStr::Ascii("ctiviy"),
        dictgen::InsensitiveStr::Ascii("ctivty"),
        dictgen::InsensitiveStr::Ascii("ctivy"),
        dictgen::InsensitiveStr::Ascii("cto"),
        dictgen::InsensitiveStr::Ascii("cton"),
        dictgen::InsensitiveStr::Ascii("ctos"),
        dictgen::InsensitiveStr::Ascii("ctpro"),
        dictgen::InsensitiveStr::Ascii("ctted"),
        dictgen::InsensitiveStr::Ascii("cttion"),
        dictgen::InsensitiveStr::Ascii("ection"),
        dictgen::InsensitiveStr::Ascii("iction"),
        dictgen::InsensitiveStr::Ascii("ktors"),
        dictgen::InsensitiveStr::Ascii("tation"),
        dictgen::InsensitiveStr::Ascii("tations"),
        dictgen::InsensitiveStr::Ascii("tced"),
        dictgen::InsensitiveStr::Ascii("tcion"),
        dictgen::InsensitiveStr::Ascii("ted"),
        dictgen::InsensitiveStr::Ascii("ticut"),
        dictgen::InsensitiveStr::Ascii("tion"),
        dictgen::InsensitiveStr::Ascii("tor"),
        dictgen::InsensitiveStr::Ascii("xtion"),
    ],
    values: &[
        &["connected"],
        &["connection"],
        &["connections"],
        &["connecticut"],
        &["connection"],
        &["connections"],
        &["connector"],
        &["connector"],
        &["connects"],
        &["connectstatus"],
        &["connected"],
        &["connected"],
        &["connected"],
        &["connects"],
        &["connected"],
        &["connectivity"],
        &["connection"],
        &["connecticut"],
        &["connecticut"],
        &["connects"],
        &["connecting", "connection"],
        &["connection"],
        &["connections"],
        &["connects", "connections"],
        &["connection"],
        &["connections"],
        &["connection"],
        &["connections"],
        &["connecting"],
        &["connecticut"],
        &["connectivity"],
        &["connectivity"],
        &["connectivity"],
        &["connectivity"],
        &["connectivity"],
        &["connect"],
        &["connection", "connector"],
        &["connectors"],
        &["connector"],
        &["connected"],
        &["connection"],
        &["connection"],
        &["connection"],
        &["connectors"],
        &["connotation"],
        &["connotations"],
        &["connected"],
        &["connection"],
        &["connected"],
        &["connecticut"],
        &["connection"],
        &["connector"],
        &["connexion"],
    ],
    range: 2..=8,
};

static WORD_CONNC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONNC_CHILDREN),
    value: None,
};

pub static WORD_CONNC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ection"),
        dictgen::InsensitiveStr::Ascii("etion"),
        dictgen::InsensitiveStr::Ascii("tion"),
        dictgen::InsensitiveStr::Ascii("urrent"),
    ],
    values: &[
        &["connection"],
        &["connections", "connection"],
        &["connection"],
        &["concurrent"],
    ],
    range: 4..=6,
};

static WORD_CONNA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONNA_CHILDREN),
    value: None,
};

pub static WORD_CONNA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ect"),
        dictgen::InsensitiveStr::Ascii("tation"),
        dictgen::InsensitiveStr::Ascii("tations"),
    ],
    values: &[&["connect"], &["connotation"], &["connotations"]],
    range: 3..=7,
};

static WORD_CONM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONM_CHILDREN),
    value: None,
};

pub static WORD_CONM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("nection"),
        dictgen::InsensitiveStr::Ascii("press"),
        dictgen::InsensitiveStr::Ascii("pression"),
    ],
    values: &[&["connection"], &["compress"], &["compression"]],
    range: 5..=8,
};

static WORD_CONL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONL_CHILDREN),
    value: None,
};

pub static WORD_CONL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cude"),
        dictgen::InsensitiveStr::Ascii("cuded"),
        dictgen::InsensitiveStr::Ascii("cudes"),
        dictgen::InsensitiveStr::Ascii("cuding"),
        dictgen::InsensitiveStr::Ascii("cusion"),
        dictgen::InsensitiveStr::Ascii("cusions"),
        dictgen::InsensitiveStr::Ascii("y"),
    ],
    values: &[
        &["conclude"],
        &["concluded"],
        &["concludes"],
        &["concluding"],
        &["conclusion"],
        &["conclusions"],
        &["only"],
    ],
    range: 1..=7,
};

static WORD_CONJ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONJ_CHILDREN),
    value: None,
};

pub static WORD_CONJ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ecutre"),
        dictgen::InsensitiveStr::Ascii("onction"),
        dictgen::InsensitiveStr::Ascii("onctive"),
        dictgen::InsensitiveStr::Ascii("ucntion"),
        dictgen::InsensitiveStr::Ascii("uction"),
        dictgen::InsensitiveStr::Ascii("uctions"),
        dictgen::InsensitiveStr::Ascii("uncion"),
        dictgen::InsensitiveStr::Ascii("uncting"),
        dictgen::InsensitiveStr::Ascii("untion"),
        dictgen::InsensitiveStr::Ascii("untions"),
    ],
    values: &[
        &["conjecture"],
        &["conjunction"],
        &["conjunctive"],
        &["conjunction"],
        &["conjunction"],
        &["conjunctions"],
        &["conjunction"],
        &["conjunction"],
        &["conjunction"],
        &["conjunctions"],
    ],
    range: 6..=7,
};

static WORD_CONI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONI_CHILDREN),
    value: None,
};

pub static WORD_CONI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cide"),
        dictgen::InsensitiveStr::Ascii("cidence"),
        dictgen::InsensitiveStr::Ascii("cidental"),
        dictgen::InsensitiveStr::Ascii("cidentally"),
        dictgen::InsensitiveStr::Ascii("der"),
        dictgen::InsensitiveStr::Ascii("fguration"),
        dictgen::InsensitiveStr::Ascii("fgurations"),
        dictgen::InsensitiveStr::Ascii("figuration"),
        dictgen::InsensitiveStr::Ascii("g"),
        dictgen::InsensitiveStr::Ascii("gurable"),
        dictgen::InsensitiveStr::Ascii("gured"),
        dictgen::InsensitiveStr::Ascii("ncide"),
        dictgen::InsensitiveStr::Ascii("ncidence"),
        dictgen::InsensitiveStr::Ascii("ncident"),
        dictgen::InsensitiveStr::Ascii("ncides"),
        dictgen::InsensitiveStr::Ascii("nciding"),
        dictgen::InsensitiveStr::Ascii("nient"),
        dictgen::InsensitiveStr::Ascii("nstallable"),
        dictgen::InsensitiveStr::Ascii("nuation"),
        dictgen::InsensitiveStr::Ascii("nue"),
        dictgen::InsensitiveStr::Ascii("nues"),
        dictgen::InsensitiveStr::Ascii("nuity"),
        dictgen::InsensitiveStr::Ascii("nuous"),
        dictgen::InsensitiveStr::Ascii("rm"),
        dictgen::InsensitiveStr::Ascii("sderation"),
        dictgen::InsensitiveStr::Ascii("tinue"),
        dictgen::InsensitiveStr::Ascii("ved"),
    ],
    values: &[
        &["coincide"],
        &["coincidence"],
        &["coincidental"],
        &["coincidentally"],
        &["consider"],
        &["configurations", "configuration"],
        &["configurations"],
        &["configuration"],
        &["config"],
        &["configurable"],
        &["configured"],
        &["coincide"],
        &["coincidence"],
        &["coincident"],
        &["coincides"],
        &["coinciding"],
        &["convenient"],
        &["coinstallable"],
        &["continuation"],
        &["continue"],
        &["continues"],
        &["continuity"],
        &["continuous"],
        &["confirm"],
        &["considerations"],
        &["continue"],
        &["connived"],
    ],
    range: 1..=10,
};

static WORD_CONG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONG_CHILDREN),
    value: None,
};

pub static WORD_CONG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("egration"),
        dictgen::InsensitiveStr::Ascii("ergation"),
        dictgen::InsensitiveStr::Ascii("ifurable"),
        dictgen::InsensitiveStr::Ascii("ifuration"),
        dictgen::InsensitiveStr::Ascii("ifure"),
        dictgen::InsensitiveStr::Ascii("ifured"),
        dictgen::InsensitiveStr::Ascii("ig"),
        dictgen::InsensitiveStr::Ascii("igs"),
        dictgen::InsensitiveStr::Ascii("iguration"),
        dictgen::InsensitiveStr::Ascii("igurations"),
        dictgen::InsensitiveStr::Ascii("igure"),
        dictgen::InsensitiveStr::Ascii("itive"),
        dictgen::InsensitiveStr::Ascii("laturation"),
        dictgen::InsensitiveStr::Ascii("laturations"),
        dictgen::InsensitiveStr::Ascii("nition"),
        dictgen::InsensitiveStr::Ascii("nitive"),
        dictgen::InsensitiveStr::Ascii("radulate"),
        dictgen::InsensitiveStr::Ascii("radulations"),
        dictgen::InsensitiveStr::Ascii("ragation"),
        dictgen::InsensitiveStr::Ascii("ragulate"),
        dictgen::InsensitiveStr::Ascii("ragulations"),
        dictgen::InsensitiveStr::Ascii("rassman"),
        dictgen::InsensitiveStr::Ascii("ratualte"),
        dictgen::InsensitiveStr::Ascii("ratualted"),
        dictgen::InsensitiveStr::Ascii("ratualtions"),
        dictgen::InsensitiveStr::Ascii("ratuate"),
        dictgen::InsensitiveStr::Ascii("ratulatons"),
        dictgen::InsensitiveStr::Ascii("ratule"),
        dictgen::InsensitiveStr::Ascii("raturations"),
        dictgen::InsensitiveStr::Ascii("regacion"),
        dictgen::InsensitiveStr::Ascii("resional"),
        dictgen::InsensitiveStr::Ascii("resman"),
        dictgen::InsensitiveStr::Ascii("resmen"),
        dictgen::InsensitiveStr::Ascii("ressen"),
        dictgen::InsensitiveStr::Ascii("resssman"),
        dictgen::InsensitiveStr::Ascii("resssmen"),
        dictgen::InsensitiveStr::Ascii("retation"),
        dictgen::InsensitiveStr::Ascii("rigation"),
    ],
    values: &[
        &["congregation"],
        &["congregation"],
        &["configurable"],
        &["configuration"],
        &["configure"],
        &["configured"],
        &["config"],
        &["configs"],
        &["configuration"],
        &["configurations"],
        &["configure"],
        &["cognitive"],
        &["congratulations"],
        &["congratulations"],
        &["cognition"],
        &["cognitive"],
        &["congratulate"],
        &["congratulations"],
        &["congregation"],
        &["congratulate"],
        &["congratulations"],
        &["congressman"],
        &["congratulate"],
        &["congratulate"],
        &["congratulations"],
        &["congratulate"],
        &["congratulations"],
        &["congratulate"],
        &["congratulations"],
        &["congregation"],
        &["congressional"],
        &["congressman"],
        &["congressmen"],
        &["congressmen"],
        &["congressman"],
        &["congressmen"],
        &["congregation"],
        &["congregation"],
    ],
    range: 2..=11,
};

static WORD_CONF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_CONF_CHILDREN),
    value: None,
};

static WORD_CONF_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    None,
    None,
    Some(&WORD_CONFE_NODE),
    Some(&WORD_CONFF_NODE),
    Some(&WORD_CONFG_NODE),
    None,
    Some(&WORD_CONFI_NODE),
    None,
    None,
    Some(&WORD_CONFL_NODE),
    None,
    None,
    Some(&WORD_CONFO_NODE),
    None,
    None,
    Some(&WORD_CONFR_NODE),
    None,
    None,
    Some(&WORD_CONFU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_CONFU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONFU_CHILDREN),
    value: None,
};

pub static WORD_CONFU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cing"),
        dictgen::InsensitiveStr::Ascii("cion"),
        dictgen::InsensitiveStr::Ascii("ction"),
        dictgen::InsensitiveStr::Ascii("dion"),
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("giration"),
        dictgen::InsensitiveStr::Ascii("girble"),
        dictgen::InsensitiveStr::Ascii("gire"),
        dictgen::InsensitiveStr::Ascii("gired"),
        dictgen::InsensitiveStr::Ascii("gires"),
        dictgen::InsensitiveStr::Ascii("giring"),
        dictgen::InsensitiveStr::Ascii("grable"),
        dictgen::InsensitiveStr::Ascii("gration"),
        dictgen::InsensitiveStr::Ascii("gre"),
        dictgen::InsensitiveStr::Ascii("gred"),
        dictgen::InsensitiveStr::Ascii("gres"),
        dictgen::InsensitiveStr::Ascii("gring"),
        dictgen::InsensitiveStr::Ascii("gurable"),
        dictgen::InsensitiveStr::Ascii("guration"),
        dictgen::InsensitiveStr::Ascii("gurations"),
        dictgen::InsensitiveStr::Ascii("gure"),
        dictgen::InsensitiveStr::Ascii("gured"),
        dictgen::InsensitiveStr::Ascii("gures"),
        dictgen::InsensitiveStr::Ascii("guring"),
        dictgen::InsensitiveStr::Ascii("igration"),
        dictgen::InsensitiveStr::Ascii("igrations"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("nction"),
        dictgen::InsensitiveStr::Ascii("nder"),
        dictgen::InsensitiveStr::Ascii("nse"),
        dictgen::InsensitiveStr::Ascii("nsed"),
        dictgen::InsensitiveStr::Ascii("nses"),
        dictgen::InsensitiveStr::Ascii("nsing"),
        dictgen::InsensitiveStr::Ascii("rable"),
        dictgen::InsensitiveStr::Ascii("ration"),
        dictgen::InsensitiveStr::Ascii("re"),
        dictgen::InsensitiveStr::Ascii("red"),
        dictgen::InsensitiveStr::Ascii("res"),
        dictgen::InsensitiveStr::Ascii("ring"),
        dictgen::InsensitiveStr::Ascii("rse"),
        dictgen::InsensitiveStr::Ascii("rsed"),
        dictgen::InsensitiveStr::Ascii("rses"),
        dictgen::InsensitiveStr::Ascii("rsing"),
        dictgen::InsensitiveStr::Ascii("ssion"),
        dictgen::InsensitiveStr::Ascii("ssions"),
        dictgen::InsensitiveStr::Ascii("sting"),
        dictgen::InsensitiveStr::Ascii("ze"),
        dictgen::InsensitiveStr::Ascii("zed"),
        dictgen::InsensitiveStr::Ascii("zes"),
        dictgen::InsensitiveStr::Ascii("zing"),
        dictgen::InsensitiveStr::Ascii("zze"),
        dictgen::InsensitiveStr::Ascii("zzed"),
        dictgen::InsensitiveStr::Ascii("zzes"),
        dictgen::InsensitiveStr::Ascii("zzing"),
    ],
    values: &[
        &["confusing"],
        &["confusion"],
        &["conjunction"],
        &["confusion"],
        &["confuse"],
        &["confused"],
        &["confuses"],
        &["configuration"],
        &["configurable"],
        &["configure"],
        &["configured"],
        &["configures"],
        &["configuring"],
        &["configurable"],
        &["configuration"],
        &["configure"],
        &["configured"],
        &["configures"],
        &["configuring"],
        &["configurable"],
        &["configuration"],
        &["configurations"],
        &["configure"],
        &["configured"],
        &["configures"],
        &["configuring"],
        &["configuration"],
        &["configurations"],
        &["confusing"],
        &["conjunction"],
        &["confounder"],
        &["confuse"],
        &["confused"],
        &["confuses"],
        &["confusing"],
        &["configurable"],
        &["configuration"],
        &["configure"],
        &["configured"],
        &["configures"],
        &["configuring"],
        &["confuse"],
        &["confused"],
        &["confuses"],
        &["confusing"],
        &["confession"],
        &["confessions"],
        &["confusing"],
        &["confuse"],
        &["confused"],
        &["confuses"],
        &["confusing"],
        &["confuse"],
        &["confused"],
        &["confuses"],
        &["confusing"],
    ],
    range: 1..=9,
};

static WORD_CONFR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONFR_CHILDREN),
    value: None,
};

pub static WORD_CONFR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("entation"),
        dictgen::InsensitiveStr::Ascii("entational"),
        dictgen::InsensitiveStr::Ascii("im"),
        dictgen::InsensitiveStr::Ascii("imation"),
        dictgen::InsensitiveStr::Ascii("imations"),
        dictgen::InsensitiveStr::Ascii("imed"),
        dictgen::InsensitiveStr::Ascii("iming"),
        dictgen::InsensitiveStr::Ascii("ims"),
        dictgen::InsensitiveStr::Ascii("ontacion"),
        dictgen::InsensitiveStr::Ascii("ontacional"),
        dictgen::InsensitiveStr::Ascii("ontaion"),
        dictgen::InsensitiveStr::Ascii("ontating"),
        dictgen::InsensitiveStr::Ascii("ontativo"),
        dictgen::InsensitiveStr::Ascii("ontato"),
    ],
    values: &[
        &["confrontation"],
        &["confrontational"],
        &["confirm"],
        &["confirmation"],
        &["confirmations"],
        &["confirmed"],
        &["confirming"],
        &["confirms"],
        &["confrontation"],
        &["confrontational"],
        &["confrontation"],
        &["confrontation"],
        &["confrontation"],
        &["confrontation"],
    ],
    range: 2..=10,
};

static WORD_CONFO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONFO_CHILDREN),
    value: None,
};

pub static WORD_CONFO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("g"),
        dictgen::InsensitiveStr::Ascii("guration"),
        dictgen::InsensitiveStr::Ascii("rt"),
        dictgen::InsensitiveStr::Ascii("rtable"),
    ],
    values: &[
        &["config"],
        &["configuration"],
        &["comfort"],
        &["comfortable"],
    ],
    range: 1..=8,
};

static WORD_CONFL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONFL_CHILDREN),
    value: None,
};

pub static WORD_CONFL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cit"),
        dictgen::InsensitiveStr::Ascii("citing"),
        dictgen::InsensitiveStr::Ascii("cits"),
        dictgen::InsensitiveStr::Ascii("cting"),
        dictgen::InsensitiveStr::Ascii("icing"),
        dictgen::InsensitiveStr::Ascii("ics"),
        dictgen::InsensitiveStr::Ascii("ictd"),
        dictgen::InsensitiveStr::Ascii("ictin"),
        dictgen::InsensitiveStr::Ascii("ictos"),
        dictgen::InsensitiveStr::Ascii("ift"),
        dictgen::InsensitiveStr::Ascii("it"),
        dictgen::InsensitiveStr::Ascii("iting"),
    ],
    values: &[
        &["conflict"],
        &["conflicting"],
        &["conflicts"],
        &["conflating"],
        &["conflicting"],
        &["conflicts"],
        &["conflicts", "conflicted"],
        &["conflicting"],
        &["conflicts"],
        &["conflict"],
        &["conflict"],
        &["conflating"],
    ],
    range: 2..=6,
};

static WORD_CONFI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_CONFI_CHILDREN),
    value: None,
};

static WORD_CONFI_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    Some(&WORD_CONFIC_NODE),
    Some(&WORD_CONFID_NODE),
    None,
    Some(&WORD_CONFIF_NODE),
    Some(&WORD_CONFIG_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_CONFIL_NODE),
    Some(&WORD_CONFIM_NODE),
    Some(&WORD_CONFIN_NODE),
    None,
    None,
    None,
    Some(&WORD_CONFIR_NODE),
    Some(&WORD_CONFIS_NODE),
    None,
    Some(&WORD_CONFIU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_CONFIU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONFIU_CHILDREN),
    value: None,
};

pub static WORD_CONFIU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("g"),
        dictgen::InsensitiveStr::Ascii("grable"),
        dictgen::InsensitiveStr::Ascii("gration"),
        dictgen::InsensitiveStr::Ascii("grations"),
        dictgen::InsensitiveStr::Ascii("gre"),
        dictgen::InsensitiveStr::Ascii("gred"),
        dictgen::InsensitiveStr::Ascii("gres"),
        dictgen::InsensitiveStr::Ascii("gring"),
        dictgen::InsensitiveStr::Ascii("gure"),
        dictgen::InsensitiveStr::Ascii("ration"),
    ],
    values: &[
        &["config"],
        &["configurable"],
        &["configuration"],
        &["configurations"],
        &["configure"],
        &["configured"],
        &["configures"],
        &["configuring"],
        &["configure"],
        &["configuration"],
    ],
    range: 1..=8,
};

static WORD_CONFIS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONFIS_CHILDREN),
    value: None,
};

pub static WORD_CONFIS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("gated"),
    ],
    values: &[&["confines"], &["confiscated"]],
    range: 1..=5,
};

static WORD_CONFIR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONFIR_CHILDREN),
    value: None,
};

pub static WORD_CONFIR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("amtion"),
        dictgen::InsensitiveStr::Ascii("macion"),
        dictgen::InsensitiveStr::Ascii("maed"),
        dictgen::InsensitiveStr::Ascii("mas"),
        dictgen::InsensitiveStr::Ascii("matino"),
        dictgen::InsensitiveStr::Ascii("matinon"),
        dictgen::InsensitiveStr::Ascii("md"),
        dictgen::InsensitiveStr::Ascii("medd"),
        dictgen::InsensitiveStr::Ascii("meed"),
        dictgen::InsensitiveStr::Ascii("mming"),
    ],
    values: &[
        &["confirmation"],
        &["confirmation"],
        &["confirmed"],
        &["confirms"],
        &["confirmation"],
        &["confirmation"],
        &["confirmed"],
        &["confirmed"],
        &["confirmed"],
        &["confirming"],
    ],
    range: 2..=7,
};

static WORD_CONFIN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONFIN_CHILDREN),
    value: None,
};

pub static WORD_CONFIN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("g"),
        dictgen::InsensitiveStr::Ascii("gs"),
        dictgen::InsensitiveStr::Ascii("s"),
    ],
    values: &[
        &["config", "confine"],
        &["configs", "confines"],
        &["confines"],
    ],
    range: 1..=2,
};

static WORD_CONFIM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONFIM_CHILDREN),
    value: Some(&["confirm"]),
};

pub static WORD_CONFIM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ation"),
        dictgen::InsensitiveStr::Ascii("ations"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("red"),
        dictgen::InsensitiveStr::Ascii("s"),
    ],
    values: &[
        &["confirmation"],
        &["confirmations"],
        &["confirmed"],
        &["confirming"],
        &["confirmed"],
        &["confirms"],
    ],
    range: 1..=6,
};

static WORD_CONFIL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONFIL_CHILDREN),
    value: None,
};

pub static WORD_CONFIL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ct"),
        dictgen::InsensitiveStr::Ascii("cting"),
        dictgen::InsensitiveStr::Ascii("cts"),
    ],
    values: &[&["conflict"], &["conflicting"], &["conflicts"]],
    range: 2..=5,
};

static WORD_CONFIG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_CONFIG_CHILDREN),
    value: None,
};

static WORD_CONFIG_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_CONFIGA_NODE),
    None,
    None,
    None,
    Some(&WORD_CONFIGE_NODE),
    None,
    None,
    None,
    Some(&WORD_CONFIGI_NODE),
    None,
    None,
    Some(&WORD_CONFIGL_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_CONFIGR_NODE),
    None,
    None,
    Some(&WORD_CONFIGU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_CONFIGU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONFIGU_CHILDREN),
    value: None,
};

pub static WORD_CONFIGU_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("aration"),
            dictgen::InsensitiveStr::Ascii("arble"),
            dictgen::InsensitiveStr::Ascii("are"),
            dictgen::InsensitiveStr::Ascii("ared"),
            dictgen::InsensitiveStr::Ascii("arion"),
            dictgen::InsensitiveStr::Ascii("arions"),
            dictgen::InsensitiveStr::Ascii("artion"),
            dictgen::InsensitiveStr::Ascii("artions"),
            dictgen::InsensitiveStr::Ascii("ation"),
            dictgen::InsensitiveStr::Ascii("ations"),
            dictgen::InsensitiveStr::Ascii("e"),
            dictgen::InsensitiveStr::Ascii("ed"),
            dictgen::InsensitiveStr::Ascii("erd"),
            dictgen::InsensitiveStr::Ascii("ered"),
            dictgen::InsensitiveStr::Ascii("es"),
            dictgen::InsensitiveStr::Ascii("late"),
            dictgen::InsensitiveStr::Ascii("lation"),
            dictgen::InsensitiveStr::Ascii("lations"),
            dictgen::InsensitiveStr::Ascii("racion"),
            dictgen::InsensitiveStr::Ascii("raion"),
            dictgen::InsensitiveStr::Ascii("raiton"),
            dictgen::InsensitiveStr::Ascii("rare"),
            dictgen::InsensitiveStr::Ascii("ratiens"),
            dictgen::InsensitiveStr::Ascii("ratin"),
            dictgen::InsensitiveStr::Ascii("ratiom"),
            dictgen::InsensitiveStr::Ascii("rationn"),
            dictgen::InsensitiveStr::Ascii("ratioon"),
            dictgen::InsensitiveStr::Ascii("rato"),
            dictgen::InsensitiveStr::Ascii("ratoin"),
            dictgen::InsensitiveStr::Ascii("ratoins"),
            dictgen::InsensitiveStr::Ascii("raton"),
            dictgen::InsensitiveStr::Ascii("ratons"),
            dictgen::InsensitiveStr::Ascii("ratrions"),
            dictgen::InsensitiveStr::Ascii("ratuion"),
            dictgen::InsensitiveStr::Ascii("reable"),
            dictgen::InsensitiveStr::Ascii("reing"),
            dictgen::InsensitiveStr::Ascii("retion"),
            dictgen::InsensitiveStr::Ascii("rres"),
            dictgen::InsensitiveStr::Ascii("rring"),
            dictgen::InsensitiveStr::Ascii("rses"),
            dictgen::InsensitiveStr::Ascii("rtation"),
            dictgen::InsensitiveStr::Ascii("rting"),
            dictgen::InsensitiveStr::Ascii("rtion"),
            dictgen::InsensitiveStr::Ascii("rtoin"),
            dictgen::InsensitiveStr::Ascii("ry"),
            dictgen::InsensitiveStr::Ascii("tation"),
            dictgen::InsensitiveStr::Ascii("tations"),
            dictgen::InsensitiveStr::Ascii("te"),
            dictgen::InsensitiveStr::Ascii("ted"),
            dictgen::InsensitiveStr::Ascii("tes"),
            dictgen::InsensitiveStr::Ascii("tration"),
        ],
        values: &[
            &["configuration"],
            &["configurable"],
            &["configure"],
            &["configured"],
            &["configuration"],
            &["configurations"],
            &["configuration"],
            &["configurations"],
            &["configuration"],
            &["configurations"],
            &["configure"],
            &["configured"],
            &["configured"],
            &["configured"],
            &["configures"],
            &["configurate"],
            &["configuration"],
            &["configurations"],
            &["configuration"],
            &["configuration"],
            &["configuration"],
            &["configure"],
            &["configurations"],
            &["configurations", "configuration", "configurating"],
            &["configuration"],
            &["configuration"],
            &["configuration"],
            &["configuration"],
            &["configurations", "configuration"],
            &["configurations"],
            &["configuration"],
            &["configurations"],
            &["configurations"],
            &["configuration"],
            &["configurable"],
            &["configuring"],
            &["configuration"],
            &["configures"],
            &["configuring"],
            &["configures"],
            &["configuration"],
            &["configuring"],
            &["configuration"],
            &["configuration"],
            &["configurable"],
            &["configuration"],
            &["configurations"],
            &["configure"],
            &["configured"],
            &["configures"],
            &["configuration"],
        ],
        range: 1..=8,
    };

static WORD_CONFIGR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONFIGR_CHILDREN),
    value: None,
};

pub static WORD_CONFIGR_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("ation"),
            dictgen::InsensitiveStr::Ascii("ations"),
            dictgen::InsensitiveStr::Ascii("e"),
            dictgen::InsensitiveStr::Ascii("ed"),
            dictgen::InsensitiveStr::Ascii("uated"),
            dictgen::InsensitiveStr::Ascii("uation"),
            dictgen::InsensitiveStr::Ascii("uations"),
            dictgen::InsensitiveStr::Ascii("ued"),
        ],
        values: &[
            &["configuration"],
            &["configurations"],
            &["configure"],
            &["configured"],
            &["configured", "configuration"],
            &["configurations", "configuration"],
            &["configurations"],
            &["configured"],
        ],
        range: 1..=7,
    };

static WORD_CONFIGL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONFIGL_CHILDREN),
    value: Some(&["config"]),
};

pub static WORD_CONFIGL_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[],
        values: &[],
        range: 0..=0,
    };

static WORD_CONFIGI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONFIGI_CHILDREN),
    value: None,
};

pub static WORD_CONFIGI_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("guration"),
            dictgen::InsensitiveStr::Ascii("ration"),
            dictgen::InsensitiveStr::Ascii("re"),
            dictgen::InsensitiveStr::Ascii("uration"),
        ],
        values: &[
            &["configuration"],
            &["configuration"],
            &["configure"],
            &["configuration"],
        ],
        range: 2..=8,
    };

static WORD_CONFIGE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONFIGE_CHILDREN),
    value: None,
};

pub static WORD_CONFIGE_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("d"),
            dictgen::InsensitiveStr::Ascii("r"),
        ],
        values: &[&["configured"], &["configure"]],
        range: 1..=1,
    };

static WORD_CONFIGA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONFIGA_CHILDREN),
    value: None,
};

pub static WORD_CONFIGA_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[dictgen::InsensitiveStr::Ascii("ration")],
        values: &[&["configuration"]],
        range: 6..=6,
    };

static WORD_CONFIF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONFIF_CHILDREN),
    value: None,
};

pub static WORD_CONFIF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("urable"),
        dictgen::InsensitiveStr::Ascii("uration"),
        dictgen::InsensitiveStr::Ascii("ure"),
        dictgen::InsensitiveStr::Ascii("ured"),
    ],
    values: &[
        &["configurable"],
        &["configuration"],
        &["configure"],
        &["configured"],
    ],
    range: 3..=7,
};

static WORD_CONFID_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONFID_CHILDREN),
    value: None,
};

pub static WORD_CONFID_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ance"),
        dictgen::InsensitiveStr::Ascii("antal"),
        dictgen::InsensitiveStr::Ascii("antally"),
        dictgen::InsensitiveStr::Ascii("antals"),
        dictgen::InsensitiveStr::Ascii("antial"),
        dictgen::InsensitiveStr::Ascii("antially"),
        dictgen::InsensitiveStr::Ascii("antly"),
        dictgen::InsensitiveStr::Ascii("encial"),
        dictgen::InsensitiveStr::Ascii("enciality"),
        dictgen::InsensitiveStr::Ascii("enly"),
        dictgen::InsensitiveStr::Ascii("ense"),
        dictgen::InsensitiveStr::Ascii("entail"),
        dictgen::InsensitiveStr::Ascii("ental"),
        dictgen::InsensitiveStr::Ascii("entally"),
        dictgen::InsensitiveStr::Ascii("entaly"),
        dictgen::InsensitiveStr::Ascii("entely"),
        dictgen::InsensitiveStr::Ascii("entiel"),
        dictgen::InsensitiveStr::Ascii("entuality"),
        dictgen::InsensitiveStr::Ascii("enty"),
        dictgen::InsensitiveStr::Ascii("eny"),
        dictgen::InsensitiveStr::Ascii("s"),
    ],
    values: &[
        &["confidence"],
        &["confidential"],
        &["confidentially"],
        &["confidentials"],
        &["confidential"],
        &["confidentially"],
        &["confidently"],
        &["confidential"],
        &["confidential"],
        &["confidently"],
        &["confidence"],
        &["confidential"],
        &["confidential"],
        &["confidentially"],
        &["confidently"],
        &["confidently"],
        &["confidential"],
        &["confidential"],
        &["confidently"],
        &["confidently"],
        &["confides"],
    ],
    range: 1..=9,
};

static WORD_CONFIC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONFIC_CHILDREN),
    value: None,
};

pub static WORD_CONFIC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("ted"),
        dictgen::InsensitiveStr::Ascii("ts"),
    ],
    values: &[&["conflict"], &["conflicted"], &["conflicts"]],
    range: 1..=3,
};

static WORD_CONFG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONFG_CHILDREN),
    value: None,
};

pub static WORD_CONFG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("iuration"),
        dictgen::InsensitiveStr::Ascii("iure"),
        dictgen::InsensitiveStr::Ascii("iured"),
        dictgen::InsensitiveStr::Ascii("uration"),
        dictgen::InsensitiveStr::Ascii("ure"),
        dictgen::InsensitiveStr::Ascii("ured"),
    ],
    values: &[
        &["configuration"],
        &["configure"],
        &["configured"],
        &["configuration"],
        &["configure"],
        &["configured"],
    ],
    range: 3..=8,
};

static WORD_CONFF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONFF_CHILDREN),
    value: None,
};

pub static WORD_CONFF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("iguration")],
    values: &[&["configuration"]],
    range: 9..=9,
};

static WORD_CONFE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONFE_CHILDREN),
    value: None,
};

pub static WORD_CONFE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("daracy"),
        dictgen::InsensitiveStr::Ascii("darate"),
        dictgen::InsensitiveStr::Ascii("darcy"),
        dictgen::InsensitiveStr::Ascii("dence"),
        dictgen::InsensitiveStr::Ascii("dential"),
        dictgen::InsensitiveStr::Ascii("derancy"),
        dictgen::InsensitiveStr::Ascii("deratie"),
        dictgen::InsensitiveStr::Ascii("dercy"),
        dictgen::InsensitiveStr::Ascii("derecy"),
        dictgen::InsensitiveStr::Ascii("rance"),
        dictgen::InsensitiveStr::Ascii("rances"),
        dictgen::InsensitiveStr::Ascii("redate"),
        dictgen::InsensitiveStr::Ascii("rene"),
        dictgen::InsensitiveStr::Ascii("renze"),
        dictgen::InsensitiveStr::Ascii("rerate"),
        dictgen::InsensitiveStr::Ascii("rmation"),
        dictgen::InsensitiveStr::Ascii("rming"),
        dictgen::InsensitiveStr::Ascii("rnece"),
        dictgen::InsensitiveStr::Ascii("rrencing"),
        dictgen::InsensitiveStr::Ascii("rsation"),
        dictgen::InsensitiveStr::Ascii("rt"),
        dictgen::InsensitiveStr::Ascii("scated"),
        dictgen::InsensitiveStr::Ascii("ses"),
        dictgen::InsensitiveStr::Ascii("sos"),
        dictgen::InsensitiveStr::Ascii("ssin"),
        dictgen::InsensitiveStr::Ascii("ssino"),
        dictgen::InsensitiveStr::Ascii("ssionis"),
        dictgen::InsensitiveStr::Ascii("sso"),
        dictgen::InsensitiveStr::Ascii("sssion"),
        dictgen::InsensitiveStr::Ascii("ty"),
    ],
    values: &[
        &["confederacy"],
        &["confederate"],
        &["confederacy"],
        &["conference"],
        &["confidential"],
        &["confederacy"],
        &["confederate"],
        &["confederacy"],
        &["confederacy"],
        &["conference"],
        &["conferences"],
        &["confederate"],
        &["conferences", "conference"],
        &["conference"],
        &["confederate"],
        &["confirmation"],
        &["confirming"],
        &["conferences"],
        &["conferencing"],
        &["conservation"],
        &["convert"],
        &["confiscated"],
        &["confess"],
        &["confess"],
        &["confession"],
        &["confessions"],
        &["confessions"],
        &["confession"],
        &["confessions"],
        &["confetti"],
    ],
    range: 2..=8,
};

static WORD_CONE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_CONE_CHILDREN),
    value: None,
};

static WORD_CONE_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    Some(&WORD_CONEC_NODE),
    None,
    Some(&WORD_CONEE_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_CONEN_NODE),
    None,
    None,
    None,
    Some(&WORD_CONER_NODE),
    Some(&WORD_CONES_NODE),
    Some(&WORD_CONET_NODE),
    None,
    None,
    None,
    Some(&WORD_CONEX_NODE),
    None,
    None,
];

static WORD_CONEX_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONEX_CHILDREN),
    value: None,
};

pub static WORD_CONEX_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ant"),
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("ts"),
    ],
    values: &[
        &["connexant"],
        &["context", "connect", "connects"],
        &["contexts", "connects"],
    ],
    range: 1..=3,
};

static WORD_CONET_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONET_CHILDREN),
    value: Some(&["connect"]),
};

pub static WORD_CONET_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("ion"),
        dictgen::InsensitiveStr::Ascii("ions"),
        dictgen::InsensitiveStr::Ascii("ivities"),
        dictgen::InsensitiveStr::Ascii("ivity"),
        dictgen::InsensitiveStr::Ascii("nt"),
        dictgen::InsensitiveStr::Ascii("or"),
        dictgen::InsensitiveStr::Ascii("ors"),
        dictgen::InsensitiveStr::Ascii("s"),
        dictgen::InsensitiveStr::Ascii("xt"),
        dictgen::InsensitiveStr::Ascii("xts"),
    ],
    values: &[
        &["connected"],
        &["connecting"],
        &["connection"],
        &["connections"],
        &["connectivities"],
        &["connectivity"],
        &["content"],
        &["connector"],
        &["connectors"],
        &["connects"],
        &["context", "connect"],
        &["contexts", "connects"],
    ],
    range: 1..=7,
};

static WORD_CONES_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONES_CHILDREN),
    value: None,
};

pub static WORD_CONES_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cutive"),
        dictgen::InsensitiveStr::Ascii("encus"),
    ],
    values: &[&["consecutive"], &["consensus"]],
    range: 5..=6,
};

static WORD_CONER_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONER_CHILDREN),
    value: Some(&["corner", "coroner"]),
};

pub static WORD_CONER_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("gence"),
        dictgen::InsensitiveStr::Ascii("n"),
        dictgen::InsensitiveStr::Ascii("ning"),
        dictgen::InsensitiveStr::Ascii("s"),
        dictgen::InsensitiveStr::Ascii("sion"),
        dictgen::InsensitiveStr::Ascii("sions"),
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("ted"),
        dictgen::InsensitiveStr::Ascii("ter"),
        dictgen::InsensitiveStr::Ascii("ters"),
        dictgen::InsensitiveStr::Ascii("ting"),
        dictgen::InsensitiveStr::Ascii("vative"),
    ],
    values: &[
        &["convergence"],
        &["concern"],
        &["concerning"],
        &["corners", "coroners"],
        &["conversion"],
        &["conversions"],
        &["convert"],
        &["converted"],
        &["converter"],
        &["converters"],
        &["converting"],
        &["conservative"],
    ],
    range: 1..=6,
};

static WORD_CONEN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONEN_CHILDREN),
    value: None,
};

pub static WORD_CONEN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ct"),
        dictgen::InsensitiveStr::Ascii("cted"),
        dictgen::InsensitiveStr::Ascii("cting"),
        dictgen::InsensitiveStr::Ascii("ction"),
        dictgen::InsensitiveStr::Ascii("ctions"),
        dictgen::InsensitiveStr::Ascii("ctivities"),
        dictgen::InsensitiveStr::Ascii("ctivity"),
        dictgen::InsensitiveStr::Ascii("ctor"),
        dictgen::InsensitiveStr::Ascii("ctors"),
        dictgen::InsensitiveStr::Ascii("ctration"),
        dictgen::InsensitiveStr::Ascii("cts"),
        dictgen::InsensitiveStr::Ascii("ience"),
        dictgen::InsensitiveStr::Ascii("ient"),
        dictgen::InsensitiveStr::Ascii("inece"),
        dictgen::InsensitiveStr::Ascii("inet"),
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("ts"),
    ],
    values: &[
        &["connect"],
        &["connected"],
        &["connecting"],
        &["connection"],
        &["connections"],
        &["connectivities"],
        &["connectivity"],
        &["connector"],
        &["connectors"],
        &["concentrations"],
        &["connects"],
        &["convenience"],
        &["convenient"],
        &["convenience"],
        &["convenient"],
        &["content"],
        &["contents"],
    ],
    range: 1..=9,
};

static WORD_CONEE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONEE_CHILDREN),
    value: None,
};

pub static WORD_CONEE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ct"),
        dictgen::InsensitiveStr::Ascii("cted"),
        dictgen::InsensitiveStr::Ascii("cting"),
        dictgen::InsensitiveStr::Ascii("ction"),
        dictgen::InsensitiveStr::Ascii("ctions"),
        dictgen::InsensitiveStr::Ascii("ctivities"),
        dictgen::InsensitiveStr::Ascii("ctivity"),
        dictgen::InsensitiveStr::Ascii("ctor"),
        dictgen::InsensitiveStr::Ascii("ctors"),
        dictgen::InsensitiveStr::Ascii("cts"),
    ],
    values: &[
        &["connect"],
        &["connected"],
        &["connecting"],
        &["connection"],
        &["connections"],
        &["connectivities"],
        &["connectivity"],
        &["connector"],
        &["connectors"],
        &["connects"],
    ],
    range: 2..=9,
};

static WORD_CONEC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONEC_CHILDREN),
    value: None,
};

pub static WORD_CONEC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ct"),
        dictgen::InsensitiveStr::Ascii("cted"),
        dictgen::InsensitiveStr::Ascii("cting"),
        dictgen::InsensitiveStr::Ascii("ction"),
        dictgen::InsensitiveStr::Ascii("ctions"),
        dictgen::InsensitiveStr::Ascii("ctivities"),
        dictgen::InsensitiveStr::Ascii("ctivity"),
        dictgen::InsensitiveStr::Ascii("ctor"),
        dictgen::InsensitiveStr::Ascii("ctors"),
        dictgen::InsensitiveStr::Ascii("cts"),
        dictgen::InsensitiveStr::Ascii("ept"),
        dictgen::InsensitiveStr::Ascii("epts"),
        dictgen::InsensitiveStr::Ascii("jture"),
        dictgen::InsensitiveStr::Ascii("jtures"),
        dictgen::InsensitiveStr::Ascii("nt"),
        dictgen::InsensitiveStr::Ascii("ntrate"),
        dictgen::InsensitiveStr::Ascii("ntrated"),
        dictgen::InsensitiveStr::Ascii("ntrates"),
        dictgen::InsensitiveStr::Ascii("ntration"),
        dictgen::InsensitiveStr::Ascii("nts"),
        dictgen::InsensitiveStr::Ascii("pt"),
        dictgen::InsensitiveStr::Ascii("pts"),
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("ted"),
        dictgen::InsensitiveStr::Ascii("ting"),
        dictgen::InsensitiveStr::Ascii("tion"),
        dictgen::InsensitiveStr::Ascii("tions"),
        dictgen::InsensitiveStr::Ascii("tivities"),
        dictgen::InsensitiveStr::Ascii("tivity"),
        dictgen::InsensitiveStr::Ascii("tix"),
        dictgen::InsensitiveStr::Ascii("tor"),
        dictgen::InsensitiveStr::Ascii("tors"),
        dictgen::InsensitiveStr::Ascii("ts"),
        dictgen::InsensitiveStr::Ascii("urrency"),
        dictgen::InsensitiveStr::Ascii("utive"),
    ],
    values: &[
        &["connect"],
        &["connected"],
        &["connecting"],
        &["connection"],
        &["connections"],
        &["connectivities"],
        &["connectivity"],
        &["connector"],
        &["connectors"],
        &["connects"],
        &["concept"],
        &["concepts"],
        &["conjecture"],
        &["conjectures"],
        &["connect", "content"],
        &["concentrate"],
        &["concentrated"],
        &["concentrates"],
        &["concentrations"],
        &["connects", "contents"],
        &["concept"],
        &["concepts"],
        &["connect"],
        &["connected"],
        &["connecting"],
        &["connection"],
        &["connections"],
        &["connectivities"],
        &["connectivity"],
        &["connectix"],
        &["connector"],
        &["connectors"],
        &["connects"],
        &["concurrency"],
        &["consecutive"],
    ],
    range: 1..=9,
};

static WORD_COND_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_COND_CHILDREN),
    value: None,
};

static WORD_COND_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_CONDA_NODE),
    None,
    None,
    None,
    Some(&WORD_CONDE_NODE),
    Some(&WORD_CONDF_NODE),
    None,
    None,
    Some(&WORD_CONDI_NODE),
    None,
    None,
    None,
    Some(&WORD_CONDM_NODE),
    Some(&WORD_CONDN_NODE),
    Some(&WORD_CONDO_NODE),
    None,
    None,
    Some(&WORD_CONDR_NODE),
    None,
    Some(&WORD_CONDT_NODE),
    Some(&WORD_CONDU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_CONDU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONDU_CHILDREN),
    value: None,
};

pub static WORD_CONDU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ctiong"),
        dictgen::InsensitiveStr::Ascii("ctuve"),
        dictgen::InsensitiveStr::Ascii("ict"),
        dictgen::InsensitiveStr::Ascii("iting"),
        dictgen::InsensitiveStr::Ascii("lences"),
    ],
    values: &[
        &["conducting"],
        &["conductive", "conducive"],
        &["conduit"],
        &["conducting"],
        &["condolences"],
    ],
    range: 3..=6,
};

static WORD_CONDT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONDT_CHILDREN),
    value: None,
};

pub static WORD_CONDT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("iion"),
        dictgen::InsensitiveStr::Ascii("iions"),
        dictgen::InsensitiveStr::Ascii("ion"),
        dictgen::InsensitiveStr::Ascii("ional"),
        dictgen::InsensitiveStr::Ascii("ionally"),
        dictgen::InsensitiveStr::Ascii("ionals"),
        dictgen::InsensitiveStr::Ascii("ioned"),
        dictgen::InsensitiveStr::Ascii("ions"),
        dictgen::InsensitiveStr::Ascii("ition"),
        dictgen::InsensitiveStr::Ascii("itional"),
        dictgen::InsensitiveStr::Ascii("itionals"),
        dictgen::InsensitiveStr::Ascii("itions"),
    ],
    values: &[
        &["condition"],
        &["conditions"],
        &["condition"],
        &["conditional"],
        &["conditionally"],
        &["conditionals"],
        &["conditioned"],
        &["conditions"],
        &["condition"],
        &["conditional"],
        &["conditionals"],
        &["conditions"],
    ],
    range: 3..=8,
};

static WORD_CONDR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONDR_CHILDREN),
    value: None,
};

pub static WORD_CONDR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("adicted"),
        dictgen::InsensitiveStr::Ascii("adicting"),
        dictgen::InsensitiveStr::Ascii("adiction"),
        dictgen::InsensitiveStr::Ascii("adictions"),
        dictgen::InsensitiveStr::Ascii("adictory"),
    ],
    values: &[
        &["contradicted"],
        &["contradicting"],
        &["contradiction"],
        &["contradictions"],
        &["contradictory"],
    ],
    range: 7..=9,
};

static WORD_CONDO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONDO_CHILDREN),
    value: None,
};

pub static WORD_CONDO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("lances"),
        dictgen::InsensitiveStr::Ascii("lencies"),
        dictgen::InsensitiveStr::Ascii("lensces"),
        dictgen::InsensitiveStr::Ascii("lenses"),
        dictgen::InsensitiveStr::Ascii("lonces"),
        dictgen::InsensitiveStr::Ascii("mes"),
        dictgen::InsensitiveStr::Ascii("mnation"),
        dictgen::InsensitiveStr::Ascii("mns"),
    ],
    values: &[
        &["condolences"],
        &["condolences"],
        &["condolences"],
        &["condolences"],
        &["condolences"],
        &["condoms"],
        &["condemnation"],
        &["condoms"],
    ],
    range: 3..=7,
};

static WORD_CONDN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONDN_CHILDREN),
    value: None,
};

pub static WORD_CONDN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("tional")],
    values: &[&["conditional"]],
    range: 6..=6,
};

static WORD_CONDM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONDM_CHILDREN),
    value: None,
};

pub static WORD_CONDM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("en"),
        dictgen::InsensitiveStr::Ascii("enation"),
        dictgen::InsensitiveStr::Ascii("ened"),
        dictgen::InsensitiveStr::Ascii("ening"),
    ],
    values: &[
        &["condemn"],
        &["condemnation"],
        &["condemned"],
        &["condemning"],
    ],
    range: 2..=7,
};

static WORD_CONDI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONDI_CHILDREN),
    value: None,
};

pub static WORD_CONDI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cional"),
        dictgen::InsensitiveStr::Ascii("ct"),
        dictgen::InsensitiveStr::Ascii("cted"),
        dictgen::InsensitiveStr::Ascii("date"),
        dictgen::InsensitiveStr::Ascii("dates"),
        dictgen::InsensitiveStr::Ascii("dent"),
        dictgen::InsensitiveStr::Ascii("dential"),
        dictgen::InsensitiveStr::Ascii("dional"),
        dictgen::InsensitiveStr::Ascii("dtion"),
        dictgen::InsensitiveStr::Ascii("dtioning"),
        dictgen::InsensitiveStr::Ascii("dtions"),
        dictgen::InsensitiveStr::Ascii("furable"),
        dictgen::InsensitiveStr::Ascii("furation"),
        dictgen::InsensitiveStr::Ascii("fure"),
        dictgen::InsensitiveStr::Ascii("fured"),
        dictgen::InsensitiveStr::Ascii("g"),
        dictgen::InsensitiveStr::Ascii("gdialog"),
        dictgen::InsensitiveStr::Ascii("iton"),
        dictgen::InsensitiveStr::Ascii("onally"),
        dictgen::InsensitiveStr::Ascii("scending"),
        dictgen::InsensitiveStr::Ascii("tial"),
        dictgen::InsensitiveStr::Ascii("tially"),
        dictgen::InsensitiveStr::Ascii("tialy"),
        dictgen::InsensitiveStr::Ascii("tianal"),
        dictgen::InsensitiveStr::Ascii("tianally"),
        dictgen::InsensitiveStr::Ascii("tianaly"),
        dictgen::InsensitiveStr::Ascii("tinal"),
        dictgen::InsensitiveStr::Ascii("tiner"),
        dictgen::InsensitiveStr::Ascii("tionaly"),
        dictgen::InsensitiveStr::Ascii("tionar"),
        dictgen::InsensitiveStr::Ascii("tiond"),
        dictgen::InsensitiveStr::Ascii("tionel"),
        dictgen::InsensitiveStr::Ascii("tiong"),
        dictgen::InsensitiveStr::Ascii("tionn"),
        dictgen::InsensitiveStr::Ascii("tionnal"),
        dictgen::InsensitiveStr::Ascii("tionnaly"),
        dictgen::InsensitiveStr::Ascii("tionned"),
        dictgen::InsensitiveStr::Ascii("tionner"),
        dictgen::InsensitiveStr::Ascii("tionning"),
        dictgen::InsensitiveStr::Ascii("toinal"),
        dictgen::InsensitiveStr::Ascii("ton"),
        dictgen::InsensitiveStr::Ascii("tonal"),
        dictgen::InsensitiveStr::Ascii("tons"),
        dictgen::InsensitiveStr::Ascii("ut"),
    ],
    values: &[
        &["conditional"],
        &["conduct"],
        &["conducted"],
        &["candidate"],
        &["candidates"],
        &["confident"],
        &["confidential"],
        &["conditional"],
        &["condition"],
        &["conditioning"],
        &["conditions"],
        &["configurable"],
        &["configuration"],
        &["configure"],
        &["configured"],
        &["config"],
        &["configdialog"],
        &["condition"],
        &["conditionally"],
        &["condescending"],
        &["conditional"],
        &["conditionally"],
        &["conditionally"],
        &["conditional"],
        &["conditionally"],
        &["conditionally"],
        &["conditional"],
        &["conditioner"],
        &["conditionally"],
        &["conditioner"],
        &["conditioned"],
        &["conditional"],
        &["conditioning"],
        &["condition"],
        &["conditional"],
        &["conditionally"],
        &["conditioned"],
        &["conditioner"],
        &["conditioning"],
        &["conditional"],
        &["condition"],
        &["conditional"],
        &["conditions"],
        &["conduit"],
    ],
    range: 1..=8,
};

static WORD_CONDF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONDF_CHILDREN),
    value: None,
};

pub static WORD_CONDF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("iguration"),
        dictgen::InsensitiveStr::Ascii("igurations"),
        dictgen::InsensitiveStr::Ascii("igure"),
        dictgen::InsensitiveStr::Ascii("igured"),
        dictgen::InsensitiveStr::Ascii("igures"),
        dictgen::InsensitiveStr::Ascii("iguring"),
    ],
    values: &[
        &["configuration"],
        &["configurations"],
        &["configure"],
        &["configured"],
        &["configures"],
        &["configuring"],
    ],
    range: 5..=10,
};

static WORD_CONDE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONDE_CHILDREN),
    value: None,
};

pub static WORD_CONDE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("feracy"),
        dictgen::InsensitiveStr::Ascii("m"),
        dictgen::InsensitiveStr::Ascii("mantion"),
        dictgen::InsensitiveStr::Ascii("mend"),
        dictgen::InsensitiveStr::Ascii("mmed"),
        dictgen::InsensitiveStr::Ascii("mming"),
        dictgen::InsensitiveStr::Ascii("mnd"),
        dictgen::InsensitiveStr::Ascii("mnig"),
        dictgen::InsensitiveStr::Ascii("ncing"),
        dictgen::InsensitiveStr::Ascii("nm"),
        dictgen::InsensitiveStr::Ascii("nmation"),
        dictgen::InsensitiveStr::Ascii("nmed"),
        dictgen::InsensitiveStr::Ascii("nming"),
        dictgen::InsensitiveStr::Ascii("nsend"),
        dictgen::InsensitiveStr::Ascii("scencion"),
        dictgen::InsensitiveStr::Ascii("scendion"),
        dictgen::InsensitiveStr::Ascii("scening"),
        dictgen::InsensitiveStr::Ascii("scenion"),
        dictgen::InsensitiveStr::Ascii("scenscion"),
        dictgen::InsensitiveStr::Ascii("scensing"),
        dictgen::InsensitiveStr::Ascii("send"),
        dictgen::InsensitiveStr::Ascii("sned"),
    ],
    values: &[
        &["confederacy"],
        &["condemn"],
        &["condemnation"],
        &["condemned"],
        &["condemned"],
        &["condemning"],
        &["condemned"],
        &["condemning"],
        &["condemning"],
        &["condemn"],
        &["condemnation"],
        &["condemned"],
        &["condemning"],
        &["condensed"],
        &["condescension"],
        &["condescension"],
        &["condescending"],
        &["condescension"],
        &["condescension"],
        &["condescension"],
        &["condensed"],
        &["condensed"],
    ],
    range: 1..=9,
};

static WORD_CONDA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONDA_CHILDREN),
    value: None,
};

pub static WORD_CONDA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("mnation"),
        dictgen::InsensitiveStr::Ascii("mned"),
        dictgen::InsensitiveStr::Ascii("mning"),
        dictgen::InsensitiveStr::Ascii("scending"),
    ],
    values: &[
        &["condemnation"],
        &["condemned"],
        &["condemning"],
        &["condescending"],
    ],
    range: 4..=8,
};

static WORD_CONC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_CONC_CHILDREN),
    value: None,
};

static WORD_CONC_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_CONCA_NODE),
    None,
    None,
    None,
    Some(&WORD_CONCE_NODE),
    None,
    None,
    Some(&WORD_CONCH_NODE),
    Some(&WORD_CONCI_NODE),
    None,
    None,
    Some(&WORD_CONCL_NODE),
    None,
    Some(&WORD_CONCN_NODE),
    Some(&WORD_CONCO_NODE),
    None,
    None,
    Some(&WORD_CONCR_NODE),
    Some(&WORD_CONCS_NODE),
    None,
    Some(&WORD_CONCU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_CONCU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONCU_CHILDREN),
    value: None,
};

pub static WORD_CONCU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("lsion"),
        dictgen::InsensitiveStr::Ascii("lsions"),
        dictgen::InsensitiveStr::Ascii("lsive"),
        dictgen::InsensitiveStr::Ascii("red"),
        dictgen::InsensitiveStr::Ascii("rence"),
        dictgen::InsensitiveStr::Ascii("rency"),
        dictgen::InsensitiveStr::Ascii("rent"),
        dictgen::InsensitiveStr::Ascii("rently"),
        dictgen::InsensitiveStr::Ascii("rents"),
        dictgen::InsensitiveStr::Ascii("rer"),
        dictgen::InsensitiveStr::Ascii("res"),
        dictgen::InsensitiveStr::Ascii("ring"),
        dictgen::InsensitiveStr::Ascii("rment"),
        dictgen::InsensitiveStr::Ascii("rrant"),
        dictgen::InsensitiveStr::Ascii("rrect"),
        dictgen::InsensitiveStr::Ascii("rrectly"),
        dictgen::InsensitiveStr::Ascii("rret"),
        dictgen::InsensitiveStr::Ascii("sions"),
        dictgen::InsensitiveStr::Ascii("sison"),
        dictgen::InsensitiveStr::Ascii("sssion"),
    ],
    values: &[
        &["conclusion"],
        &["conclusions"],
        &["conclusive"],
        &["concurred", "conquered"],
        &["concurrence"],
        &["concurrency"],
        &["concurrent"],
        &["concurrently"],
        &["concurrents", "concurrence"],
        &["conqueror"],
        &["concurs", "conquers"],
        &["concurring", "conquering"],
        &["concurrent"],
        &["concurrent"],
        &["concurrent"],
        &["concurrently"],
        &["concurrent"],
        &["concussion"],
        &["concussions"],
        &["concussions"],
    ],
    range: 3..=7,
};

static WORD_CONCS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONCS_CHILDREN),
    value: None,
};

pub static WORD_CONCS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ience"),
        dictgen::InsensitiveStr::Ascii("ious"),
        dictgen::InsensitiveStr::Ascii("iously"),
        dictgen::InsensitiveStr::Ascii("iousness"),
    ],
    values: &[
        &["conscience"],
        &["conscious"],
        &["consciously"],
        &["consciousness"],
    ],
    range: 4..=8,
};

static WORD_CONCR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONCR_CHILDREN),
    value: None,
};

pub static WORD_CONCR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eet"),
        dictgen::InsensitiveStr::Ascii("et"),
        dictgen::InsensitiveStr::Ascii("ets"),
    ],
    values: &[&["concrete"], &["concert"], &["concerts", "concrete"]],
    range: 2..=3,
};

static WORD_CONCO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONCO_CHILDREN),
    value: None,
};

pub static WORD_CONCO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("rrent")],
    values: &[&["concurrent"]],
    range: 5..=5,
};

static WORD_CONCN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONCN_CHILDREN),
    value: None,
};

pub static WORD_CONCN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("etration")],
    values: &[&["concentrations"]],
    range: 8..=8,
};

static WORD_CONCL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONCL_CHILDREN),
    value: None,
};

pub static WORD_CONCL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("suion"),
        dictgen::InsensitiveStr::Ascii("suions"),
        dictgen::InsensitiveStr::Ascii("udendo"),
        dictgen::InsensitiveStr::Ascii("ue"),
        dictgen::InsensitiveStr::Ascii("ued"),
        dictgen::InsensitiveStr::Ascii("use"),
        dictgen::InsensitiveStr::Ascii("usie"),
        dictgen::InsensitiveStr::Ascii("usies"),
        dictgen::InsensitiveStr::Ascii("usiones"),
        dictgen::InsensitiveStr::Ascii("usivley"),
        dictgen::InsensitiveStr::Ascii("uso"),
        dictgen::InsensitiveStr::Ascii("ussion"),
        dictgen::InsensitiveStr::Ascii("ussive"),
        dictgen::InsensitiveStr::Ascii("ution"),
        dictgen::InsensitiveStr::Ascii("utions"),
    ],
    values: &[
        &["concussion"],
        &["concussions"],
        &["concluded"],
        &["conclude"],
        &["conclude"],
        &["conclusive"],
        &["conclusive"],
        &["conclusive"],
        &["conclusions"],
        &["conclusive"],
        &["conclusion"],
        &["conclusions"],
        &["conclusive"],
        &["conclusion"],
        &["conclusions"],
    ],
    range: 2..=7,
};

static WORD_CONCI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONCI_CHILDREN),
    value: None,
};

pub static WORD_CONCI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("bes"),
        dictgen::InsensitiveStr::Ascii("cely"),
        dictgen::InsensitiveStr::Ascii("der"),
        dictgen::InsensitiveStr::Ascii("derable"),
        dictgen::InsensitiveStr::Ascii("derably"),
        dictgen::InsensitiveStr::Ascii("deration"),
        dictgen::InsensitiveStr::Ascii("derations"),
        dictgen::InsensitiveStr::Ascii("dered"),
        dictgen::InsensitiveStr::Ascii("dering"),
        dictgen::InsensitiveStr::Ascii("ders"),
        dictgen::InsensitiveStr::Ascii("des"),
        dictgen::InsensitiveStr::Ascii("eted"),
        dictgen::InsensitiveStr::Ascii("eve"),
        dictgen::InsensitiveStr::Ascii("eved"),
        dictgen::InsensitiveStr::Ascii("ous"),
        dictgen::InsensitiveStr::Ascii("ously"),
        dictgen::InsensitiveStr::Ascii("ousness"),
        dictgen::InsensitiveStr::Ascii("oussness"),
        dictgen::InsensitiveStr::Ascii("ssion"),
        dictgen::InsensitiveStr::Ascii("veable"),
        dictgen::InsensitiveStr::Ascii("veably"),
    ],
    values: &[
        &["concise"],
        &["concisely"],
        &["consider"],
        &["considerable"],
        &["considerably"],
        &["consideration"],
        &["considerations"],
        &["considered"],
        &["considering"],
        &["considers"],
        &["concise"],
        &["conceited"],
        &["conceive"],
        &["conceived"],
        &["conscious"],
        &["consciously"],
        &["consciousness"],
        &["consciousness"],
        &["concession"],
        &["conceivable"],
        &["conceivably"],
    ],
    range: 3..=9,
};

static WORD_CONCH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONCH_CHILDREN),
    value: None,
};

pub static WORD_CONCH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ance"),
        dictgen::InsensitiveStr::Ascii("ances"),
        dictgen::InsensitiveStr::Ascii("us"),
        dictgen::InsensitiveStr::Ascii("usally"),
        dictgen::InsensitiveStr::Ascii("usly"),
    ],
    values: &[
        &["conscience"],
        &["consciences"],
        &["conscious"],
        &["consciously"],
        &["consciously"],
    ],
    range: 2..=6,
};

static WORD_CONCE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_CONCE_CHILDREN),
    value: None,
};

static WORD_CONCE_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_CONCEA_NODE),
    None,
    None,
    Some(&WORD_CONCED_NODE),
    Some(&WORD_CONCEE_NODE),
    None,
    None,
    None,
    Some(&WORD_CONCEI_NODE),
    None,
    None,
    Some(&WORD_CONCEL_NODE),
    None,
    Some(&WORD_CONCEN_NODE),
    Some(&WORD_CONCEO_NODE),
    Some(&WORD_CONCEP_NODE),
    Some(&WORD_CONCEQ_NODE),
    Some(&WORD_CONCER_NODE),
    Some(&WORD_CONCES_NODE),
    Some(&WORD_CONCET_NODE),
    None,
    Some(&WORD_CONCEV_NODE),
    None,
    None,
    None,
    None,
];

static WORD_CONCEV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONCEV_CHILDREN),
    value: None,
};

pub static WORD_CONCEV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("iable"),
        dictgen::InsensitiveStr::Ascii("iably"),
        dictgen::InsensitiveStr::Ascii("ied"),
    ],
    values: &[
        &["concede"],
        &["conceivable"],
        &["conceivably"],
        &["conceived"],
    ],
    range: 2..=5,
};

static WORD_CONCET_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONCET_CHILDREN),
    value: None,
};

pub static WORD_CONCET_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ed")],
    values: &[&["concede"]],
    range: 2..=2,
};

static WORD_CONCES_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONCES_CHILDREN),
    value: None,
};

pub static WORD_CONCES_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ions"),
        dictgen::InsensitiveStr::Ascii("so"),
    ],
    values: &[&["concession"], &["concession"]],
    range: 2..=4,
};

static WORD_CONCER_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONCER_CHILDREN),
    value: None,
};

pub static WORD_CONCER_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("ened"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("nig"),
        dictgen::InsensitiveStr::Ascii("nt"),
        dictgen::InsensitiveStr::Ascii("ntrating"),
        dictgen::InsensitiveStr::Ascii("sation"),
        dictgen::InsensitiveStr::Ascii("sion"),
        dictgen::InsensitiveStr::Ascii("tas"),
        dictgen::InsensitiveStr::Ascii("te"),
        dictgen::InsensitiveStr::Ascii("tmate"),
        dictgen::InsensitiveStr::Ascii("vation"),
        dictgen::InsensitiveStr::Ascii("vatism"),
        dictgen::InsensitiveStr::Ascii("vative"),
        dictgen::InsensitiveStr::Ascii("vatives"),
    ],
    values: &[
        &["concede", "concerned"],
        &["concerned"],
        &["concerning"],
        &["concerning"],
        &["concert"],
        &["concentrating"],
        &["conservation"],
        &["concession", "conversion"],
        &["concerts"],
        &["concrete"],
        &["concentrate"],
        &["conservation"],
        &["conservatism"],
        &["conservative"],
        &["conservatives"],
    ],
    range: 2..=8,
};

static WORD_CONCEQ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONCEQ_CHILDREN),
    value: None,
};

pub static WORD_CONCEQ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("uence"),
        dictgen::InsensitiveStr::Ascii("uences"),
        dictgen::InsensitiveStr::Ascii("uently"),
    ],
    values: &[&["consequence"], &["consequences"], &["consequently"]],
    range: 5..=6,
};

static WORD_CONCEP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONCEP_CHILDREN),
    value: None,
};

pub static WORD_CONCEP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("s"),
        dictgen::InsensitiveStr::Ascii("ta"),
        dictgen::InsensitiveStr::Ascii("tial"),
        dictgen::InsensitiveStr::Ascii("tification"),
        dictgen::InsensitiveStr::Ascii("tos"),
        dictgen::InsensitiveStr::Ascii("tuel"),
        dictgen::InsensitiveStr::Ascii("tul"),
    ],
    values: &[
        &["concepts"],
        &["conceptual"],
        &["conceptual"],
        &["conceptualisation", "conceptualization"],
        &["concepts"],
        &["conceptual"],
        &["conceptual"],
    ],
    range: 1..=10,
};

static WORD_CONCEO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONCEO_CHILDREN),
    value: None,
};

pub static WORD_CONCEO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("us"),
        dictgen::InsensitiveStr::Ascii("usally"),
        dictgen::InsensitiveStr::Ascii("usly"),
    ],
    values: &[&["conscious"], &["consciously"], &["consciously"]],
    range: 2..=6,
};

static WORD_CONCEN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONCEN_CHILDREN),
    value: None,
};

pub static WORD_CONCEN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("crate"),
        dictgen::InsensitiveStr::Ascii("cration"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("rtation"),
        dictgen::InsensitiveStr::Ascii("sors"),
        dictgen::InsensitiveStr::Ascii("sus"),
        dictgen::InsensitiveStr::Ascii("tartion"),
        dictgen::InsensitiveStr::Ascii("tate"),
        dictgen::InsensitiveStr::Ascii("tated"),
        dictgen::InsensitiveStr::Ascii("tates"),
        dictgen::InsensitiveStr::Ascii("tating"),
        dictgen::InsensitiveStr::Ascii("tation"),
        dictgen::InsensitiveStr::Ascii("tic"),
        dictgen::InsensitiveStr::Ascii("ting"),
        dictgen::InsensitiveStr::Ascii("trace"),
        dictgen::InsensitiveStr::Ascii("tracion"),
        dictgen::InsensitiveStr::Ascii("trade"),
        dictgen::InsensitiveStr::Ascii("traded"),
        dictgen::InsensitiveStr::Ascii("traing"),
        dictgen::InsensitiveStr::Ascii("traion"),
        dictgen::InsensitiveStr::Ascii("trait"),
        dictgen::InsensitiveStr::Ascii("traited"),
        dictgen::InsensitiveStr::Ascii("traiton"),
        dictgen::InsensitiveStr::Ascii("trant"),
        dictgen::InsensitiveStr::Ascii("trare"),
        dictgen::InsensitiveStr::Ascii("trarte"),
        dictgen::InsensitiveStr::Ascii("tratie"),
        dictgen::InsensitiveStr::Ascii("tratin"),
        dictgen::InsensitiveStr::Ascii("trato"),
        dictgen::InsensitiveStr::Ascii("tratons"),
        dictgen::InsensitiveStr::Ascii("traze"),
    ],
    values: &[
        &["concentrate"],
        &["concentration"],
        &["concede"],
        &["concentrations"],
        &["consensus"],
        &["consensus"],
        &["concentrations"],
        &["concentrate"],
        &["concentrated"],
        &["concentrates"],
        &["concentrating"],
        &["concentration"],
        &["concentric"],
        &["connecting"],
        &["concentrate"],
        &["concentration"],
        &["concentrated"],
        &["concentrated"],
        &["concentrating"],
        &["concentration"],
        &["concentrate"],
        &["concentrated"],
        &["concentrations"],
        &["concentrate"],
        &["concentrate"],
        &["concentrate"],
        &["concentrate"],
        &["concentration"],
        &["concentration"],
        &["concentrations"],
        &["concentrate"],
    ],
    range: 2..=7,
};

static WORD_CONCEL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONCEL_CHILDREN),
    value: None,
};

pub static WORD_CONCEL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aed"),
        dictgen::InsensitiveStr::Ascii("aer"),
        dictgen::InsensitiveStr::Ascii("ear"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("lation"),
    ],
    values: &[
        &["concealed"],
        &["concealer"],
        &["concealer"],
        &["concede"],
        &["cancellation"],
    ],
    range: 2..=6,
};

static WORD_CONCEI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONCEI_CHILDREN),
    value: None,
};

pub static WORD_CONCEI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("de"),
        dictgen::InsensitiveStr::Ascii("tual"),
        dictgen::InsensitiveStr::Ascii("vablely"),
        dictgen::InsensitiveStr::Ascii("vabley"),
        dictgen::InsensitiveStr::Ascii("vibly"),
    ],
    values: &[
        &["conceived"],
        &["conceptual"],
        &["conceivably"],
        &["conceivably"],
        &["conceivably"],
    ],
    range: 2..=7,
};

static WORD_CONCEE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONCEE_CHILDREN),
    value: None,
};

pub static WORD_CONCEE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("d"),
        dictgen::InsensitiveStr::Ascii("dd"),
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("ted"),
    ],
    values: &[&["concede"], &["conceded"], &["conceit"], &["conceited"]],
    range: 1..=3,
};

static WORD_CONCED_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONCED_CHILDREN),
    value: None,
};

pub static WORD_CONCED_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("endo"),
        dictgen::InsensitiveStr::Ascii("ered"),
    ],
    values: &[&["conceded"], &["conceded"]],
    range: 4..=4,
};

static WORD_CONCEA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONCEA_CHILDREN),
    value: None,
};

pub static WORD_CONCEA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ld")],
    values: &[&["concealed"]],
    range: 2..=2,
};

static WORD_CONCA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONCA_CHILDREN),
    value: None,
};

pub static WORD_CONCA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("neted"),
        dictgen::InsensitiveStr::Ascii("ntenated"),
        dictgen::InsensitiveStr::Ascii("tenaded"),
        dictgen::InsensitiveStr::Ascii("tenaion"),
        dictgen::InsensitiveStr::Ascii("tened"),
        dictgen::InsensitiveStr::Ascii("tentaion"),
        dictgen::InsensitiveStr::Ascii("tentate"),
        dictgen::InsensitiveStr::Ascii("tentated"),
        dictgen::InsensitiveStr::Ascii("tentates"),
        dictgen::InsensitiveStr::Ascii("tentating"),
        dictgen::InsensitiveStr::Ascii("tentation"),
        dictgen::InsensitiveStr::Ascii("tentations"),
        dictgen::InsensitiveStr::Ascii("tented"),
        dictgen::InsensitiveStr::Ascii("tinate"),
        dictgen::InsensitiveStr::Ascii("tinated"),
        dictgen::InsensitiveStr::Ascii("tination"),
        dictgen::InsensitiveStr::Ascii("tinations"),
        dictgen::InsensitiveStr::Ascii("tincate"),
        dictgen::InsensitiveStr::Ascii("ting"),
        dictgen::InsensitiveStr::Ascii("tonate"),
        dictgen::InsensitiveStr::Ascii("tonated"),
        dictgen::InsensitiveStr::Ascii("tonates"),
        dictgen::InsensitiveStr::Ascii("tonating"),
    ],
    values: &[
        &["concatenated"],
        &["concatenated"],
        &["concatenated"],
        &["concatenation"],
        &["concatenated"],
        &["concatenation"],
        &["concatenate"],
        &["concatenated"],
        &["concatenates"],
        &["concatenating"],
        &["concatenation"],
        &["concatenations"],
        &["concatenated"],
        &["concatenate"],
        &["contaminated", "concatenated"],
        &["contamination", "concatenation"],
        &["concatenations"],
        &["concatenate"],
        &["concatenating"],
        &["concatenate"],
        &["concatenated"],
        &["concatenates"],
        &["concatenating"],
    ],
    range: 4..=10,
};

static WORD_CONB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONB_CHILDREN),
    value: None,
};

pub static WORD_CONB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ination"),
        dictgen::InsensitiveStr::Ascii("inations"),
        dictgen::InsensitiveStr::Ascii("ine"),
        dictgen::InsensitiveStr::Ascii("ined"),
        dictgen::InsensitiveStr::Ascii("trols"),
    ],
    values: &[
        &["combination"],
        &["combinations"],
        &["combine", "confine"],
        &["combined", "confined"],
        &["controls"],
    ],
    range: 3..=8,
};

static WORD_CONA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CONA_CHILDREN),
    value: None,
};

pub static WORD_CONA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("in"),
        dictgen::InsensitiveStr::Ascii("ined"),
        dictgen::InsensitiveStr::Ascii("iner"),
        dictgen::InsensitiveStr::Ascii("iners"),
        dictgen::InsensitiveStr::Ascii("ines"),
        dictgen::InsensitiveStr::Ascii("ining"),
        dictgen::InsensitiveStr::Ascii("ins"),
        dictgen::InsensitiveStr::Ascii("int"),
        dictgen::InsensitiveStr::Ascii("inted"),
        dictgen::InsensitiveStr::Ascii("inter"),
        dictgen::InsensitiveStr::Ascii("nical"),
        dictgen::InsensitiveStr::Ascii("tain"),
        dictgen::InsensitiveStr::Ascii("tainer"),
        dictgen::InsensitiveStr::Ascii("tainers"),
        dictgen::InsensitiveStr::Ascii("tains"),
        dictgen::InsensitiveStr::Ascii("tin"),
        dictgen::InsensitiveStr::Ascii("tined"),
        dictgen::InsensitiveStr::Ascii("tiner"),
        dictgen::InsensitiveStr::Ascii("tiners"),
        dictgen::InsensitiveStr::Ascii("tining"),
        dictgen::InsensitiveStr::Ascii("tins"),
    ],
    values: &[
        &["contain"],
        &["contained"],
        &["container"],
        &["containers"],
        &["contains"],
        &["containing"],
        &["contains"],
        &["contain"],
        &["contained"],
        &["container"],
        &["canonical"],
        &["contain"],
        &["container"],
        &["containers"],
        &["contains"],
        &["contain"],
        &["contained"],
        &["container"],
        &["containers"],
        &["containing"],
        &["contains"],
    ],
    range: 2..=7,
};

static WORD_COM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_COM_CHILDREN),
    value: None,
};

static WORD_COM_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_COMA_NODE),
    Some(&WORD_COMB_NODE),
    Some(&WORD_COMC_NODE),
    Some(&WORD_COMD_NODE),
    Some(&WORD_COME_NODE),
    Some(&WORD_COMF_NODE),
    None,
    None,
    Some(&WORD_COMI_NODE),
    None,
    None,
    Some(&WORD_COML_NODE),
    Some(&WORD_COMM_NODE),
    Some(&WORD_COMN_NODE),
    Some(&WORD_COMO_NODE),
    Some(&WORD_COMP_NODE),
    None,
    Some(&WORD_COMR_NODE),
    Some(&WORD_COMS_NODE),
    Some(&WORD_COMT_NODE),
    Some(&WORD_COMU_NODE),
    Some(&WORD_COMV_NODE),
    None,
    None,
    None,
    None,
];

static WORD_COMV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COMV_CHILDREN),
    value: None,
};

pub static WORD_COMV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("entions"),
        dictgen::InsensitiveStr::Ascii("erted"),
    ],
    values: &[&["conventions"], &["converted"]],
    range: 5..=7,
};

static WORD_COMU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COMU_CHILDREN),
    value: None,
};

pub static WORD_COMU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("nicate"),
        dictgen::InsensitiveStr::Ascii("nication"),
        dictgen::InsensitiveStr::Ascii("nism"),
        dictgen::InsensitiveStr::Ascii("nist"),
        dictgen::InsensitiveStr::Ascii("nists"),
        dictgen::InsensitiveStr::Ascii("nity"),
        dictgen::InsensitiveStr::Ascii("te"),
        dictgen::InsensitiveStr::Ascii("ted"),
    ],
    values: &[
        &["communicate"],
        &["communication"],
        &["communism"],
        &["communist"],
        &["communists"],
        &["community"],
        &["commute", "compute"],
        &["commuted", "computed"],
    ],
    range: 2..=8,
};

static WORD_COMT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COMT_CHILDREN),
    value: None,
};

pub static WORD_COMT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ain"),
        dictgen::InsensitiveStr::Ascii("ained"),
        dictgen::InsensitiveStr::Ascii("ainer"),
        dictgen::InsensitiveStr::Ascii("aining"),
        dictgen::InsensitiveStr::Ascii("ains"),
        dictgen::InsensitiveStr::Ascii("aminated"),
        dictgen::InsensitiveStr::Ascii("amination"),
        dictgen::InsensitiveStr::Ascii("emplating"),
        dictgen::InsensitiveStr::Ascii("emporary"),
        dictgen::InsensitiveStr::Ascii("pon"),
    ],
    values: &[
        &["contain"],
        &["contained"],
        &["container"],
        &["containing"],
        &["contains"],
        &["contaminated"],
        &["contamination"],
        &["contemplating"],
        &["contemporary"],
        &["compton"],
    ],
    range: 3..=9,
};

static WORD_COMS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COMS_CHILDREN),
    value: None,
};

pub static WORD_COMS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("etic"),
        dictgen::InsensitiveStr::Ascii("etics"),
        dictgen::InsensitiveStr::Ascii("traint"),
        dictgen::InsensitiveStr::Ascii("ume"),
        dictgen::InsensitiveStr::Ascii("umed"),
        dictgen::InsensitiveStr::Ascii("umer"),
        dictgen::InsensitiveStr::Ascii("umers"),
        dictgen::InsensitiveStr::Ascii("umes"),
        dictgen::InsensitiveStr::Ascii("uming"),
        dictgen::InsensitiveStr::Ascii("ummed"),
        dictgen::InsensitiveStr::Ascii("ummes"),
        dictgen::InsensitiveStr::Ascii("umption"),
    ],
    values: &[
        &["cosmetic"],
        &["cosmetics"],
        &["constraint"],
        &["consume"],
        &["consumed"],
        &["consumer"],
        &["consumers"],
        &["consumes"],
        &["consuming"],
        &["consumed"],
        &["consumes"],
        &["consumption"],
    ],
    range: 3..=7,
};

static WORD_COMR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COMR_CHILDREN),
    value: None,
};

pub static WORD_COMR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("adets"),
        dictgen::InsensitiveStr::Ascii("adre"),
        dictgen::InsensitiveStr::Ascii("ads"),
        dictgen::InsensitiveStr::Ascii("ess"),
        dictgen::InsensitiveStr::Ascii("essed"),
        dictgen::InsensitiveStr::Ascii("esses"),
        dictgen::InsensitiveStr::Ascii("essing"),
        dictgen::InsensitiveStr::Ascii("ession"),
        dictgen::InsensitiveStr::Ascii("pess"),
        dictgen::InsensitiveStr::Ascii("pessed"),
        dictgen::InsensitiveStr::Ascii("pesses"),
        dictgen::InsensitiveStr::Ascii("pessing"),
        dictgen::InsensitiveStr::Ascii("pession"),
        dictgen::InsensitiveStr::Ascii("pomising"),
    ],
    values: &[
        &["comrades"],
        &["comrade"],
        &["comrades"],
        &["compress"],
        &["compressed"],
        &["compresses"],
        &["compressing"],
        &["compression"],
        &["compress"],
        &["compressed"],
        &["compresses"],
        &["compressing"],
        &["compression"],
        &["compromising"],
    ],
    range: 3..=8,
};

static WORD_COMP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_COMP_CHILDREN),
    value: None,
};

static WORD_COMP_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_COMPA_NODE),
    None,
    None,
    None,
    Some(&WORD_COMPE_NODE),
    Some(&WORD_COMPF_NODE),
    None,
    Some(&WORD_COMPH_NODE),
    Some(&WORD_COMPI_NODE),
    None,
    None,
    Some(&WORD_COMPL_NODE),
    None,
    Some(&WORD_COMPN_NODE),
    Some(&WORD_COMPO_NODE),
    Some(&WORD_COMPP_NODE),
    None,
    Some(&WORD_COMPR_NODE),
    Some(&WORD_COMPS_NODE),
    Some(&WORD_COMPT_NODE),
    Some(&WORD_COMPU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_COMPU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COMPU_CHILDREN),
    value: None,
};

pub static WORD_COMPU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("atation"),
        dictgen::InsensitiveStr::Ascii("ation"),
        dictgen::InsensitiveStr::Ascii("ler"),
        dictgen::InsensitiveStr::Ascii("lers"),
        dictgen::InsensitiveStr::Ascii("lisve"),
        dictgen::InsensitiveStr::Ascii("losry"),
        dictgen::InsensitiveStr::Ascii("lsary"),
        dictgen::InsensitiveStr::Ascii("lsery"),
        dictgen::InsensitiveStr::Ascii("lsing"),
        dictgen::InsensitiveStr::Ascii("lsivley"),
        dictgen::InsensitiveStr::Ascii("lsivo"),
        dictgen::InsensitiveStr::Ascii("lsorary"),
        dictgen::InsensitiveStr::Ascii("lstion"),
        dictgen::InsensitiveStr::Ascii("lsury"),
        dictgen::InsensitiveStr::Ascii("nation"),
        dictgen::InsensitiveStr::Ascii("nd"),
        dictgen::InsensitiveStr::Ascii("nds"),
        dictgen::InsensitiveStr::Ascii("net"),
        dictgen::InsensitiveStr::Ascii("slion"),
        dictgen::InsensitiveStr::Ascii("slive"),
        dictgen::InsensitiveStr::Ascii("slory"),
        dictgen::InsensitiveStr::Ascii("stion"),
        dictgen::InsensitiveStr::Ascii("tacion"),
        dictgen::InsensitiveStr::Ascii("tacional"),
        dictgen::InsensitiveStr::Ascii("taion"),
        dictgen::InsensitiveStr::Ascii("tanti"),
        dictgen::InsensitiveStr::Ascii("tarized"),
        dictgen::InsensitiveStr::Ascii("tating"),
        dictgen::InsensitiveStr::Ascii("tationnal"),
        dictgen::InsensitiveStr::Ascii("tato"),
        dictgen::InsensitiveStr::Ascii("taton"),
        dictgen::InsensitiveStr::Ascii("tition"),
        dictgen::InsensitiveStr::Ascii("tre"),
        dictgen::InsensitiveStr::Ascii("ttaion"),
        dictgen::InsensitiveStr::Ascii("ttaions"),
    ],
    values: &[
        &["computation"],
        &["computation"],
        &["compiler", "computer"],
        &["compilers", "computers"],
        &["compulsive"],
        &["compulsory"],
        &["compulsory"],
        &["compulsory"],
        &["compulsion"],
        &["compulsive"],
        &["compulsion"],
        &["compulsory"],
        &["compulsion"],
        &["compulsory"],
        &["computation"],
        &["compound"],
        &["compounds"],
        &["compute"],
        &["compulsion"],
        &["compulsive"],
        &["compulsory"],
        &["compulsion"],
        &["computation"],
        &["computational"],
        &["computation"],
        &["computation"],
        &["computerized"],
        &["computation"],
        &["computational"],
        &["computation"],
        &["computation"],
        &["computation"],
        &["compute"],
        &["computation"],
        &["computations"],
    ],
    range: 2..=9,
};

static WORD_COMPT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COMPT_CHILDREN),
    value: None,
};

pub static WORD_COMPT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("abile"),
        dictgen::InsensitiveStr::Ascii("ability"),
        dictgen::InsensitiveStr::Ascii("eting"),
        dictgen::InsensitiveStr::Ascii("etion"),
        dictgen::InsensitiveStr::Ascii("eurs"),
        dictgen::InsensitiveStr::Ascii("ible"),
        dictgen::InsensitiveStr::Ascii("own"),
        dictgen::InsensitiveStr::Ascii("ue"),
        dictgen::InsensitiveStr::Ascii("uers"),
    ],
    values: &[
        &["compatible"],
        &["compatibility", "computability"],
        &["completing"],
        &["completion"],
        &["computers"],
        &["compatible"],
        &["compton"],
        &["compute"],
        &["computers"],
    ],
    range: 2..=7,
};

static WORD_COMPS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COMPS_CHILDREN),
    value: None,
};

pub static WORD_COMPS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("able"),
        dictgen::InsensitiveStr::Ascii("ers"),
        dictgen::InsensitiveStr::Ascii("ite"),
    ],
    values: &[&["composable"], &["compress"], &["composite"]],
    range: 3..=4,
};

static WORD_COMPR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COMPR_CHILDREN),
    value: None,
};

pub static WORD_COMPR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("able"),
        dictgen::InsensitiveStr::Ascii("aison"),
        dictgen::InsensitiveStr::Ascii("amise"),
        dictgen::InsensitiveStr::Ascii("amised"),
        dictgen::InsensitiveStr::Ascii("amises"),
        dictgen::InsensitiveStr::Ascii("amising"),
        dictgen::InsensitiveStr::Ascii("assem"),
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("edded"),
        dictgen::InsensitiveStr::Ascii("ehand"),
        dictgen::InsensitiveStr::Ascii("ehention"),
        dictgen::InsensitiveStr::Ascii("emised"),
        dictgen::InsensitiveStr::Ascii("emises"),
        dictgen::InsensitiveStr::Ascii("emising"),
        dictgen::InsensitiveStr::Ascii("ension"),
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("esas"),
        dictgen::InsensitiveStr::Ascii("ese"),
        dictgen::InsensitiveStr::Ascii("esed"),
        dictgen::InsensitiveStr::Ascii("eser"),
        dictgen::InsensitiveStr::Ascii("esers"),
        dictgen::InsensitiveStr::Ascii("eses"),
        dictgen::InsensitiveStr::Ascii("esible"),
        dictgen::InsensitiveStr::Ascii("esing"),
        dictgen::InsensitiveStr::Ascii("esion"),
        dictgen::InsensitiveStr::Ascii("esions"),
        dictgen::InsensitiveStr::Ascii("eso"),
        dictgen::InsensitiveStr::Ascii("esor"),
        dictgen::InsensitiveStr::Ascii("esores"),
        dictgen::InsensitiveStr::Ascii("esors"),
        dictgen::InsensitiveStr::Ascii("essable"),
        dictgen::InsensitiveStr::Ascii("esser"),
        dictgen::InsensitiveStr::Ascii("essers"),
        dictgen::InsensitiveStr::Ascii("essio"),
        dictgen::InsensitiveStr::Ascii("esson"),
        dictgen::InsensitiveStr::Ascii("esss"),
        dictgen::InsensitiveStr::Ascii("esssed"),
        dictgen::InsensitiveStr::Ascii("esssion"),
        dictgen::InsensitiveStr::Ascii("esssor"),
        dictgen::InsensitiveStr::Ascii("ihend"),
        dictgen::InsensitiveStr::Ascii("imise"),
        dictgen::InsensitiveStr::Ascii("imised"),
        dictgen::InsensitiveStr::Ascii("imises"),
        dictgen::InsensitiveStr::Ascii("omessi"),
        dictgen::InsensitiveStr::Ascii("omisng"),
        dictgen::InsensitiveStr::Ascii("omiss"),
        dictgen::InsensitiveStr::Ascii("omisse"),
        dictgen::InsensitiveStr::Ascii("omissen"),
        dictgen::InsensitiveStr::Ascii("omisses"),
        dictgen::InsensitiveStr::Ascii("omisso"),
        dictgen::InsensitiveStr::Ascii("omize"),
        dictgen::InsensitiveStr::Ascii("omized"),
        dictgen::InsensitiveStr::Ascii("omizing"),
        dictgen::InsensitiveStr::Ascii("omosing"),
        dictgen::InsensitiveStr::Ascii("omsie"),
        dictgen::InsensitiveStr::Ascii("ossor"),
    ],
    values: &[
        &["comparable"],
        &["comparisons"],
        &["compromise"],
        &["compromised"],
        &["compromises"],
        &["compromising"],
        &["compress"],
        &["compare", "compère"],
        &["compressed"],
        &["comprehend"],
        &["comprehension"],
        &["compromised"],
        &["compromises"],
        &["compromising"],
        &["compression"],
        &["compress", "compares"],
        &["compress"],
        &["compressed"],
        &["compressed"],
        &["compressor"],
        &["compressors"],
        &["compress", "compresses"],
        &["compressible"],
        &["compressing"],
        &["compression"],
        &["compressions"],
        &["compressor"],
        &["compressor"],
        &["compressor"],
        &["compressor", "compressors"],
        &["compressible"],
        &["compressor"],
        &["compressors"],
        &["compressor"],
        &["compression"],
        &["compress"],
        &["compressed"],
        &["compression"],
        &["compressor"],
        &["comprehend"],
        &["compromise"],
        &["compromised"],
        &["compromises"],
        &["compromises"],
        &["compromising"],
        &["compromises"],
        &["compromises"],
        &["compromise"],
        &["compromises"],
        &["compromises"],
        &["compromise"],
        &["compromised"],
        &["compromising"],
        &["compromising"],
        &["compromises"],
        &["compressor"],
    ],
    range: 1..=8,
};

static WORD_COMPP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COMPP_CHILDREN),
    value: None,
};

pub static WORD_COMPP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("atible"),
        dictgen::InsensitiveStr::Ascii("iler"),
        dictgen::InsensitiveStr::Ascii("ilers"),
        dictgen::InsensitiveStr::Ascii("liance"),
    ],
    values: &[
        &["compatible"],
        &["compiler"],
        &["compilers"],
        &["compliance"],
    ],
    range: 4..=6,
};

static WORD_COMPO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COMPO_CHILDREN),
    value: None,
};

pub static WORD_COMPO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ennt"),
        dictgen::InsensitiveStr::Ascii("ent"),
        dictgen::InsensitiveStr::Ascii("ents"),
        dictgen::InsensitiveStr::Ascii("esd"),
        dictgen::InsensitiveStr::Ascii("lation"),
        dictgen::InsensitiveStr::Ascii("lsive"),
        dictgen::InsensitiveStr::Ascii("lsory"),
        dictgen::InsensitiveStr::Ascii("lsury"),
        dictgen::InsensitiveStr::Ascii("ment"),
        dictgen::InsensitiveStr::Ascii("ments"),
        dictgen::InsensitiveStr::Ascii("nant"),
        dictgen::InsensitiveStr::Ascii("nants"),
        dictgen::InsensitiveStr::Ascii("nbents"),
        dictgen::InsensitiveStr::Ascii("nding"),
        dictgen::InsensitiveStr::Ascii("neent"),
        dictgen::InsensitiveStr::Ascii("neents"),
        dictgen::InsensitiveStr::Ascii("nemt"),
        dictgen::InsensitiveStr::Ascii("nemts"),
        dictgen::InsensitiveStr::Ascii("nenent"),
        dictgen::InsensitiveStr::Ascii("nenents"),
        dictgen::InsensitiveStr::Ascii("nenet"),
        dictgen::InsensitiveStr::Ascii("nenete"),
        dictgen::InsensitiveStr::Ascii("nenets"),
        dictgen::InsensitiveStr::Ascii("nens"),
        dictgen::InsensitiveStr::Ascii("nentes"),
        dictgen::InsensitiveStr::Ascii("nes"),
        dictgen::InsensitiveStr::Ascii("net"),
        dictgen::InsensitiveStr::Ascii("nets"),
        dictgen::InsensitiveStr::Ascii("nnents"),
        dictgen::InsensitiveStr::Ascii("nnet"),
        dictgen::InsensitiveStr::Ascii("noent"),
        dictgen::InsensitiveStr::Ascii("noents"),
        dictgen::InsensitiveStr::Ascii("nsate"),
        dictgen::InsensitiveStr::Ascii("nsites"),
        dictgen::InsensitiveStr::Ascii("ntent"),
        dictgen::InsensitiveStr::Ascii("ntents"),
        dictgen::InsensitiveStr::Ascii("nts"),
        dictgen::InsensitiveStr::Ascii("rable"),
        dictgen::InsensitiveStr::Ascii("sablity"),
        dictgen::InsensitiveStr::Ascii("set"),
        dictgen::InsensitiveStr::Ascii("sibility"),
        dictgen::InsensitiveStr::Ascii("siblity"),
        dictgen::InsensitiveStr::Ascii("sicion"),
        dictgen::InsensitiveStr::Ascii("siiton"),
        dictgen::InsensitiveStr::Ascii("sision"),
        dictgen::InsensitiveStr::Ascii("sistion"),
        dictgen::InsensitiveStr::Ascii("sit"),
        dictgen::InsensitiveStr::Ascii("sitie"),
        dictgen::InsensitiveStr::Ascii("sitied"),
        dictgen::InsensitiveStr::Ascii("sities"),
        dictgen::InsensitiveStr::Ascii("sitionwise"),
        dictgen::InsensitiveStr::Ascii("sitoin"),
        dictgen::InsensitiveStr::Ascii("siton"),
        dictgen::InsensitiveStr::Ascii("sitong"),
        dictgen::InsensitiveStr::Ascii("sitons"),
        dictgen::InsensitiveStr::Ascii("sitore"),
        dictgen::InsensitiveStr::Ascii("sits"),
        dictgen::InsensitiveStr::Ascii("ste"),
        dictgen::InsensitiveStr::Ascii("stiion"),
        dictgen::InsensitiveStr::Ascii("tition"),
        dictgen::InsensitiveStr::Ascii("ts"),
        dictgen::InsensitiveStr::Ascii("unt"),
    ],
    values: &[
        &["component"],
        &["component"],
        &["components"],
        &["composed"],
        &["compilation"],
        &["compulsive"],
        &["compulsory"],
        &["compulsory"],
        &["component"],
        &["components"],
        &["component"],
        &["components"],
        &["components"],
        &["compounding"],
        &["component"],
        &["components"],
        &["component"],
        &["components"],
        &["component"],
        &["components"],
        &["components", "component"],
        &["component", "components"],
        &["components"],
        &["components"],
        &["components"],
        &["compose"],
        &["components", "component"],
        &["components"],
        &["components"],
        &["component"],
        &["component"],
        &["components"],
        &["compensate"],
        &["composites"],
        &["component"],
        &["components"],
        &["compost"],
        &["comparable"],
        &["composability"],
        &["compost"],
        &["composability"],
        &["composability"],
        &["composition"],
        &["compositions"],
        &["compositions"],
        &["compositions"],
        &["compost", "composite"],
        &["composite"],
        &["composite"],
        &["composite"],
        &["compositions"],
        &["compositions"],
        &["composition"],
        &["compositing"],
        &["compositions"],
        &["composite"],
        &["composites"],
        &["compose", "composed", "composite", "compost", "composted"],
        &["compositions"],
        &["composition"],
        &["compost"],
        &["compound"],
    ],
    range: 2..=10,
};

static WORD_COMPN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COMPN_CHILDREN),
    value: None,
};

pub static WORD_COMPN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ay"),
        dictgen::InsensitiveStr::Ascii("ent"),
        dictgen::InsensitiveStr::Ascii("ents"),
    ],
    values: &[&["company"], &["component"], &["components"]],
    range: 2..=4,
};

static WORD_COMPL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_COMPL_CHILDREN),
    value: None,
};

static WORD_COMPL_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_COMPLA_NODE),
    None,
    Some(&WORD_COMPLC_NODE),
    None,
    Some(&WORD_COMPLE_NODE),
    None,
    None,
    None,
    Some(&WORD_COMPLI_NODE),
    None,
    None,
    None,
    Some(&WORD_COMPLM_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_COMPLT_NODE),
    Some(&WORD_COMPLU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_COMPLU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COMPLU_CHILDREN),
    value: None,
};

pub static WORD_COMPLU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("sion"),
        dictgen::InsensitiveStr::Ascii("sions"),
        dictgen::InsensitiveStr::Ascii("sive"),
        dictgen::InsensitiveStr::Ascii("sory"),
        dictgen::InsensitiveStr::Ascii("ter"),
    ],
    values: &[
        &["compulsion"],
        &["compulsion"],
        &["compulsive"],
        &["compulsory"],
        &["computer"],
    ],
    range: 3..=5,
};

static WORD_COMPLT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COMPLT_CHILDREN),
    value: None,
};

pub static WORD_COMPLT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ed")],
    values: &[&["completed"]],
    range: 2..=2,
};

static WORD_COMPLM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COMPLM_CHILDREN),
    value: None,
};

pub static WORD_COMPLM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("enet")],
    values: &[&["complement"]],
    range: 4..=4,
};

static WORD_COMPLI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COMPLI_CHILDREN),
    value: None,
};

pub static WORD_COMPLI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ace"),
        dictgen::InsensitiveStr::Ascii("acted"),
        dictgen::InsensitiveStr::Ascii("actions"),
        dictgen::InsensitiveStr::Ascii("ancy"),
        dictgen::InsensitiveStr::Ascii("aned"),
        dictgen::InsensitiveStr::Ascii("ans"),
        dictgen::InsensitiveStr::Ascii("anse"),
        dictgen::InsensitiveStr::Ascii("ants"),
        dictgen::InsensitiveStr::Ascii("ation"),
        dictgen::InsensitiveStr::Ascii("ations"),
        dictgen::InsensitiveStr::Ascii("cacion"),
        dictgen::InsensitiveStr::Ascii("caed"),
        dictgen::InsensitiveStr::Ascii("caitons"),
        dictgen::InsensitiveStr::Ascii("care"),
        dictgen::InsensitiveStr::Ascii("carte"),
        dictgen::InsensitiveStr::Ascii("cati"),
        dictgen::InsensitiveStr::Ascii("catie"),
        dictgen::InsensitiveStr::Ascii("catied"),
        dictgen::InsensitiveStr::Ascii("caties"),
        dictgen::InsensitiveStr::Ascii("catii"),
        dictgen::InsensitiveStr::Ascii("catin"),
        dictgen::InsensitiveStr::Ascii("cato"),
        dictgen::InsensitiveStr::Ascii("catred"),
        dictgen::InsensitiveStr::Ascii("catted"),
        dictgen::InsensitiveStr::Ascii("cite"),
        dictgen::InsensitiveStr::Ascii("ct"),
        dictgen::InsensitiveStr::Ascii("ctaed"),
        dictgen::InsensitiveStr::Ascii("cted"),
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("ence"),
        dictgen::InsensitiveStr::Ascii("ent"),
        dictgen::InsensitiveStr::Ascii("er"),
        dictgen::InsensitiveStr::Ascii("ers"),
        dictgen::InsensitiveStr::Ascii("lation"),
        dictgen::InsensitiveStr::Ascii("lations"),
        dictgen::InsensitiveStr::Ascii("le"),
        dictgen::InsensitiveStr::Ascii("led"),
        dictgen::InsensitiveStr::Ascii("ler"),
        dictgen::InsensitiveStr::Ascii("les"),
        dictgen::InsensitiveStr::Ascii("ling"),
        dictgen::InsensitiveStr::Ascii("mate"),
        dictgen::InsensitiveStr::Ascii("mation"),
        dictgen::InsensitiveStr::Ascii("menary"),
        dictgen::InsensitiveStr::Ascii("mentarity"),
        dictgen::InsensitiveStr::Ascii("mente"),
        dictgen::InsensitiveStr::Ascii("mentery"),
        dictgen::InsensitiveStr::Ascii("mentje"),
        dictgen::InsensitiveStr::Ascii("mentoni"),
        dictgen::InsensitiveStr::Ascii("mentory"),
        dictgen::InsensitiveStr::Ascii("mentry"),
        dictgen::InsensitiveStr::Ascii("menty"),
        dictgen::InsensitiveStr::Ascii("nation"),
        dictgen::InsensitiveStr::Ascii("ng"),
        dictgen::InsensitiveStr::Ascii("tation"),
        dictgen::InsensitiveStr::Ascii("tations"),
        dictgen::InsensitiveStr::Ascii("tely"),
        dictgen::InsensitiveStr::Ascii("tion"),
    ],
    values: &[
        &["compliance"],
        &["complicate"],
        &["complication"],
        &["compliance"],
        &["compliance"],
        &["complains"],
        &["compliance"],
        &["complaints"],
        &["compilation"],
        &["compilation", "compilations"],
        &["complication"],
        &["complicate"],
        &["complication"],
        &["complicate"],
        &["complicate"],
        &["complicit"],
        &["complicit"],
        &["complicate"],
        &["complicate"],
        &["complicit"],
        &["complicit"],
        &["complication"],
        &["complicate"],
        &["complicate"],
        &["complicate"],
        &["complicit"],
        &["complicate"],
        &["complicated"],
        &["compile", "complice", "complied"],
        &["compliance"],
        &["compliant"],
        &["compiler"],
        &["compilers"],
        &["complication"],
        &["complications"],
        &["compile"],
        &["compiled"],
        &["compiler"],
        &["compiles"],
        &["compiling"],
        &["complicate"],
        &["complication"],
        &["complimentary"],
        &["complimentary"],
        &["complement"],
        &["complimentary"],
        &["complimented"],
        &["complimenting"],
        &["complimentary"],
        &["complimentary"],
        &["complimentary"],
        &["complication"],
        &["compiling"],
        &["complication", "compilation"],
        &["compilations", "complications"],
        &["completely"],
        &["completion"],
    ],
    range: 1..=9,
};

static WORD_COMPLE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COMPLE_CHILDREN),
    value: None,
};

pub static WORD_COMPLE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ate"),
        dictgen::InsensitiveStr::Ascii("ated"),
        dictgen::InsensitiveStr::Ascii("ates"),
        dictgen::InsensitiveStr::Ascii("ating"),
        dictgen::InsensitiveStr::Ascii("ation"),
        dictgen::InsensitiveStr::Ascii("atly"),
        dictgen::InsensitiveStr::Ascii("cate"),
        dictgen::InsensitiveStr::Ascii("cated"),
        dictgen::InsensitiveStr::Ascii("cations"),
        dictgen::InsensitiveStr::Ascii("ction"),
        dictgen::InsensitiveStr::Ascii("ctions"),
        dictgen::InsensitiveStr::Ascii("et"),
        dictgen::InsensitiveStr::Ascii("ete"),
        dictgen::InsensitiveStr::Ascii("eted"),
        dictgen::InsensitiveStr::Ascii("etly"),
        dictgen::InsensitiveStr::Ascii("etness"),
        dictgen::InsensitiveStr::Ascii("lely"),
        dictgen::InsensitiveStr::Ascii("lte"),
        dictgen::InsensitiveStr::Ascii("mentt"),
        dictgen::InsensitiveStr::Ascii("ness"),
        dictgen::InsensitiveStr::Ascii("ssion"),
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("talbe"),
        dictgen::InsensitiveStr::Ascii("taste"),
        dictgen::InsensitiveStr::Ascii("td"),
        dictgen::InsensitiveStr::Ascii("teds"),
        dictgen::InsensitiveStr::Ascii("teing"),
        dictgen::InsensitiveStr::Ascii("teion"),
        dictgen::InsensitiveStr::Ascii("telly"),
        dictgen::InsensitiveStr::Ascii("telty"),
        dictgen::InsensitiveStr::Ascii("telyl"),
        dictgen::InsensitiveStr::Ascii("telys"),
        dictgen::InsensitiveStr::Ascii("ten"),
        dictgen::InsensitiveStr::Ascii("tenes"),
        dictgen::InsensitiveStr::Ascii("tent"),
        dictgen::InsensitiveStr::Ascii("tess"),
        dictgen::InsensitiveStr::Ascii("tetion"),
        dictgen::InsensitiveStr::Ascii("tetly"),
        dictgen::InsensitiveStr::Ascii("tey"),
        dictgen::InsensitiveStr::Ascii("ti"),
        dictgen::InsensitiveStr::Ascii("tily"),
        dictgen::InsensitiveStr::Ascii("tin"),
        dictgen::InsensitiveStr::Ascii("tiom"),
        dictgen::InsensitiveStr::Ascii("tition"),
        dictgen::InsensitiveStr::Ascii("tito"),
        dictgen::InsensitiveStr::Ascii("tley"),
        dictgen::InsensitiveStr::Ascii("tly"),
        dictgen::InsensitiveStr::Ascii("tness"),
        dictgen::InsensitiveStr::Ascii("tor"),
        dictgen::InsensitiveStr::Ascii("ts"),
        dictgen::InsensitiveStr::Ascii("tte"),
        dictgen::InsensitiveStr::Ascii("ttly"),
        dictgen::InsensitiveStr::Ascii("ty"),
        dictgen::InsensitiveStr::Ascii("xers"),
        dictgen::InsensitiveStr::Ascii("xety"),
        dictgen::InsensitiveStr::Ascii("xitiy"),
        dictgen::InsensitiveStr::Ascii("xs"),
        dictgen::InsensitiveStr::Ascii("xt"),
        dictgen::InsensitiveStr::Ascii("xtion"),
        dictgen::InsensitiveStr::Ascii("xtions"),
        dictgen::InsensitiveStr::Ascii("xy"),
    ],
    values: &[
        &["complete"],
        &["completed"],
        &["completes"],
        &["completing"],
        &["compilation", "completion"],
        &["completely"],
        &["complicate"],
        &["complicated"],
        &["complications"],
        &["completion"],
        &["completions"],
        &["complete"],
        &["complete"],
        &["completed"],
        &["completely"],
        &["completeness"],
        &["completely"],
        &["complete"],
        &["complement"],
        &["completeness"],
        &["compression"],
        &["complete"],
        &["completable"],
        &["completes"],
        &["complete", "completed"],
        &["completes"],
        &["completing"],
        &["completion"],
        &["completely"],
        &["completely"],
        &["completely"],
        &["completes"],
        &["complement"],
        &["completes"],
        &["complement"],
        &["completeness", "completes"],
        &["completion"],
        &["completely"],
        &["completely"],
        &["complexity"],
        &["complexity"],
        &["completion"],
        &["completion"],
        &["completion"],
        &["completion"],
        &["completely"],
        &["completely"],
        &["completeness"],
        &["completer", "completion"],
        &["completes"],
        &["complete"],
        &["completely"],
        &["completely"],
        &["complexes"],
        &["complexity"],
        &["complexity"],
        &["complexes"],
        &["complexity"],
        &["complexion"],
        &["complexions"],
        &["complexity"],
    ],
    range: 1..=7,
};

static WORD_COMPLC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COMPLC_CHILDREN),
    value: None,
};

pub static WORD_COMPLC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ated"),
        dictgen::InsensitiveStr::Ascii("iated"),
        dictgen::InsensitiveStr::Ascii("iations"),
    ],
    values: &[&["complicated"], &["complicate"], &["complication"]],
    range: 4..=7,
};

static WORD_COMPLA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COMPLA_CHILDREN),
    value: None,
};

pub static WORD_COMPLA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cant"),
        dictgen::InsensitiveStr::Ascii("cient"),
        dictgen::InsensitiveStr::Ascii("ince"),
        dictgen::InsensitiveStr::Ascii("ind"),
        dictgen::InsensitiveStr::Ascii("ines"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("inging"),
        dictgen::InsensitiveStr::Ascii("inig"),
        dictgen::InsensitiveStr::Ascii("inte"),
        dictgen::InsensitiveStr::Ascii("is"),
        dictgen::InsensitiveStr::Ascii("ne"),
        dictgen::InsensitiveStr::Ascii("nied"),
        dictgen::InsensitiveStr::Ascii("te"),
        dictgen::InsensitiveStr::Ascii("ted"),
        dictgen::InsensitiveStr::Ascii("tes"),
        dictgen::InsensitiveStr::Ascii("ting"),
        dictgen::InsensitiveStr::Ascii("tion"),
        dictgen::InsensitiveStr::Ascii("tly"),
        dictgen::InsensitiveStr::Ascii("tness"),
        dictgen::InsensitiveStr::Ascii("ts"),
    ],
    values: &[
        &["complacent"],
        &["complacent"],
        &["compliance"],
        &["complained"],
        &["complaints"],
        &["complaining"],
        &["complaining"],
        &["complaining"],
        &["complained"],
        &["complains"],
        &["complacent"],
        &["complained"],
        &["complacent", "complete"],
        &["completed"],
        &["completes"],
        &["completing"],
        &["completion", "compilation"],
        &["completely"],
        &["completeness"],
        &["completes"],
    ],
    range: 2..=6,
};

static WORD_COMPI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COMPI_CHILDREN),
    value: None,
};

pub static WORD_COMPI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ant"),
        dictgen::InsensitiveStr::Ascii("cated"),
        dictgen::InsensitiveStr::Ascii("cations"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("eler"),
        dictgen::InsensitiveStr::Ascii("elers"),
        dictgen::InsensitiveStr::Ascii("lability"),
        dictgen::InsensitiveStr::Ascii("lacion"),
        dictgen::InsensitiveStr::Ascii("laiton"),
        dictgen::InsensitiveStr::Ascii("laitons"),
        dictgen::InsensitiveStr::Ascii("lance"),
        dictgen::InsensitiveStr::Ascii("lant"),
        dictgen::InsensitiveStr::Ascii("lare"),
        dictgen::InsensitiveStr::Ascii("lato"),
        dictgen::InsensitiveStr::Ascii("laton"),
        dictgen::InsensitiveStr::Ascii("latons"),
        dictgen::InsensitiveStr::Ascii("lcate"),
        dictgen::InsensitiveStr::Ascii("lcated"),
        dictgen::InsensitiveStr::Ascii("lcatedly"),
        dictgen::InsensitiveStr::Ascii("lcates"),
        dictgen::InsensitiveStr::Ascii("lcating"),
        dictgen::InsensitiveStr::Ascii("lcation"),
        dictgen::InsensitiveStr::Ascii("lcations"),
        dictgen::InsensitiveStr::Ascii("leable"),
        dictgen::InsensitiveStr::Ascii("lger"),
        dictgen::InsensitiveStr::Ascii("lgers"),
        dictgen::InsensitiveStr::Ascii("liant"),
        dictgen::InsensitiveStr::Ascii("liation"),
        dictgen::InsensitiveStr::Ascii("licated"),
        dictgen::InsensitiveStr::Ascii("lication"),
        dictgen::InsensitiveStr::Ascii("lier"),
        dictgen::InsensitiveStr::Ascii("liers"),
        dictgen::InsensitiveStr::Ascii("ller"),
        dictgen::InsensitiveStr::Ascii("llers"),
        dictgen::InsensitiveStr::Ascii("lr"),
        dictgen::InsensitiveStr::Ascii("lter"),
        dictgen::InsensitiveStr::Ascii("lters"),
        dictgen::InsensitiveStr::Ascii("nation"),
        dictgen::InsensitiveStr::Ascii("nsate"),
        dictgen::InsensitiveStr::Ascii("nsated"),
        dictgen::InsensitiveStr::Ascii("nsating"),
        dictgen::InsensitiveStr::Ascii("nsation"),
        dictgen::InsensitiveStr::Ascii("tability"),
        dictgen::InsensitiveStr::Ascii("table"),
        dictgen::InsensitiveStr::Ascii("tance"),
        dictgen::InsensitiveStr::Ascii("tation"),
        dictgen::InsensitiveStr::Ascii("tent"),
        dictgen::InsensitiveStr::Ascii("tetion"),
        dictgen::InsensitiveStr::Ascii("tible"),
    ],
    values: &[
        &["compliant"],
        &["complicated"],
        &["complications"],
        &["compiled"],
        &["compiler"],
        &["compilers"],
        &["compatibility"],
        &["compilation"],
        &["compilation"],
        &["compilations"],
        &["compliance"],
        &["compliant"],
        &["compiler"],
        &["compilation"],
        &["compilation"],
        &["compilations"],
        &["complicate"],
        &["complicate", "complicated"],
        &["complicatedly"],
        &["complicates"],
        &["complicating"],
        &["complication"],
        &["complication", "complications"],
        &["compilable"],
        &["compiler"],
        &["compilers"],
        &["compliant"],
        &["compilation"],
        &["complicated"],
        &["complication"],
        &["compiler"],
        &["compilers"],
        &["compiler"],
        &["compilers"],
        &["compiler"],
        &["compiler"],
        &["compilers"],
        &["compilation", "combination"],
        &["compensate"],
        &["compensated"],
        &["compensating"],
        &["compensation"],
        &["compatibility"],
        &["compatible"],
        &["compliance"],
        &["computation"],
        &["competent"],
        &["competitions"],
        &["compatible"],
    ],
    range: 2..=8,
};

static WORD_COMPH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COMPH_CHILDREN),
    value: None,
};

pub static WORD_COMPH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("rehensive")],
    values: &[&["comprehensive"]],
    range: 9..=9,
};

static WORD_COMPF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COMPF_CHILDREN),
    value: None,
};

pub static WORD_COMPF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ortable")],
    values: &[&["comfortable"]],
    range: 7..=7,
};

static WORD_COMPE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_COMPE_CHILDREN),
    value: None,
};

static WORD_COMPE_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_COMPEA_NODE),
    None,
    None,
    Some(&WORD_COMPED_NODE),
    Some(&WORD_COMPEE_NODE),
    None,
    None,
    None,
    Some(&WORD_COMPEI_NODE),
    None,
    None,
    Some(&WORD_COMPEL_NODE),
    Some(&WORD_COMPEM_NODE),
    Some(&WORD_COMPEN_NODE),
    None,
    None,
    None,
    Some(&WORD_COMPER_NODE),
    Some(&WORD_COMPES_NODE),
    Some(&WORD_COMPET_NODE),
    None,
    None,
    None,
    Some(&WORD_COMPEX_NODE),
    None,
    None,
];

static WORD_COMPEX_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COMPEX_CHILDREN),
    value: Some(&["complex"]),
};

pub static WORD_COMPEX_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[],
    values: &[],
    range: 0..=0,
};

static WORD_COMPET_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COMPET_CHILDREN),
    value: None,
};

pub static WORD_COMPET_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ance"),
        dictgen::InsensitiveStr::Ascii("ant"),
        dictgen::InsensitiveStr::Ascii("ation"),
        dictgen::InsensitiveStr::Ascii("ative"),
        dictgen::InsensitiveStr::Ascii("atively"),
        dictgen::InsensitiveStr::Ascii("ator"),
        dictgen::InsensitiveStr::Ascii("ators"),
        dictgen::InsensitiveStr::Ascii("ely"),
        dictgen::InsensitiveStr::Ascii("end"),
        dictgen::InsensitiveStr::Ascii("enet"),
        dictgen::InsensitiveStr::Ascii("ense"),
        dictgen::InsensitiveStr::Ascii("enze"),
        dictgen::InsensitiveStr::Ascii("eted"),
        dictgen::InsensitiveStr::Ascii("etion"),
        dictgen::InsensitiveStr::Ascii("etions"),
        dictgen::InsensitiveStr::Ascii("etive"),
        dictgen::InsensitiveStr::Ascii("etor"),
        dictgen::InsensitiveStr::Ascii("etors"),
        dictgen::InsensitiveStr::Ascii("idor"),
        dictgen::InsensitiveStr::Ascii("ion"),
        dictgen::InsensitiveStr::Ascii("ions"),
        dictgen::InsensitiveStr::Ascii("iors"),
        dictgen::InsensitiveStr::Ascii("itavely"),
        dictgen::InsensitiveStr::Ascii("iters"),
        dictgen::InsensitiveStr::Ascii("itevely"),
        dictgen::InsensitiveStr::Ascii("itevly"),
        dictgen::InsensitiveStr::Ascii("itie"),
        dictgen::InsensitiveStr::Ascii("itiion"),
        dictgen::InsensitiveStr::Ascii("itin"),
        dictgen::InsensitiveStr::Ascii("iting"),
        dictgen::InsensitiveStr::Ascii("itio"),
        dictgen::InsensitiveStr::Ascii("itioners"),
        dictgen::InsensitiveStr::Ascii("itior"),
        dictgen::InsensitiveStr::Ascii("itiors"),
        dictgen::InsensitiveStr::Ascii("itivley"),
        dictgen::InsensitiveStr::Ascii("itivly"),
        dictgen::InsensitiveStr::Ascii("itivo"),
        dictgen::InsensitiveStr::Ascii("itivos"),
        dictgen::InsensitiveStr::Ascii("itoin"),
        dictgen::InsensitiveStr::Ascii("iton"),
        dictgen::InsensitiveStr::Ascii("itons"),
        dictgen::InsensitiveStr::Ascii("itve"),
        dictgen::InsensitiveStr::Ascii("ive"),
        dictgen::InsensitiveStr::Ascii("iveness"),
        dictgen::InsensitiveStr::Ascii("ution"),
    ],
    values: &[
        &["competence"],
        &["competent"],
        &["computation"],
        &["competitive"],
        &["competitively"],
        &["competitor"],
        &["competitors"],
        &["completely"],
        &["competed"],
        &["competence"],
        &["competence"],
        &["competence"],
        &["competed"],
        &["competition"],
        &["competitions"],
        &["competitive"],
        &["competitor"],
        &["competitors"],
        &["competitor"],
        &["competition", "completion"],
        &["completions"],
        &["competitors"],
        &["competitively"],
        &["competitors"],
        &["competitively"],
        &["competitively"],
        &["competitive"],
        &["competition"],
        &["competitions"],
        &["competition"],
        &["competitor"],
        &["competitions"],
        &["competitor"],
        &["competitors"],
        &["competitively"],
        &["competitively"],
        &["competition"],
        &["competitions"],
        &["competitions"],
        &["competition"],
        &["competitors"],
        &["competitive"],
        &["competitive"],
        &["competitiveness"],
        &["computation"],
    ],
    range: 3..=8,
};

static WORD_COMPES_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COMPES_CHILDREN),
    value: None,
};

pub static WORD_COMPES_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ition"),
        dictgen::InsensitiveStr::Ascii("itions"),
        dictgen::InsensitiveStr::Ascii("sion"),
    ],
    values: &[&["composition"], &["compositions"], &["compassion"]],
    range: 4..=6,
};

static WORD_COMPER_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COMPER_CHILDREN),
    value: None,
};

pub static WORD_COMPER_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("able"),
        dictgen::InsensitiveStr::Ascii("ative"),
        dictgen::InsensitiveStr::Ascii("atively"),
        dictgen::InsensitiveStr::Ascii("hend"),
        dictgen::InsensitiveStr::Ascii("hension"),
    ],
    values: &[
        &["comparable"],
        &["comparative"],
        &["comparatively"],
        &["comprehend"],
        &["comprehension"],
    ],
    range: 4..=7,
};

static WORD_COMPEN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COMPEN_CHILDREN),
    value: None,
};

pub static WORD_COMPEN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("duim"),
        dictgen::InsensitiveStr::Ascii("ent"),
        dictgen::InsensitiveStr::Ascii("ents"),
        dictgen::InsensitiveStr::Ascii("idum"),
        dictgen::InsensitiveStr::Ascii("sacion"),
        dictgen::InsensitiveStr::Ascii("sante"),
        dictgen::InsensitiveStr::Ascii("santion"),
        dictgen::InsensitiveStr::Ascii("sare"),
        dictgen::InsensitiveStr::Ascii("satie"),
        dictgen::InsensitiveStr::Ascii("satin"),
        dictgen::InsensitiveStr::Ascii("sationg"),
        dictgen::InsensitiveStr::Ascii("sative"),
        dictgen::InsensitiveStr::Ascii("se"),
        dictgen::InsensitiveStr::Ascii("state"),
        dictgen::InsensitiveStr::Ascii("stated"),
        dictgen::InsensitiveStr::Ascii("states"),
    ],
    values: &[
        &["compendium"],
        &["component", "competent"],
        &["components", "competence"],
        &["compendium"],
        &["compensation"],
        &["compensate"],
        &["compensation"],
        &["compensate"],
        &["compensate"],
        &["compensation"],
        &["compensating"],
        &["compensate"],
        &["compensate"],
        &["compensate"],
        &["compensated"],
        &["compensates"],
    ],
    range: 2..=7,
};

static WORD_COMPEM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COMPEM_CHILDREN),
    value: None,
};

pub static WORD_COMPEM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("dium")],
    values: &[&["compendium"]],
    range: 4..=4,
};

static WORD_COMPEL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COMPEL_CHILDREN),
    value: None,
};

pub static WORD_COMPEL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ation"),
        dictgen::InsensitiveStr::Ascii("etely"),
        dictgen::InsensitiveStr::Ascii("te"),
        dictgen::InsensitiveStr::Ascii("tely"),
        dictgen::InsensitiveStr::Ascii("telyt"),
        dictgen::InsensitiveStr::Ascii("tes"),
        dictgen::InsensitiveStr::Ascii("ting"),
        dictgen::InsensitiveStr::Ascii("tion"),
        dictgen::InsensitiveStr::Ascii("tly"),
        dictgen::InsensitiveStr::Ascii("x"),
        dictgen::InsensitiveStr::Ascii("xes"),
        dictgen::InsensitiveStr::Ascii("xities"),
        dictgen::InsensitiveStr::Ascii("xity"),
    ],
    values: &[
        &["compilation"],
        &["completely"],
        &["complete"],
        &["completely"],
        &["completely"],
        &["completes"],
        &["completing"],
        &["completion"],
        &["completely"],
        &["complex"],
        &["complexes"],
        &["complexities"],
        &["complexity"],
    ],
    range: 1..=6,
};

static WORD_COMPEI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COMPEI_CHILDREN),
    value: None,
};

pub static WORD_COMPEI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("tions"),
        dictgen::InsensitiveStr::Ascii("ttion"),
    ],
    values: &[&["competitions"], &["competitions"]],
    range: 5..=5,
};

static WORD_COMPEE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COMPEE_CHILDREN),
    value: None,
};

pub static WORD_COMPEE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ting")],
    values: &[&["completing"]],
    range: 4..=4,
};

static WORD_COMPED_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COMPED_CHILDREN),
    value: None,
};

pub static WORD_COMPED_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("itive"),
        dictgen::InsensitiveStr::Ascii("itively"),
        dictgen::InsensitiveStr::Ascii("itor"),
        dictgen::InsensitiveStr::Ascii("itors"),
        dictgen::InsensitiveStr::Ascii("nium"),
    ],
    values: &[
        &["competed"],
        &["competitive"],
        &["competitively"],
        &["competitor"],
        &["competitors"],
        &["compendium"],
    ],
    range: 1..=7,
};

static WORD_COMPEA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COMPEA_CHILDREN),
    value: None,
};

pub static WORD_COMPEA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("re"),
        dictgen::InsensitiveStr::Ascii("red"),
        dictgen::InsensitiveStr::Ascii("res"),
        dictgen::InsensitiveStr::Ascii("ring"),
        dictgen::InsensitiveStr::Ascii("rs"),
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("ted"),
        dictgen::InsensitiveStr::Ascii("tes"),
        dictgen::InsensitiveStr::Ascii("ting"),
    ],
    values: &[
        &["compare"],
        &["compared"],
        &["compares"],
        &["comparing"],
        &["compares"],
        &["compete"],
        &["competed"],
        &["competes"],
        &["completing", "competing"],
    ],
    range: 1..=4,
};

static WORD_COMPA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_COMPA_CHILDREN),
    value: None,
};

static WORD_COMPA_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    Some(&WORD_COMPAB_NODE),
    None,
    Some(&WORD_COMPAD_NODE),
    None,
    None,
    Some(&WORD_COMPAG_NODE),
    None,
    Some(&WORD_COMPAI_NODE),
    None,
    None,
    Some(&WORD_COMPAL_NODE),
    None,
    Some(&WORD_COMPAN_NODE),
    None,
    None,
    None,
    Some(&WORD_COMPAR_NODE),
    Some(&WORD_COMPAS_NODE),
    Some(&WORD_COMPAT_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_COMPAY_NODE),
    None,
];

static WORD_COMPAY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COMPAY_CHILDREN),
    value: None,
};

pub static WORD_COMPAY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("tibility")],
    values: &[&["compatibility"]],
    range: 8..=8,
};

static WORD_COMPAT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COMPAT_CHILDREN),
    value: None,
};

pub static WORD_COMPAT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("abable"),
        dictgen::InsensitiveStr::Ascii("abiity"),
        dictgen::InsensitiveStr::Ascii("abile"),
        dictgen::InsensitiveStr::Ascii("abilities"),
        dictgen::InsensitiveStr::Ascii("ability"),
        dictgen::InsensitiveStr::Ascii("abillity"),
        dictgen::InsensitiveStr::Ascii("abilty"),
        dictgen::InsensitiveStr::Ascii("abily"),
        dictgen::InsensitiveStr::Ascii("able"),
        dictgen::InsensitiveStr::Ascii("ablie"),
        dictgen::InsensitiveStr::Ascii("ablility"),
        dictgen::InsensitiveStr::Ascii("ablities"),
        dictgen::InsensitiveStr::Ascii("ablitiy"),
        dictgen::InsensitiveStr::Ascii("ablity"),
        dictgen::InsensitiveStr::Ascii("ably"),
        dictgen::InsensitiveStr::Ascii("aibility"),
        dictgen::InsensitiveStr::Ascii("aible"),
        dictgen::InsensitiveStr::Ascii("aility"),
        dictgen::InsensitiveStr::Ascii("atbility"),
        dictgen::InsensitiveStr::Ascii("atble"),
        dictgen::InsensitiveStr::Ascii("atible"),
        dictgen::InsensitiveStr::Ascii("ative"),
        dictgen::InsensitiveStr::Ascii("ator"),
        dictgen::InsensitiveStr::Ascii("ators"),
        dictgen::InsensitiveStr::Ascii("bile"),
        dictgen::InsensitiveStr::Ascii("bility"),
        dictgen::InsensitiveStr::Ascii("ble"),
        dictgen::InsensitiveStr::Ascii("iability"),
        dictgen::InsensitiveStr::Ascii("iable"),
        dictgen::InsensitiveStr::Ascii("iablity"),
        dictgen::InsensitiveStr::Ascii("ibel"),
        dictgen::InsensitiveStr::Ascii("ibil"),
        dictgen::InsensitiveStr::Ascii("ibile"),
        dictgen::InsensitiveStr::Ascii("ibililty"),
        dictgen::InsensitiveStr::Ascii("ibiliy"),
        dictgen::InsensitiveStr::Ascii("ibillity"),
        dictgen::InsensitiveStr::Ascii("ibiltiy"),
        dictgen::InsensitiveStr::Ascii("ibilty"),
        dictgen::InsensitiveStr::Ascii("ibily"),
        dictgen::InsensitiveStr::Ascii("ibity"),
        dictgen::InsensitiveStr::Ascii("iblilty"),
        dictgen::InsensitiveStr::Ascii("iblities"),
        dictgen::InsensitiveStr::Ascii("iblity"),
        dictgen::InsensitiveStr::Ascii("ion"),
        dictgen::InsensitiveStr::Ascii("itbility"),
        dictgen::InsensitiveStr::Ascii("ivle"),
    ],
    values: &[
        &["compatible"],
        &["compatibility"],
        &["compatible"],
        &["compatibilities"],
        &["compatibility"],
        &["compatibility"],
        &["compatibility"],
        &["compatibility"],
        &["compatible"],
        &["compatible", "compatibly"],
        &["compatibility"],
        &["compatibilities"],
        &["compatibility"],
        &["compatibility"],
        &["compatibly"],
        &["compatibility"],
        &["compatible"],
        &["compatibility"],
        &["compatibility"],
        &["compatible"],
        &["compatible"],
        &["comparative"],
        &["comparator"],
        &["comparators"],
        &["compatible"],
        &["compatibility"],
        &["compatible"],
        &["compatibility"],
        &["compatible"],
        &["compatibility"],
        &["compatible"],
        &["compatible"],
        &["compatible"],
        &["compatibility"],
        &["compatibility"],
        &["compatibility"],
        &["compatibility"],
        &["compatibility"],
        &["compatibility"],
        &["compatibility"],
        &["compatibility"],
        &["compatibilities"],
        &["compatibility"],
        &["compaction"],
        &["compatibility"],
        &["compatible"],
    ],
    range: 3..=9,
};

static WORD_COMPAS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COMPAS_CHILDREN),
    value: None,
};

pub static WORD_COMPAS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("sione"),
        dictgen::InsensitiveStr::Ascii("so"),
        dictgen::InsensitiveStr::Ascii("ssion"),
    ],
    values: &[
        &["compares"],
        &["compassionate"],
        &["compassion"],
        &["compassion"],
    ],
    range: 1..=5,
};

static WORD_COMPAR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_COMPAR_CHILDREN),
    value: None,
};

static WORD_COMPAR_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_COMPARA_NODE),
    None,
    None,
    None,
    Some(&WORD_COMPARE_NODE),
    None,
    None,
    None,
    Some(&WORD_COMPARI_NODE),
    None,
    None,
    None,
    Some(&WORD_COMPARM_NODE),
    None,
    Some(&WORD_COMPARO_NODE),
    None,
    None,
    Some(&WORD_COMPARR_NODE),
    Some(&WORD_COMPARS_NODE),
    Some(&WORD_COMPART_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_COMPART_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COMPART_CHILDREN),
    value: None,
};

pub static WORD_COMPART_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("e"),
            dictgen::InsensitiveStr::Ascii("ent"),
            dictgen::InsensitiveStr::Ascii("met"),
        ],
        values: &[&["compare"], &["compartment"], &["compartment"]],
        range: 1..=3,
    };

static WORD_COMPARS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COMPARS_CHILDREN),
    value: None,
};

pub static WORD_COMPARS_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("e"),
            dictgen::InsensitiveStr::Ascii("ion"),
            dictgen::InsensitiveStr::Ascii("ions"),
        ],
        values: &[&["compares"], &["comparison"], &["comparisons"]],
        range: 1..=4,
    };

static WORD_COMPARR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COMPARR_CHILDREN),
    value: None,
};

pub static WORD_COMPARR_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[dictgen::InsensitiveStr::Ascii("e")],
        values: &[&["compare"]],
        range: 1..=1,
    };

static WORD_COMPARO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COMPARO_CHILDREN),
    value: None,
};

pub static WORD_COMPARO_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("tor"),
            dictgen::InsensitiveStr::Ascii("tors"),
        ],
        values: &[&["comparator"], &["comparators"]],
        range: 3..=4,
    };

static WORD_COMPARM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COMPARM_CHILDREN),
    value: None,
};

pub static WORD_COMPARM_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[dictgen::InsensitiveStr::Ascii("ent")],
        values: &[&["compartment"]],
        range: 3..=3,
    };

static WORD_COMPARI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COMPARI_CHILDREN),
    value: None,
};

pub static WORD_COMPARI_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("able"),
            dictgen::InsensitiveStr::Ascii("ed"),
            dictgen::InsensitiveStr::Ascii("gn"),
            dictgen::InsensitiveStr::Ascii("gon"),
            dictgen::InsensitiveStr::Ascii("gons"),
            dictgen::InsensitiveStr::Ascii("ing"),
            dictgen::InsensitiveStr::Ascii("on"),
            dictgen::InsensitiveStr::Ascii("ons"),
            dictgen::InsensitiveStr::Ascii("os"),
            dictgen::InsensitiveStr::Ascii("osn"),
            dictgen::InsensitiveStr::Ascii("oss"),
            dictgen::InsensitiveStr::Ascii("saion"),
            dictgen::InsensitiveStr::Ascii("saions"),
            dictgen::InsensitiveStr::Ascii("sation"),
            dictgen::InsensitiveStr::Ascii("sations"),
            dictgen::InsensitiveStr::Ascii("sement"),
            dictgen::InsensitiveStr::Ascii("sements"),
            dictgen::InsensitiveStr::Ascii("sen"),
            dictgen::InsensitiveStr::Ascii("sin"),
            dictgen::InsensitiveStr::Ascii("sing"),
            dictgen::InsensitiveStr::Ascii("sins"),
            dictgen::InsensitiveStr::Ascii("sion"),
            dictgen::InsensitiveStr::Ascii("sions"),
            dictgen::InsensitiveStr::Ascii("sm"),
            dictgen::InsensitiveStr::Ascii("sment"),
            dictgen::InsensitiveStr::Ascii("sments"),
            dictgen::InsensitiveStr::Ascii("sms"),
            dictgen::InsensitiveStr::Ascii("sn"),
            dictgen::InsensitiveStr::Ascii("sns"),
            dictgen::InsensitiveStr::Ascii("spon"),
            dictgen::InsensitiveStr::Ascii("spons"),
            dictgen::InsensitiveStr::Ascii("ssion"),
            dictgen::InsensitiveStr::Ascii("ssions"),
            dictgen::InsensitiveStr::Ascii("sson"),
            dictgen::InsensitiveStr::Ascii("ssons"),
            dictgen::InsensitiveStr::Ascii("stion"),
            dictgen::InsensitiveStr::Ascii("stions"),
            dictgen::InsensitiveStr::Ascii("ston"),
            dictgen::InsensitiveStr::Ascii("stons"),
            dictgen::InsensitiveStr::Ascii("tave"),
            dictgen::InsensitiveStr::Ascii("tavely"),
            dictgen::InsensitiveStr::Ascii("tion"),
            dictgen::InsensitiveStr::Ascii("tions"),
            dictgen::InsensitiveStr::Ascii("titive"),
            dictgen::InsensitiveStr::Ascii("titively"),
            dictgen::InsensitiveStr::Ascii("tive"),
            dictgen::InsensitiveStr::Ascii("tively"),
            dictgen::InsensitiveStr::Ascii("tor"),
            dictgen::InsensitiveStr::Ascii("tors"),
            dictgen::InsensitiveStr::Ascii("tve"),
            dictgen::InsensitiveStr::Ascii("zon"),
            dictgen::InsensitiveStr::Ascii("zons"),
        ],
        values: &[
            &["comparable"],
            &["compared"],
            &["comparing"],
            &["comparison"],
            &["comparisons"],
            &["comparing"],
            &["comparison"],
            &["comparison", "comparisons"],
            &["comparison"],
            &["comparisons"],
            &["comparisons"],
            &["comparison"],
            &["comparisons"],
            &["comparison"],
            &["comparisons"],
            &["comparison"],
            &["comparisons"],
            &["compares"],
            &["comparison"],
            &["comparing"],
            &["comparisons"],
            &["comparison"],
            &["comparisons"],
            &["comparison"],
            &["comparison"],
            &["comparisons"],
            &["comparisons"],
            &["comparisons", "comparison"],
            &["comparisons"],
            &["comparison"],
            &["comparisons"],
            &["comparisons", "comparison"],
            &["comparisons"],
            &["comparisons", "comparison"],
            &["comparisons"],
            &["comparison"],
            &["comparisons"],
            &["comparison"],
            &["comparisons"],
            &["comparative"],
            &["comparatively"],
            &["comparison"],
            &["comparisons"],
            &["comparative"],
            &["comparatively"],
            &["comparative"],
            &["comparatively"],
            &["comparator"],
            &["comparators"],
            &["comparative"],
            &["comparison"],
            &["comparisons"],
        ],
        range: 2..=8,
    };

static WORD_COMPARE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COMPARE_CHILDREN),
    value: None,
};

pub static WORD_COMPARE_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("able"),
            dictgen::InsensitiveStr::Ascii("ble"),
            dictgen::InsensitiveStr::Ascii("ing"),
            dictgen::InsensitiveStr::Ascii("ison"),
            dictgen::InsensitiveStr::Ascii("isons"),
            dictgen::InsensitiveStr::Ascii("ment"),
            dictgen::InsensitiveStr::Ascii("ments"),
            dictgen::InsensitiveStr::Ascii("mos"),
            dictgen::InsensitiveStr::Ascii("tive"),
            dictgen::InsensitiveStr::Ascii("tively"),
        ],
        values: &[
            &["comparable"],
            &["comparable"],
            &["comparing"],
            &["comparison"],
            &["comparisons"],
            &["compartment", "comparing", "comparison"],
            &["compartments"],
            &["compares"],
            &["comparative"],
            &["comparatively"],
        ],
        range: 3..=6,
    };

static WORD_COMPARA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COMPARA_CHILDREN),
    value: None,
};

pub static WORD_COMPARA_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("bil"),
            dictgen::InsensitiveStr::Ascii("bile"),
            dictgen::InsensitiveStr::Ascii("ison"),
            dictgen::InsensitiveStr::Ascii("re"),
            dictgen::InsensitiveStr::Ascii("sion"),
            dictgen::InsensitiveStr::Ascii("sions"),
            dictgen::InsensitiveStr::Ascii("son"),
            dictgen::InsensitiveStr::Ascii("sons"),
            dictgen::InsensitiveStr::Ascii("ste"),
            dictgen::InsensitiveStr::Ascii("ter"),
            dictgen::InsensitiveStr::Ascii("tie"),
            dictgen::InsensitiveStr::Ascii("tion"),
            dictgen::InsensitiveStr::Ascii("tions"),
            dictgen::InsensitiveStr::Ascii("tivley"),
            dictgen::InsensitiveStr::Ascii("tivly"),
        ],
        values: &[
            &["comparable"],
            &["comparable"],
            &["comparison"],
            &["compare"],
            &["comparison"],
            &["comparisons"],
            &["comparison"],
            &["comparisons"],
            &["compares"],
            &["comparator"],
            &["comparative"],
            &["comparison"],
            &["comparisons"],
            &["comparatively"],
            &["comparatively"],
        ],
        range: 2..=6,
    };

static WORD_COMPAN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COMPAN_CHILDREN),
    value: None,
};

pub static WORD_COMPAN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("dium"),
        dictgen::InsensitiveStr::Ascii("ians"),
        dictgen::InsensitiveStr::Ascii("ines"),
        dictgen::InsensitiveStr::Ascii("is"),
        dictgen::InsensitiveStr::Ascii("sate"),
        dictgen::InsensitiveStr::Ascii("sated"),
        dictgen::InsensitiveStr::Ascii("sates"),
        dictgen::InsensitiveStr::Ascii("sating"),
        dictgen::InsensitiveStr::Ascii("sation"),
        dictgen::InsensitiveStr::Ascii("sations"),
    ],
    values: &[
        &["compendium"],
        &["companions"],
        &["companions"],
        &["companions"],
        &["compensate"],
        &["compensated"],
        &["compensates"],
        &["compensating"],
        &["compensation"],
        &["compensations"],
    ],
    range: 2..=7,
};

static WORD_COMPAL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COMPAL_CHILDREN),
    value: None,
};

pub static WORD_COMPAL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ation"),
        dictgen::InsensitiveStr::Ascii("ined"),
        dictgen::InsensitiveStr::Ascii("ins"),
        dictgen::InsensitiveStr::Ascii("int"),
    ],
    values: &[
        &["compilation"],
        &["complained"],
        &["complains"],
        &["compliant"],
    ],
    range: 3..=5,
};

static WORD_COMPAI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COMPAI_CHILDREN),
    value: None,
};

pub static WORD_COMPAI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("bility"),
        dictgen::InsensitiveStr::Ascii("gns"),
        dictgen::InsensitiveStr::Ascii("n"),
        dictgen::InsensitiveStr::Ascii("nes"),
        dictgen::InsensitiveStr::Ascii("nons"),
        dictgen::InsensitiveStr::Ascii("r"),
        dictgen::InsensitiveStr::Ascii("re"),
        dictgen::InsensitiveStr::Ascii("red"),
        dictgen::InsensitiveStr::Ascii("ring"),
        dictgen::InsensitiveStr::Ascii("rison"),
        dictgen::InsensitiveStr::Ascii("risons"),
        dictgen::InsensitiveStr::Ascii("rs"),
        dictgen::InsensitiveStr::Ascii("rson"),
    ],
    values: &[
        &["compatibility"],
        &["campaigns"],
        &["complain"],
        &["companies"],
        &["companions"],
        &["compare"],
        &["compare"],
        &["compared"],
        &["comparing"],
        &["comparison"],
        &["comparisons"],
        &["compares"],
        &["comparison"],
    ],
    range: 1..=6,
};

static WORD_COMPAG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COMPAG_CHILDREN),
    value: None,
};

pub static WORD_COMPAG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("nion"),
        dictgen::InsensitiveStr::Ascii("nons"),
        dictgen::InsensitiveStr::Ascii("ny"),
    ],
    values: &[&["companion"], &["companions"], &["company"]],
    range: 2..=4,
};

static WORD_COMPAD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COMPAD_CHILDREN),
    value: None,
};

pub static WORD_COMPAD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ibility"),
        dictgen::InsensitiveStr::Ascii("ible"),
    ],
    values: &[&["compatibility"], &["compatible"]],
    range: 4..=7,
};

static WORD_COMPAB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COMPAB_CHILDREN),
    value: None,
};

pub static WORD_COMPAB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ility"),
        dictgen::InsensitiveStr::Ascii("illity"),
        dictgen::InsensitiveStr::Ascii("itiliby"),
        dictgen::InsensitiveStr::Ascii("itility"),
    ],
    values: &[
        &["compatibility"],
        &["compatibility"],
        &["compatibility"],
        &["compatibility"],
    ],
    range: 5..=7,
};

static WORD_COMO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COMO_CHILDREN),
    value: None,
};

pub static WORD_COMO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("n"),
        dictgen::InsensitiveStr::Ascii("nent"),
        dictgen::InsensitiveStr::Ascii("nents"),
        dictgen::InsensitiveStr::Ascii("pnent"),
        dictgen::InsensitiveStr::Ascii("pnents"),
        dictgen::InsensitiveStr::Ascii("r"),
        dictgen::InsensitiveStr::Ascii("tion"),
    ],
    values: &[
        &["common"],
        &["component"],
        &["components"],
        &["component"],
        &["components"],
        &["color"],
        &["commotion"],
    ],
    range: 1..=6,
};

static WORD_COMN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COMN_CHILDREN),
    value: None,
};

pub static WORD_COMN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("mand"),
        dictgen::InsensitiveStr::Ascii("nected"),
        dictgen::InsensitiveStr::Ascii("paring"),
        dictgen::InsensitiveStr::Ascii("pletion"),
        dictgen::InsensitiveStr::Ascii("presion"),
        dictgen::InsensitiveStr::Ascii("press"),
    ],
    values: &[
        &["command"],
        &["connected"],
        &["comparing"],
        &["completion"],
        &["compression"],
        &["compress"],
    ],
    range: 4..=7,
};

static WORD_COMM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_COMM_CHILDREN),
    value: None,
};

static WORD_COMM_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_COMMA_NODE),
    None,
    None,
    None,
    Some(&WORD_COMME_NODE),
    None,
    None,
    None,
    Some(&WORD_COMMI_NODE),
    None,
    None,
    None,
    Some(&WORD_COMMM_NODE),
    Some(&WORD_COMMN_NODE),
    Some(&WORD_COMMO_NODE),
    Some(&WORD_COMMP_NODE),
    None,
    None,
    None,
    Some(&WORD_COMMT_NODE),
    Some(&WORD_COMMU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_COMMU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COMMU_CHILDREN),
    value: None,
};

pub static WORD_COMMU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ication"),
        dictgen::InsensitiveStr::Ascii("ications"),
        dictgen::InsensitiveStr::Ascii("incate"),
        dictgen::InsensitiveStr::Ascii("incation"),
        dictgen::InsensitiveStr::Ascii("inications"),
        dictgen::InsensitiveStr::Ascii("n"),
        dictgen::InsensitiveStr::Ascii("ncated"),
        dictgen::InsensitiveStr::Ascii("ncation"),
        dictgen::InsensitiveStr::Ascii("ncations"),
        dictgen::InsensitiveStr::Ascii("nciate"),
        dictgen::InsensitiveStr::Ascii("nciated"),
        dictgen::InsensitiveStr::Ascii("nciation"),
        dictgen::InsensitiveStr::Ascii("nciations"),
        dictgen::InsensitiveStr::Ascii("niaction"),
        dictgen::InsensitiveStr::Ascii("niation"),
        dictgen::InsensitiveStr::Ascii("nicae"),
        dictgen::InsensitiveStr::Ascii("nicaion"),
        dictgen::InsensitiveStr::Ascii("nicaiton"),
        dictgen::InsensitiveStr::Ascii("nicatie"),
        dictgen::InsensitiveStr::Ascii("nicatin"),
        dictgen::InsensitiveStr::Ascii("nicatoin"),
        dictgen::InsensitiveStr::Ascii("nicaton"),
        dictgen::InsensitiveStr::Ascii("nicatons"),
        dictgen::InsensitiveStr::Ascii("nicted"),
        dictgen::InsensitiveStr::Ascii("nikay"),
        dictgen::InsensitiveStr::Ascii("nikays"),
        dictgen::InsensitiveStr::Ascii("nisim"),
        dictgen::InsensitiveStr::Ascii("nisit"),
        dictgen::InsensitiveStr::Ascii("nisits"),
        dictgen::InsensitiveStr::Ascii("niss"),
        dictgen::InsensitiveStr::Ascii("nistas"),
        dictgen::InsensitiveStr::Ascii("niste"),
        dictgen::InsensitiveStr::Ascii("nistes"),
        dictgen::InsensitiveStr::Ascii("nit"),
        dictgen::InsensitiveStr::Ascii("nitcate"),
        dictgen::InsensitiveStr::Ascii("nitcated"),
        dictgen::InsensitiveStr::Ascii("nitcates"),
        dictgen::InsensitiveStr::Ascii("nitcation"),
        dictgen::InsensitiveStr::Ascii("nitcations"),
        dictgen::InsensitiveStr::Ascii("nite"),
        dictgen::InsensitiveStr::Ascii("nites"),
        dictgen::InsensitiveStr::Ascii("nitites"),
        dictgen::InsensitiveStr::Ascii("nits"),
        dictgen::InsensitiveStr::Ascii("niy"),
        dictgen::InsensitiveStr::Ascii("niyt"),
        dictgen::InsensitiveStr::Ascii("nsim"),
        dictgen::InsensitiveStr::Ascii("nsit"),
        dictgen::InsensitiveStr::Ascii("nsits"),
        dictgen::InsensitiveStr::Ascii("nters"),
        dictgen::InsensitiveStr::Ascii("nuication"),
        dictgen::InsensitiveStr::Ascii("tated"),
        dictgen::InsensitiveStr::Ascii("tating"),
        dictgen::InsensitiveStr::Ascii("tive"),
    ],
    values: &[
        &["communication"],
        &["communications"],
        &["communicated"],
        &["communications"],
        &["communications"],
        &["common", "commune"],
        &["communicated"],
        &["communication"],
        &["communications"],
        &["communicate"],
        &["communicated"],
        &["communication"],
        &["communications"],
        &["communications"],
        &["communication"],
        &["communicated"],
        &["communication"],
        &["communication"],
        &["communicate", "communication"],
        &["communications"],
        &["communications"],
        &["communication"],
        &["communications"],
        &["communicated"],
        &["communiqué"],
        &["communiqués"],
        &["communism"],
        &["communist"],
        &["communists"],
        &["communists"],
        &["communists"],
        &["communities"],
        &["communists"],
        &["communist"],
        &["communicate"],
        &["communicated"],
        &["communicates"],
        &["communication"],
        &["communications"],
        &["communities"],
        &["communities"],
        &["communities"],
        &["communist"],
        &["community"],
        &["community"],
        &["communism"],
        &["communist"],
        &["communists"],
        &["commenters"],
        &["communication"],
        &["commuted"],
        &["commuting"],
        &["commutative"],
    ],
    range: 1..=10,
};

static WORD_COMMT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COMMT_CHILDREN),
    value: None,
};

pub static WORD_COMMT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("iment"),
        dictgen::InsensitiveStr::Ascii("ited"),
        dictgen::InsensitiveStr::Ascii("ted"),
    ],
    values: &[&["commitments"], &["committed"], &["committed"]],
    range: 3..=5,
};

static WORD_COMMP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COMMP_CHILDREN),
    value: None,
};

pub static WORD_COMMP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("act"),
        dictgen::InsensitiveStr::Ascii("action"),
        dictgen::InsensitiveStr::Ascii("and"),
        dictgen::InsensitiveStr::Ascii("are"),
        dictgen::InsensitiveStr::Ascii("arisons"),
        dictgen::InsensitiveStr::Ascii("atibility"),
        dictgen::InsensitiveStr::Ascii("atible"),
        dictgen::InsensitiveStr::Ascii("essed"),
        dictgen::InsensitiveStr::Ascii("ilation"),
        dictgen::InsensitiveStr::Ascii("ile"),
        dictgen::InsensitiveStr::Ascii("iled"),
        dictgen::InsensitiveStr::Ascii("iling"),
        dictgen::InsensitiveStr::Ascii("lain"),
        dictgen::InsensitiveStr::Ascii("lete"),
        dictgen::InsensitiveStr::Ascii("leted"),
        dictgen::InsensitiveStr::Ascii("letely"),
        dictgen::InsensitiveStr::Ascii("letes"),
        dictgen::InsensitiveStr::Ascii("letion"),
        dictgen::InsensitiveStr::Ascii("lex"),
        dictgen::InsensitiveStr::Ascii("liant"),
        dictgen::InsensitiveStr::Ascii("lied"),
        dictgen::InsensitiveStr::Ascii("n"),
        dictgen::InsensitiveStr::Ascii("onent"),
        dictgen::InsensitiveStr::Ascii("onents"),
        dictgen::InsensitiveStr::Ascii("ound"),
        dictgen::InsensitiveStr::Ascii("resd"),
        dictgen::InsensitiveStr::Ascii("resed"),
        dictgen::InsensitiveStr::Ascii("resion"),
        dictgen::InsensitiveStr::Ascii("ress"),
        dictgen::InsensitiveStr::Ascii("ressd"),
        dictgen::InsensitiveStr::Ascii("ressed"),
        dictgen::InsensitiveStr::Ascii("ression"),
        dictgen::InsensitiveStr::Ascii("ute"),
        dictgen::InsensitiveStr::Ascii("uted"),
        dictgen::InsensitiveStr::Ascii("uter"),
        dictgen::InsensitiveStr::Ascii("utes"),
        dictgen::InsensitiveStr::Ascii("uting"),
    ],
    values: &[
        &["compact"],
        &["compaction"],
        &["command", "compand"],
        &["compare"],
        &["comparisons"],
        &["compatibility"],
        &["compatible"],
        &["compressed"],
        &["compilation"],
        &["compile"],
        &["compiled"],
        &["compiling"],
        &["complain"],
        &["complete"],
        &["completed"],
        &["completely"],
        &["completes"],
        &["completion"],
        &["complex"],
        &["compliant"],
        &["complied"],
        &["common"],
        &["component"],
        &["components"],
        &["compound"],
        &["compressed"],
        &["compressed"],
        &["compression"],
        &["compress"],
        &["compressed"],
        &["compressed"],
        &["compression"],
        &["compute"],
        &["computed"],
        &["computer"],
        &["computes"],
        &["computing"],
    ],
    range: 1..=9,
};

static WORD_COMMO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COMMO_CHILDREN),
    value: None,
};

pub static WORD_COMMO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("dites"),
        dictgen::InsensitiveStr::Ascii("ditites"),
        dictgen::InsensitiveStr::Ascii("ditiy"),
        dictgen::InsensitiveStr::Ascii("doties"),
        dictgen::InsensitiveStr::Ascii("m"),
        dictgen::InsensitiveStr::Ascii("mplace"),
        dictgen::InsensitiveStr::Ascii("mwealth"),
        dictgen::InsensitiveStr::Ascii("nd"),
        dictgen::InsensitiveStr::Ascii("ngly"),
        dictgen::InsensitiveStr::Ascii("nhealth"),
        dictgen::InsensitiveStr::Ascii("nspace"),
        dictgen::InsensitiveStr::Ascii("nt"),
        dictgen::InsensitiveStr::Ascii("ntly"),
        dictgen::InsensitiveStr::Ascii("nweath"),
        dictgen::InsensitiveStr::Ascii("nweatlh"),
        dictgen::InsensitiveStr::Ascii("nwelath"),
        dictgen::InsensitiveStr::Ascii("nwelth"),
    ],
    values: &[
        &["commodities"],
        &["commodities"],
        &["commodity"],
        &["commodities"],
        &["common"],
        &["commonplace"],
        &["commonwealth"],
        &["command"],
        &["commonly"],
        &["commonwealth"],
        &["commonplace"],
        &["common", "comment"],
        &["commonly"],
        &["commonwealth"],
        &["commonwealth"],
        &["commonwealth"],
        &["commonwealth"],
    ],
    range: 1..=7,
};

static WORD_COMMN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COMMN_CHILDREN),
    value: None,
};

pub static WORD_COMMN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("a"),
        dictgen::InsensitiveStr::Ascii("ad"),
        dictgen::InsensitiveStr::Ascii("adline"),
        dictgen::InsensitiveStr::Ascii("ads"),
        dictgen::InsensitiveStr::Ascii("and"),
        dictgen::InsensitiveStr::Ascii("andline"),
        dictgen::InsensitiveStr::Ascii("ands"),
        dictgen::InsensitiveStr::Ascii("d"),
        dictgen::InsensitiveStr::Ascii("dline"),
        dictgen::InsensitiveStr::Ascii("ds"),
        dictgen::InsensitiveStr::Ascii("ent"),
        dictgen::InsensitiveStr::Ascii("ents"),
        dictgen::InsensitiveStr::Ascii("et"),
        dictgen::InsensitiveStr::Ascii("etaries"),
        dictgen::InsensitiveStr::Ascii("etary"),
        dictgen::InsensitiveStr::Ascii("etator"),
        dictgen::InsensitiveStr::Ascii("etators"),
        dictgen::InsensitiveStr::Ascii("eted"),
        dictgen::InsensitiveStr::Ascii("eting"),
        dictgen::InsensitiveStr::Ascii("ets"),
        dictgen::InsensitiveStr::Ascii("ication"),
        dictgen::InsensitiveStr::Ascii("ities"),
        dictgen::InsensitiveStr::Ascii("ity"),
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("ted"),
        dictgen::InsensitiveStr::Ascii("uative"),
        dictgen::InsensitiveStr::Ascii("unicating"),
        dictgen::InsensitiveStr::Ascii("unication"),
        dictgen::InsensitiveStr::Ascii("unity"),
    ],
    values: &[
        &["comma"],
        &["command"],
        &["commandline"],
        &["commands"],
        &["command"],
        &["commandline"],
        &["commands"],
        &["command"],
        &["commandline"],
        &["commands"],
        &["comment"],
        &["comments"],
        &["comment"],
        &["commentaries"],
        &["commentary"],
        &["commentator"],
        &["commentators"],
        &["commented"],
        &["commenting"],
        &["comments"],
        &["communication"],
        &["communities"],
        &["community"],
        &["comment"],
        &["commented"],
        &["commutative"],
        &["communicating"],
        &["communication"],
        &["community"],
    ],
    range: 1..=9,
};

static WORD_COMMM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COMMM_CHILDREN),
    value: None,
};

pub static WORD_COMMM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("a"),
        dictgen::InsensitiveStr::Ascii("and"),
        dictgen::InsensitiveStr::Ascii("andline"),
        dictgen::InsensitiveStr::Ascii("ands"),
        dictgen::InsensitiveStr::Ascii("emorated"),
        dictgen::InsensitiveStr::Ascii("ent"),
        dictgen::InsensitiveStr::Ascii("ented"),
        dictgen::InsensitiveStr::Ascii("enting"),
        dictgen::InsensitiveStr::Ascii("ents"),
        dictgen::InsensitiveStr::Ascii("et"),
        dictgen::InsensitiveStr::Ascii("ets"),
        dictgen::InsensitiveStr::Ascii("it"),
        dictgen::InsensitiveStr::Ascii("ited"),
        dictgen::InsensitiveStr::Ascii("iting"),
        dictgen::InsensitiveStr::Ascii("its"),
        dictgen::InsensitiveStr::Ascii("itted"),
        dictgen::InsensitiveStr::Ascii("itter"),
        dictgen::InsensitiveStr::Ascii("itters"),
        dictgen::InsensitiveStr::Ascii("itting"),
        dictgen::InsensitiveStr::Ascii("on"),
        dictgen::InsensitiveStr::Ascii("unicate"),
        dictgen::InsensitiveStr::Ascii("unicated"),
        dictgen::InsensitiveStr::Ascii("unicates"),
        dictgen::InsensitiveStr::Ascii("unicating"),
        dictgen::InsensitiveStr::Ascii("unication"),
        dictgen::InsensitiveStr::Ascii("unity"),
    ],
    values: &[
        &["comma"],
        &["command"],
        &["commandline"],
        &["commands"],
        &["commemorated"],
        &["comment"],
        &["commented"],
        &["commenting"],
        &["comments"],
        &["comment"],
        &["comments"],
        &["commit"],
        &["committed"],
        &["committing"],
        &["commits"],
        &["committed"],
        &["committer"],
        &["committers"],
        &["committing"],
        &["common"],
        &["communicate"],
        &["communicated"],
        &["communicates"],
        &["communicating"],
        &["communication"],
        &["community"],
    ],
    range: 1..=9,
};

static WORD_COMMI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COMMI_CHILDREN),
    value: None,
};

pub static WORD_COMMI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("est"),
        dictgen::InsensitiveStr::Ascii("g"),
        dictgen::InsensitiveStr::Ascii("ng"),
        dictgen::InsensitiveStr::Ascii("nicate"),
        dictgen::InsensitiveStr::Ascii("nicated"),
        dictgen::InsensitiveStr::Ascii("nication"),
        dictgen::InsensitiveStr::Ascii("nism"),
        dictgen::InsensitiveStr::Ascii("nist"),
        dictgen::InsensitiveStr::Ascii("nists"),
        dictgen::InsensitiveStr::Ascii("nity"),
        dictgen::InsensitiveStr::Ascii("nucate"),
        dictgen::InsensitiveStr::Ascii("nucating"),
        dictgen::InsensitiveStr::Ascii("nucation"),
        dictgen::InsensitiveStr::Ascii("shioned"),
        dictgen::InsensitiveStr::Ascii("shioner"),
        dictgen::InsensitiveStr::Ascii("sion"),
        dictgen::InsensitiveStr::Ascii("sioned"),
        dictgen::InsensitiveStr::Ascii("sioner"),
        dictgen::InsensitiveStr::Ascii("sioning"),
        dictgen::InsensitiveStr::Ascii("sions"),
        dictgen::InsensitiveStr::Ascii("sison"),
        dictgen::InsensitiveStr::Ascii("ssionar"),
        dictgen::InsensitiveStr::Ascii("ssionees"),
        dictgen::InsensitiveStr::Ascii("ssionned"),
        dictgen::InsensitiveStr::Ascii("ssionner"),
        dictgen::InsensitiveStr::Ascii("ssionor"),
        dictgen::InsensitiveStr::Ascii("ssons"),
        dictgen::InsensitiveStr::Ascii("sssion"),
        dictgen::InsensitiveStr::Ascii("table"),
        dictgen::InsensitiveStr::Ascii("td"),
        dictgen::InsensitiveStr::Ascii("ted"),
        dictgen::InsensitiveStr::Ascii("tee"),
        dictgen::InsensitiveStr::Ascii("teed"),
        dictgen::InsensitiveStr::Ascii("ter"),
        dictgen::InsensitiveStr::Ascii("ters"),
        dictgen::InsensitiveStr::Ascii("tes"),
        dictgen::InsensitiveStr::Ascii("teted"),
        dictgen::InsensitiveStr::Ascii("ti"),
        dictgen::InsensitiveStr::Ascii("tin"),
        dictgen::InsensitiveStr::Ascii("ting"),
        dictgen::InsensitiveStr::Ascii("tmet"),
        dictgen::InsensitiveStr::Ascii("tt"),
        dictgen::InsensitiveStr::Ascii("tte"),
        dictgen::InsensitiveStr::Ascii("tti"),
        dictgen::InsensitiveStr::Ascii("ttis"),
        dictgen::InsensitiveStr::Ascii("ttment"),
        dictgen::InsensitiveStr::Ascii("ttments"),
        dictgen::InsensitiveStr::Ascii("tts"),
        dictgen::InsensitiveStr::Ascii("tty"),
        dictgen::InsensitiveStr::Ascii("tus"),
    ],
    values: &[
        &["commits"],
        &["commit", "coming"],
        &["coming"],
        &["communicate"],
        &["communicated"],
        &["communication"],
        &["communism"],
        &["communist"],
        &["communists"],
        &["community"],
        &["communicate"],
        &["communicating"],
        &["communications", "communication"],
        &["commissioned"],
        &["commissioner"],
        &["commission"],
        &["commissioned"],
        &["commissioner"],
        &["commissioning"],
        &["commissions"],
        &["commissions"],
        &["commissioner"],
        &["commissions"],
        &["commissioned"],
        &["commissioner"],
        &["commissioner"],
        &["commissions"],
        &["commissions"],
        &["committable"],
        &["committed"],
        &["committed"],
        &["committee"],
        &["committed"],
        &["committer"],
        &["committers"],
        &["commits", "committed"],
        &["committed"],
        &["committee", "committing", "commit"],
        &["committing"],
        &["committing"],
        &["commitments"],
        &["commit"],
        &["committee"],
        &["committee"],
        &["committees"],
        &["commitment"],
        &["commitments"],
        &["commits"],
        &["committee"],
        &["commits"],
    ],
    range: 1..=8,
};

static WORD_COMME_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COMME_CHILDREN),
    value: None,
};

pub static WORD_COMME_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cen"),
        dictgen::InsensitiveStr::Ascii("ct"),
        dictgen::InsensitiveStr::Ascii("cted"),
        dictgen::InsensitiveStr::Ascii("cting"),
        dictgen::InsensitiveStr::Ascii("ctivity"),
        dictgen::InsensitiveStr::Ascii("dian"),
        dictgen::InsensitiveStr::Ascii("dians"),
        dictgen::InsensitiveStr::Ascii("dic"),
        dictgen::InsensitiveStr::Ascii("merative"),
        dictgen::InsensitiveStr::Ascii("mmorate"),
        dictgen::InsensitiveStr::Ascii("mmorating"),
        dictgen::InsensitiveStr::Ascii("mters"),
        dictgen::InsensitiveStr::Ascii("n"),
        dictgen::InsensitiveStr::Ascii("ncera"),
        dictgen::InsensitiveStr::Ascii("nciez"),
        dictgen::InsensitiveStr::Ascii("ndment"),
        dictgen::InsensitiveStr::Ascii("ndments"),
        dictgen::InsensitiveStr::Ascii("net"),
        dictgen::InsensitiveStr::Ascii("netd"),
        dictgen::InsensitiveStr::Ascii("neted"),
        dictgen::InsensitiveStr::Ascii("ns"),
        dictgen::InsensitiveStr::Ascii("nse"),
        dictgen::InsensitiveStr::Ascii("nstatus"),
        dictgen::InsensitiveStr::Ascii("ntaar"),
        dictgen::InsensitiveStr::Ascii("ntar"),
        dictgen::InsensitiveStr::Ascii("ntare"),
        dictgen::InsensitiveStr::Ascii("ntarea"),
        dictgen::InsensitiveStr::Ascii("ntaren"),
        dictgen::InsensitiveStr::Ascii("ntars"),
        dictgen::InsensitiveStr::Ascii("ntart"),
        dictgen::InsensitiveStr::Ascii("ntater"),
        dictgen::InsensitiveStr::Ascii("nteers"),
        dictgen::InsensitiveStr::Ascii("nteries"),
        dictgen::InsensitiveStr::Ascii("ntery"),
        dictgen::InsensitiveStr::Ascii("ntes"),
        dictgen::InsensitiveStr::Ascii("ntries"),
        dictgen::InsensitiveStr::Ascii("ntsry"),
        dictgen::InsensitiveStr::Ascii("nty"),
        dictgen::InsensitiveStr::Ascii("nwealth"),
        dictgen::InsensitiveStr::Ascii("rcail"),
        dictgen::InsensitiveStr::Ascii("rcent"),
        dictgen::InsensitiveStr::Ascii("rciales"),
        dictgen::InsensitiveStr::Ascii("rcialy"),
        dictgen::InsensitiveStr::Ascii("rcie"),
        dictgen::InsensitiveStr::Ascii("re"),
        dictgen::InsensitiveStr::Ascii("rical"),
        dictgen::InsensitiveStr::Ascii("rically"),
        dictgen::InsensitiveStr::Ascii("ricals"),
        dictgen::InsensitiveStr::Ascii("ricial"),
        dictgen::InsensitiveStr::Ascii("ricially"),
        dictgen::InsensitiveStr::Ascii("rorative"),
        dictgen::InsensitiveStr::Ascii("ted"),
        dictgen::InsensitiveStr::Ascii("ts"),
    ],
    values: &[
        &["commence"],
        &["connect"],
        &["connected"],
        &["connecting"],
        &["connectivity"],
        &["comedian"],
        &["comedians"],
        &["comedic"],
        &["commemorative"],
        &["commemorate"],
        &["commemorating"],
        &["commenters"],
        &["commend", "comment", "common"],
        &["commerce"],
        &["commence"],
        &["commandment"],
        &["commandments"],
        &["comment"],
        &["commented"],
        &["commented"],
        &["comments", "commons"],
        &["commenters"],
        &["commentstatus"],
        &["commentary"],
        &["commentator"],
        &["commenter"],
        &["commenter"],
        &["commenter"],
        &["commenters"],
        &["commentator"],
        &["commentator"],
        &["commenter"],
        &["commenters"],
        &["commentary"],
        &["commenters"],
        &["commenters"],
        &["commenters"],
        &["commentary"],
        &["commonwealth"],
        &["commercials"],
        &["commence"],
        &["commercials"],
        &["commercially"],
        &["commerce"],
        &["commerce"],
        &["commercial"],
        &["commercially"],
        &["commercials"],
        &["commercial"],
        &["commercially"],
        &["commemorative"],
        &["commented", "competed"],
        &["comets", "comments"],
    ],
    range: 1..=9,
};

static WORD_COMMA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COMMA_CHILDREN),
    value: None,
};

pub static WORD_COMMA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("d"),
        dictgen::InsensitiveStr::Ascii("dn"),
        dictgen::InsensitiveStr::Ascii("dnline"),
        dictgen::InsensitiveStr::Ascii("dns"),
        dictgen::InsensitiveStr::Ascii("ds"),
        dictgen::InsensitiveStr::Ascii("n"),
        dictgen::InsensitiveStr::Ascii("ndbox"),
        dictgen::InsensitiveStr::Ascii("ndd"),
        dictgen::InsensitiveStr::Ascii("ndemnts"),
        dictgen::InsensitiveStr::Ascii("ndent"),
        dictgen::InsensitiveStr::Ascii("ndered"),
        dictgen::InsensitiveStr::Ascii("ndes"),
        dictgen::InsensitiveStr::Ascii("ndeur"),
        dictgen::InsensitiveStr::Ascii("ndi"),
        dictgen::InsensitiveStr::Ascii("ndmant"),
        dictgen::InsensitiveStr::Ascii("ndmants"),
        dictgen::InsensitiveStr::Ascii("ndmends"),
        dictgen::InsensitiveStr::Ascii("ndoes"),
        dictgen::InsensitiveStr::Ascii("ndore"),
        dictgen::InsensitiveStr::Ascii("ndpod"),
        dictgen::InsensitiveStr::Ascii("nists"),
        dictgen::InsensitiveStr::Ascii("nnd"),
        dictgen::InsensitiveStr::Ascii("no"),
        dictgen::InsensitiveStr::Ascii("ns"),
        dictgen::InsensitiveStr::Ascii("nsd"),
        dictgen::InsensitiveStr::Ascii("nt"),
        dictgen::InsensitiveStr::Ascii("ntator"),
        dictgen::InsensitiveStr::Ascii("nted"),
        dictgen::InsensitiveStr::Ascii("nts"),
        dictgen::InsensitiveStr::Ascii("tas"),
    ],
    values: &[
        &["command"],
        &["command"],
        &["commandline"],
        &["commands"],
        &["commands"],
        &["command", "common", "comma", "commas"],
        &["commando"],
        &["commanded"],
        &["commandment"],
        &["commandment"],
        &["commanded"],
        &["commands"],
        &["commanders"],
        &["command"],
        &["commandment"],
        &["commandments"],
        &["commandments"],
        &["commandos"],
        &["commanders"],
        &["commando"],
        &["communists"],
        &["command"],
        &["commando"],
        &["commands"],
        &["commands"],
        &["command", "comment"],
        &["commentator"],
        &["commanded", "commented"],
        &["commands", "comments"],
        &["commas", "commata"],
    ],
    range: 1..=7,
};

static WORD_COML_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COML_CHILDREN),
    value: None,
};

pub static WORD_COML_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ain"),
        dictgen::InsensitiveStr::Ascii("ained"),
        dictgen::InsensitiveStr::Ascii("ainer"),
        dictgen::InsensitiveStr::Ascii("aining"),
        dictgen::InsensitiveStr::Ascii("ains"),
        dictgen::InsensitiveStr::Ascii("aint"),
        dictgen::InsensitiveStr::Ascii("aints"),
        dictgen::InsensitiveStr::Ascii("ete"),
        dictgen::InsensitiveStr::Ascii("eted"),
        dictgen::InsensitiveStr::Ascii("etely"),
        dictgen::InsensitiveStr::Ascii("etion"),
        dictgen::InsensitiveStr::Ascii("etly"),
        dictgen::InsensitiveStr::Ascii("ex"),
        dictgen::InsensitiveStr::Ascii("exity"),
        dictgen::InsensitiveStr::Ascii("peter"),
        dictgen::InsensitiveStr::Ascii("pex"),
    ],
    values: &[
        &["complain"],
        &["complained"],
        &["complainer"],
        &["complaining"],
        &["complains"],
        &["complaint"],
        &["complaints"],
        &["complete"],
        &["completed"],
        &["completely"],
        &["completion"],
        &["completely"],
        &["complex"],
        &["complexity"],
        &["completer"],
        &["complex"],
    ],
    range: 2..=6,
};

static WORD_COMI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COMI_CHILDREN),
    value: None,
};

pub static WORD_COMI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("led"),
        dictgen::InsensitiveStr::Ascii("ler"),
        dictgen::InsensitiveStr::Ascii("lers"),
        dictgen::InsensitiveStr::Ascii("nation"),
        dictgen::InsensitiveStr::Ascii("pler"),
        dictgen::InsensitiveStr::Ascii("plers"),
        dictgen::InsensitiveStr::Ascii("sion"),
        dictgen::InsensitiveStr::Ascii("sioned"),
        dictgen::InsensitiveStr::Ascii("sioner"),
        dictgen::InsensitiveStr::Ascii("sioning"),
        dictgen::InsensitiveStr::Ascii("sions"),
        dictgen::InsensitiveStr::Ascii("ssion"),
        dictgen::InsensitiveStr::Ascii("ssioned"),
        dictgen::InsensitiveStr::Ascii("ssioner"),
        dictgen::InsensitiveStr::Ascii("ssioning"),
        dictgen::InsensitiveStr::Ascii("ssions"),
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("ted"),
        dictgen::InsensitiveStr::Ascii("tee"),
        dictgen::InsensitiveStr::Ascii("ting"),
        dictgen::InsensitiveStr::Ascii("tish"),
        dictgen::InsensitiveStr::Ascii("ts"),
        dictgen::InsensitiveStr::Ascii("tte"),
        dictgen::InsensitiveStr::Ascii("tted"),
        dictgen::InsensitiveStr::Ascii("ttee"),
        dictgen::InsensitiveStr::Ascii("ttees"),
        dictgen::InsensitiveStr::Ascii("tter"),
        dictgen::InsensitiveStr::Ascii("tters"),
        dictgen::InsensitiveStr::Ascii("tting"),
        dictgen::InsensitiveStr::Ascii("ttish"),
    ],
    values: &[
        &["compiled"],
        &["compiler"],
        &["compilers"],
        &["combination"],
        &["compiler"],
        &["compilers"],
        &["commission"],
        &["commissioned"],
        &["commissioner"],
        &["commissioning"],
        &["commissions"],
        &["commission"],
        &["commissioned"],
        &["commissioner"],
        &["commissioning"],
        &["commissions"],
        &["commit"],
        &["committed"],
        &["committee"],
        &["committing"],
        &["commitish"],
        &["commits"],
        &["committed", "committee"],
        &["committed"],
        &["committee"],
        &["committees"],
        &["committer"],
        &["committers"],
        &["committing"],
        &["committish"],
    ],
    range: 1..=8,
};

static WORD_COMF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COMF_CHILDREN),
    value: None,
};

pub static WORD_COMF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ertable"),
        dictgen::InsensitiveStr::Ascii("ertably"),
        dictgen::InsensitiveStr::Ascii("erting"),
        dictgen::InsensitiveStr::Ascii("irm"),
        dictgen::InsensitiveStr::Ascii("irmation"),
        dictgen::InsensitiveStr::Ascii("licting"),
        dictgen::InsensitiveStr::Ascii("ormance"),
        dictgen::InsensitiveStr::Ascii("orming"),
        dictgen::InsensitiveStr::Ascii("ortabel"),
        dictgen::InsensitiveStr::Ascii("ortabil"),
        dictgen::InsensitiveStr::Ascii("ortablely"),
        dictgen::InsensitiveStr::Ascii("ortabley"),
        dictgen::InsensitiveStr::Ascii("ortablity"),
        dictgen::InsensitiveStr::Ascii("ortablly"),
        dictgen::InsensitiveStr::Ascii("ortbly"),
        dictgen::InsensitiveStr::Ascii("rontation"),
        dictgen::InsensitiveStr::Ascii("rontational"),
        dictgen::InsensitiveStr::Ascii("rotable"),
        dictgen::InsensitiveStr::Ascii("terble"),
        dictgen::InsensitiveStr::Ascii("terbly"),
        dictgen::InsensitiveStr::Ascii("torable"),
        dictgen::InsensitiveStr::Ascii("torably"),
    ],
    values: &[
        &["comfortable"],
        &["comfortably"],
        &["comforting"],
        &["confirm"],
        &["confirmation"],
        &["conflicting"],
        &["conformance"],
        &["comforting"],
        &["comfortably"],
        &["comfortably"],
        &["comfortably"],
        &["comfortably"],
        &["comfortably"],
        &["comfortably"],
        &["comfortably"],
        &["confrontation"],
        &["confrontational"],
        &["comfortable"],
        &["comfortable"],
        &["comfortably"],
        &["comfortable"],
        &["comfortably"],
    ],
    range: 3..=11,
};

static WORD_COME_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COME_CHILDREN),
    value: None,
};

pub static WORD_COME_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ct"),
        dictgen::InsensitiveStr::Ascii("cted"),
        dictgen::InsensitiveStr::Ascii("cting"),
        dictgen::InsensitiveStr::Ascii("ctivity"),
        dictgen::InsensitiveStr::Ascii("diac"),
        dictgen::InsensitiveStr::Ascii("diantes"),
        dictgen::InsensitiveStr::Ascii("diants"),
        dictgen::InsensitiveStr::Ascii("dias"),
        dictgen::InsensitiveStr::Ascii("dlib"),
        dictgen::InsensitiveStr::Ascii("mmorates"),
        dictgen::InsensitiveStr::Ascii("moretion"),
        dictgen::InsensitiveStr::Ascii("nt"),
        dictgen::InsensitiveStr::Ascii("nted"),
        dictgen::InsensitiveStr::Ascii("nting"),
        dictgen::InsensitiveStr::Ascii("nts"),
        dictgen::InsensitiveStr::Ascii("pndium"),
        dictgen::InsensitiveStr::Ascii("ptition"),
        dictgen::InsensitiveStr::Ascii("ptitions"),
        dictgen::InsensitiveStr::Ascii("ptitive"),
        dictgen::InsensitiveStr::Ascii("ptitively"),
        dictgen::InsensitiveStr::Ascii("ptitors"),
        dictgen::InsensitiveStr::Ascii("rant"),
        dictgen::InsensitiveStr::Ascii("rants"),
        dictgen::InsensitiveStr::Ascii("stic"),
        dictgen::InsensitiveStr::Ascii("stics"),
        dictgen::InsensitiveStr::Ascii("ted"),
    ],
    values: &[
        &["connect"],
        &["connected"],
        &["connecting"],
        &["connectivity"],
        &["comedic"],
        &["comedians"],
        &["comedians"],
        &["comedians"],
        &["comedilib"],
        &["commemorates"],
        &["commemoration"],
        &["comment"],
        &["commented"],
        &["commenting"],
        &["comments"],
        &["compendium"],
        &["competition"],
        &["competitions"],
        &["competitive"],
        &["competitively"],
        &["competitors"],
        &["cormorant"],
        &["cormorants"],
        &["cosmetic"],
        &["cosmetics"],
        &["commented", "competed"],
    ],
    range: 2..=9,
};

static WORD_COMD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COMD_CHILDREN),
    value: None,
};

pub static WORD_COMD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eic"),
        dictgen::InsensitiveStr::Ascii("emnation"),
    ],
    values: &[&["comedic"], &["condemnation"]],
    range: 3..=8,
};

static WORD_COMC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COMC_CHILDREN),
    value: None,
};

pub static WORD_COMC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("eptually")],
    values: &[&["conceptually"]],
    range: 8..=8,
};

static WORD_COMB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COMB_CHILDREN),
    value: None,
};

pub static WORD_COMB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ack"),
        dictgen::InsensitiveStr::Ascii("ained"),
        dictgen::InsensitiveStr::Ascii("anations"),
        dictgen::InsensitiveStr::Ascii("atabts"),
        dictgen::InsensitiveStr::Ascii("atans"),
        dictgen::InsensitiveStr::Ascii("atents"),
        dictgen::InsensitiveStr::Ascii("atibility"),
        dictgen::InsensitiveStr::Ascii("atible"),
        dictgen::InsensitiveStr::Ascii("iantion"),
        dictgen::InsensitiveStr::Ascii("iation"),
        dictgen::InsensitiveStr::Ascii("iations"),
        dictgen::InsensitiveStr::Ascii("iens"),
        dictgen::InsensitiveStr::Ascii("inacion"),
        dictgen::InsensitiveStr::Ascii("inaison"),
        dictgen::InsensitiveStr::Ascii("inaiton"),
        dictgen::InsensitiveStr::Ascii("inate"),
        dictgen::InsensitiveStr::Ascii("inateion"),
        dictgen::InsensitiveStr::Ascii("inateions"),
        dictgen::InsensitiveStr::Ascii("inatin"),
        dictgen::InsensitiveStr::Ascii("inatino"),
        dictgen::InsensitiveStr::Ascii("inatins"),
        dictgen::InsensitiveStr::Ascii("inatio"),
        dictgen::InsensitiveStr::Ascii("inatios"),
        dictgen::InsensitiveStr::Ascii("inato"),
        dictgen::InsensitiveStr::Ascii("inaton"),
        dictgen::InsensitiveStr::Ascii("inatorical"),
        dictgen::InsensitiveStr::Ascii("inbe"),
        dictgen::InsensitiveStr::Ascii("ind"),
        dictgen::InsensitiveStr::Ascii("inded"),
        dictgen::InsensitiveStr::Ascii("iniation"),
        dictgen::InsensitiveStr::Ascii("iniations"),
        dictgen::InsensitiveStr::Ascii("inig"),
        dictgen::InsensitiveStr::Ascii("inine"),
        dictgen::InsensitiveStr::Ascii("inining"),
        dictgen::InsensitiveStr::Ascii("ins"),
        dictgen::InsensitiveStr::Ascii("intaion"),
        dictgen::InsensitiveStr::Ascii("intaions"),
        dictgen::InsensitiveStr::Ascii("intion"),
        dictgen::InsensitiveStr::Ascii("nation"),
        dictgen::InsensitiveStr::Ascii("onation"),
        dictgen::InsensitiveStr::Ascii("onations"),
        dictgen::InsensitiveStr::Ascii("usion"),
    ],
    values: &[
        &["comeback"],
        &["combined"],
        &["combinations"],
        &["combatants"],
        &["combatants"],
        &["combatants"],
        &["compatibility"],
        &["compatible"],
        &["combinations", "combination"],
        &["combination"],
        &["combinations"],
        &["combines"],
        &["combination"],
        &["combinations"],
        &["combinations"],
        &["combine"],
        &["combination"],
        &["combinations"],
        &["combinations"],
        &["combinations"],
        &["combinations"],
        &["combination"],
        &["combinations"],
        &["combination"],
        &["combination"],
        &["combinatorial"],
        &["combined"],
        &["combined"],
        &["combined"],
        &["combination"],
        &["combinations"],
        &["combining"],
        &["combine"],
        &["combining"],
        &["combines"],
        &["combination"],
        &["combinations"],
        &["combination"],
        &["combination"],
        &["combination"],
        &["combinations"],
        &["combustion"],
    ],
    range: 3..=10,
};

static WORD_COMA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COMA_CHILDREN),
    value: None,
};

pub static WORD_COMA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("dres"),
        dictgen::InsensitiveStr::Ascii("mmand"),
        dictgen::InsensitiveStr::Ascii("mnd"),
        dictgen::InsensitiveStr::Ascii("mnded"),
        dictgen::InsensitiveStr::Ascii("mnding"),
        dictgen::InsensitiveStr::Ascii("mndline"),
        dictgen::InsensitiveStr::Ascii("mnds"),
        dictgen::InsensitiveStr::Ascii("nd"),
        dictgen::InsensitiveStr::Ascii("nded"),
        dictgen::InsensitiveStr::Ascii("nder"),
        dictgen::InsensitiveStr::Ascii("nding"),
        dictgen::InsensitiveStr::Ascii("ndline"),
        dictgen::InsensitiveStr::Ascii("ndo"),
        dictgen::InsensitiveStr::Ascii("ndos"),
        dictgen::InsensitiveStr::Ascii("nds"),
        dictgen::InsensitiveStr::Ascii("ny"),
        dictgen::InsensitiveStr::Ascii("pany"),
        dictgen::InsensitiveStr::Ascii("pare"),
        dictgen::InsensitiveStr::Ascii("pared"),
        dictgen::InsensitiveStr::Ascii("patibility"),
        dictgen::InsensitiveStr::Ascii("patible"),
        dictgen::InsensitiveStr::Ascii("pletion"),
        dictgen::InsensitiveStr::Ascii("pnies"),
        dictgen::InsensitiveStr::Ascii("pnions"),
        dictgen::InsensitiveStr::Ascii("pny"),
        dictgen::InsensitiveStr::Ascii("prable"),
        dictgen::InsensitiveStr::Ascii("pre"),
        dictgen::InsensitiveStr::Ascii("pres"),
        dictgen::InsensitiveStr::Ascii("pring"),
        dictgen::InsensitiveStr::Ascii("prison"),
        dictgen::InsensitiveStr::Ascii("prisons"),
        dictgen::InsensitiveStr::Ascii("pt"),
        dictgen::InsensitiveStr::Ascii("ptibele"),
        dictgen::InsensitiveStr::Ascii("ptibelities"),
        dictgen::InsensitiveStr::Ascii("ptibelity"),
        dictgen::InsensitiveStr::Ascii("ptible"),
        dictgen::InsensitiveStr::Ascii("rators"),
        dictgen::InsensitiveStr::Ascii("rde"),
        dictgen::InsensitiveStr::Ascii("tibility"),
        dictgen::InsensitiveStr::Ascii("tible"),
    ],
    values: &[
        &["comrades"],
        &["command"],
        &["command"],
        &["commanded"],
        &["commanding"],
        &["commandline"],
        &["commands"],
        &["command"],
        &["commanded"],
        &["commander", "commandeer"],
        &["commanding"],
        &["commandline"],
        &["commando"],
        &["commandos"],
        &["commands"],
        &["company"],
        &["company"],
        &["compare"],
        &["compared"],
        &["compatibility"],
        &["compatible"],
        &["completion"],
        &["companies"],
        &["companions"],
        &["company"],
        &["comparable"],
        &["compare"],
        &["compares"],
        &["comparing"],
        &["comparison"],
        &["comparisons"],
        &["compat"],
        &["compatible"],
        &["compatibilities"],
        &["compatibility"],
        &["compatible"],
        &["comparators"],
        &["comrade"],
        &["compatibility"],
        &["compatible"],
    ],
    range: 2..=11,
};

static WORD_COL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_COL_CHILDREN),
    value: None,
};

static WORD_COL_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_COLA_NODE),
    None,
    None,
    Some(&WORD_COLD_NODE),
    Some(&WORD_COLE_NODE),
    None,
    Some(&WORD_COLG_NODE),
    None,
    Some(&WORD_COLI_NODE),
    None,
    None,
    Some(&WORD_COLL_NODE),
    Some(&WORD_COLM_NODE),
    None,
    Some(&WORD_COLO_NODE),
    None,
    None,
    None,
    Some(&WORD_COLS_NODE),
    None,
    Some(&WORD_COLU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_COLU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COLU_CHILDREN),
    value: None,
};

pub static WORD_COLU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("bmia"),
        dictgen::InsensitiveStr::Ascii("d"),
        dictgen::InsensitiveStr::Ascii("m"),
        dictgen::InsensitiveStr::Ascii("mbidae"),
        dictgen::InsensitiveStr::Ascii("mbina"),
        dictgen::InsensitiveStr::Ascii("mm"),
        dictgen::InsensitiveStr::Ascii("mmn"),
        dictgen::InsensitiveStr::Ascii("mmns"),
        dictgen::InsensitiveStr::Ascii("mms"),
        dictgen::InsensitiveStr::Ascii("mnas"),
        dictgen::InsensitiveStr::Ascii("mnn"),
        dictgen::InsensitiveStr::Ascii("mnns"),
        dictgen::InsensitiveStr::Ascii("mnss"),
        dictgen::InsensitiveStr::Ascii("mnular"),
        dictgen::InsensitiveStr::Ascii("ms"),
        dictgen::InsensitiveStr::Ascii("msn"),
        dictgen::InsensitiveStr::Ascii("nn"),
        dictgen::InsensitiveStr::Ascii("nns"),
    ],
    values: &[
        &["columbia"],
        &["cloud", "could"],
        &["column"],
        &["columbia"],
        &["columbia"],
        &["column"],
        &["column"],
        &["columns"],
        &["columns"],
        &["columns"],
        &["column"],
        &["columns"],
        &["columns"],
        &["columnar"],
        &["columns"],
        &["columns"],
        &["column", "colon"],
        &["columns"],
    ],
    range: 1..=6,
};

static WORD_COLS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COLS_CHILDREN),
    value: None,
};

pub static WORD_COLS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ed")],
    values: &[&["closed"]],
    range: 2..=2,
};

static WORD_COLO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COLO_CHILDREN),
    value: None,
};

pub static WORD_COLO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ardo"),
        dictgen::InsensitiveStr::Ascii("er"),
        dictgen::InsensitiveStr::Ascii("eration"),
        dictgen::InsensitiveStr::Ascii("ered"),
        dictgen::InsensitiveStr::Ascii("ering"),
        dictgen::InsensitiveStr::Ascii("ers"),
        dictgen::InsensitiveStr::Ascii("ful"),
        dictgen::InsensitiveStr::Ascii("gen"),
        dictgen::InsensitiveStr::Ascii("mba"),
        dictgen::InsensitiveStr::Ascii("mbina"),
        dictgen::InsensitiveStr::Ascii("mn"),
        dictgen::InsensitiveStr::Ascii("mns"),
        dictgen::InsensitiveStr::Ascii("nge"),
        dictgen::InsensitiveStr::Ascii("nialisim"),
        dictgen::InsensitiveStr::Ascii("nializm"),
        dictgen::InsensitiveStr::Ascii("nialsim"),
        dictgen::InsensitiveStr::Ascii("nialsm"),
        dictgen::InsensitiveStr::Ascii("nianism"),
        dictgen::InsensitiveStr::Ascii("nizacion"),
        dictgen::InsensitiveStr::Ascii("nizaton"),
        dictgen::InsensitiveStr::Ascii("nizators"),
        dictgen::InsensitiveStr::Ascii("nozation"),
        dictgen::InsensitiveStr::Ascii("rao"),
        dictgen::InsensitiveStr::Ascii("rblend"),
        dictgen::InsensitiveStr::Ascii("rdao"),
        dictgen::InsensitiveStr::Ascii("rfull"),
        dictgen::InsensitiveStr::Ascii("ringh"),
        dictgen::InsensitiveStr::Ascii("rizoer"),
        dictgen::InsensitiveStr::Ascii("rpsace"),
        dictgen::InsensitiveStr::Ascii("rpsaces"),
        dictgen::InsensitiveStr::Ascii("se"),
        dictgen::InsensitiveStr::Ascii("ublind"),
        dictgen::InsensitiveStr::Ascii("um"),
        dictgen::InsensitiveStr::Ascii("umn"),
        dictgen::InsensitiveStr::Ascii("umns"),
        dictgen::InsensitiveStr::Ascii("ums"),
        dictgen::InsensitiveStr::Ascii("urd"),
        dictgen::InsensitiveStr::Ascii("urfull"),
        dictgen::InsensitiveStr::Ascii("urpsace"),
        dictgen::InsensitiveStr::Ascii("urpsaces"),
    ],
    values: &[
        &["colorado"],
        &["color"],
        &["coloration"],
        &["colored"],
        &["coloring"],
        &["colors"],
        &["colorful"],
        &["cologne"],
        &["colombia"],
        &["colombia"],
        &["column"],
        &["columns"],
        &["cologne"],
        &["colonialism"],
        &["colonialism"],
        &["colonialism"],
        &["colonialism"],
        &["colonialism"],
        &["colonization"],
        &["colonization"],
        &["colonizers"],
        &["colonization"],
        &["colorado"],
        &["colorblind"],
        &["colorado"],
        &["colorful", "colorfully"],
        &["coloring"],
        &["colorizer"],
        &["colorspace"],
        &["colorspaces"],
        &["close"],
        &["colorblind"],
        &["column"],
        &["column"],
        &["columns"],
        &["columns"],
        &["coloured"],
        &["colourful", "colourfully"],
        &["colourspace"],
        &["colourspaces"],
    ],
    range: 2..=8,
};

static WORD_COLM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COLM_CHILDREN),
    value: None,
};

pub static WORD_COLM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("n"),
        dictgen::InsensitiveStr::Ascii("ns"),
        dictgen::InsensitiveStr::Ascii("uned"),
    ],
    values: &[&["column"], &["columns"], &["columned"]],
    range: 1..=4,
};

static WORD_COLL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_COLL_CHILDREN),
    value: None,
};

static WORD_COLL_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_COLLA_NODE),
    Some(&WORD_COLLB_NODE),
    Some(&WORD_COLLC_NODE),
    None,
    Some(&WORD_COLLE_NODE),
    None,
    None,
    None,
    Some(&WORD_COLLI_NODE),
    None,
    None,
    Some(&WORD_COLLL_NODE),
    None,
    None,
    Some(&WORD_COLLO_NODE),
    Some(&WORD_COLLP_NODE),
    None,
    None,
    Some(&WORD_COLLS_NODE),
    None,
    Some(&WORD_COLLU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_COLLU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COLLU_CHILDREN),
    value: None,
};

pub static WORD_COLLU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("mn"),
        dictgen::InsensitiveStr::Ascii("mns"),
    ],
    values: &[&["column"], &["columns"]],
    range: 2..=3,
};

static WORD_COLLS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COLLS_CHILDREN),
    value: None,
};

pub static WORD_COLLS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ion"),
        dictgen::InsensitiveStr::Ascii("ions"),
    ],
    values: &[&["collision"], &["collisions"]],
    range: 3..=4,
};

static WORD_COLLP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COLLP_CHILDREN),
    value: None,
};

pub static WORD_COLLP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ase"),
        dictgen::InsensitiveStr::Ascii("ased"),
        dictgen::InsensitiveStr::Ascii("ases"),
        dictgen::InsensitiveStr::Ascii("asing"),
    ],
    values: &[
        &["collapse"],
        &["collapsed"],
        &["collapses"],
        &["collapsing"],
    ],
    range: 3..=5,
};

static WORD_COLLO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COLLO_CHILDREN),
    value: None,
};

pub static WORD_COLLO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("barate"),
        dictgen::InsensitiveStr::Ascii("baration"),
        dictgen::InsensitiveStr::Ascii("borate"),
        dictgen::InsensitiveStr::Ascii("calized"),
        dictgen::InsensitiveStr::Ascii("cweall"),
        dictgen::InsensitiveStr::Ascii("cweally"),
        dictgen::InsensitiveStr::Ascii("nade"),
        dictgen::InsensitiveStr::Ascii("ne"),
        dictgen::InsensitiveStr::Ascii("nies"),
        dictgen::InsensitiveStr::Ascii("ny"),
        dictgen::InsensitiveStr::Ascii("qiual"),
        dictgen::InsensitiveStr::Ascii("quail"),
        dictgen::InsensitiveStr::Ascii("queal"),
        dictgen::InsensitiveStr::Ascii("rscheme"),
        dictgen::InsensitiveStr::Ascii("sal"),
    ],
    values: &[
        &["collaborate"],
        &["collaboration"],
        &["collaborate"],
        &["colocalized"],
        &["colloquial"],
        &["colloquially"],
        &["colonnade"],
        &["cologne"],
        &["colonies"],
        &["colony"],
        &["colloquial"],
        &["colloquial"],
        &["colloquial"],
        &["colorscheme"],
        &["colossal"],
    ],
    range: 2..=8,
};

static WORD_COLLL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COLLL_CHILDREN),
    value: None,
};

pub static WORD_COLLL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("apses")],
    values: &[&["collapses"]],
    range: 5..=5,
};

static WORD_COLLI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COLLI_CHILDREN),
    value: None,
};

pub static WORD_COLLI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("dies"),
        dictgen::InsensitiveStr::Ascii("quial"),
        dictgen::InsensitiveStr::Ascii("sin"),
        dictgen::InsensitiveStr::Ascii("sins"),
        dictgen::InsensitiveStr::Ascii("son"),
        dictgen::InsensitiveStr::Ascii("sons"),
        dictgen::InsensitiveStr::Ascii("ssion"),
        dictgen::InsensitiveStr::Ascii("ssions"),
        dictgen::InsensitiveStr::Ascii("sson"),
        dictgen::InsensitiveStr::Ascii("stion"),
        dictgen::InsensitiveStr::Ascii("stions"),
        dictgen::InsensitiveStr::Ascii("tions"),
    ],
    values: &[
        &["collides"],
        &["colloquial"],
        &["collisions", "collision", "collusion"],
        &["collisions", "collusions"],
        &["collision", "collusion"],
        &["collisions", "collusion", "collusions"],
        &["collisions", "collision", "collusion"],
        &["collisions"],
        &["collisions"],
        &["collision"],
        &["collisions"],
        &["collisions"],
    ],
    range: 3..=6,
};

static WORD_COLLE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COLLE_CHILDREN),
    value: None,
};

pub static WORD_COLLE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("age"),
        dictgen::InsensitiveStr::Ascii("ages"),
        dictgen::InsensitiveStr::Ascii("auge"),
        dictgen::InsensitiveStr::Ascii("auges"),
        dictgen::InsensitiveStr::Ascii("cing"),
        dictgen::InsensitiveStr::Ascii("cion"),
        dictgen::InsensitiveStr::Ascii("cions"),
        dictgen::InsensitiveStr::Ascii("citon"),
        dictgen::InsensitiveStr::Ascii("citons"),
        dictgen::InsensitiveStr::Ascii("cte"),
        dictgen::InsensitiveStr::Ascii("ctems"),
        dictgen::InsensitiveStr::Ascii("ctes"),
        dictgen::InsensitiveStr::Ascii("ctie"),
        dictgen::InsensitiveStr::Ascii("ctief"),
        dictgen::InsensitiveStr::Ascii("cties"),
        dictgen::InsensitiveStr::Ascii("ctieve"),
        dictgen::InsensitiveStr::Ascii("ctifs"),
        dictgen::InsensitiveStr::Ascii("ctin"),
        dictgen::InsensitiveStr::Ascii("ctioners"),
        dictgen::InsensitiveStr::Ascii("ctivelly"),
        dictgen::InsensitiveStr::Ascii("ctivily"),
        dictgen::InsensitiveStr::Ascii("ctivley"),
        dictgen::InsensitiveStr::Ascii("ctivly"),
        dictgen::InsensitiveStr::Ascii("ctivo"),
        dictgen::InsensitiveStr::Ascii("ctivos"),
        dictgen::InsensitiveStr::Ascii("ctoin"),
        dictgen::InsensitiveStr::Ascii("cton"),
        dictgen::InsensitiveStr::Ascii("ctons"),
        dictgen::InsensitiveStr::Ascii("ctos"),
        dictgen::InsensitiveStr::Ascii("ctros"),
        dictgen::InsensitiveStr::Ascii("ection"),
        dictgen::InsensitiveStr::Ascii("gate"),
        dictgen::InsensitiveStr::Ascii("gaue"),
        dictgen::InsensitiveStr::Ascii("gaues"),
        dictgen::InsensitiveStr::Ascii("gue"),
        dictgen::InsensitiveStr::Ascii("gues"),
        dictgen::InsensitiveStr::Ascii("ktion"),
        dictgen::InsensitiveStr::Ascii("nder"),
        dictgen::InsensitiveStr::Ascii("nders"),
        dictgen::InsensitiveStr::Ascii("quial"),
        dictgen::InsensitiveStr::Ascii("st"),
        dictgen::InsensitiveStr::Ascii("teral"),
        dictgen::InsensitiveStr::Ascii("tion"),
    ],
    values: &[
        &["colleagues", "colleague"],
        &["colleagues"],
        &["colleague"],
        &["colleagues"],
        &["collecting"],
        &["collection"],
        &["collections"],
        &["collection"],
        &["collections"],
        &["collective"],
        &["collects"],
        &["collects"],
        &["collective"],
        &["collective"],
        &["collects"],
        &["collective"],
        &["collects"],
        &["collection"],
        &["collections"],
        &["collectively"],
        &["collectively"],
        &["collectively"],
        &["collectively"],
        &["collection"],
        &["collections"],
        &["collections"],
        &["collection"],
        &["collections"],
        &["collectors"],
        &["collects"],
        &["collection"],
        &["collegiate"],
        &["colleague"],
        &["colleagues"],
        &["colleague"],
        &["colleagues"],
        &["collection"],
        &["cullender"],
        &["cullenders"],
        &["colloquial"],
        &["collects"],
        &["collateral"],
        &["collection"],
    ],
    range: 2..=8,
};

static WORD_COLLC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COLLC_CHILDREN),
    value: None,
};

pub static WORD_COLLC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("etion")],
    values: &[&["collections"]],
    range: 5..=5,
};

static WORD_COLLB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COLLB_CHILDREN),
    value: None,
};

pub static WORD_COLLB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("orative")],
    values: &[&["collaborative"]],
    range: 7..=7,
};

static WORD_COLLA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COLLA_CHILDREN),
    value: None,
};

pub static WORD_COLLA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("barate"),
        dictgen::InsensitiveStr::Ascii("baration"),
        dictgen::InsensitiveStr::Ascii("berate"),
        dictgen::InsensitiveStr::Ascii("beration"),
        dictgen::InsensitiveStr::Ascii("berative"),
        dictgen::InsensitiveStr::Ascii("beratively"),
        dictgen::InsensitiveStr::Ascii("berator"),
        dictgen::InsensitiveStr::Ascii("borant"),
        dictgen::InsensitiveStr::Ascii("borare"),
        dictgen::InsensitiveStr::Ascii("boratie"),
        dictgen::InsensitiveStr::Ascii("boratin"),
        dictgen::InsensitiveStr::Ascii("borato"),
        dictgen::InsensitiveStr::Ascii("boratore"),
        dictgen::InsensitiveStr::Ascii("bore"),
        dictgen::InsensitiveStr::Ascii("boritave"),
        dictgen::InsensitiveStr::Ascii("boritavely"),
        dictgen::InsensitiveStr::Ascii("ction"),
        dictgen::InsensitiveStr::Ascii("obrative"),
        dictgen::InsensitiveStr::Ascii("pe"),
        dictgen::InsensitiveStr::Ascii("pes"),
        dictgen::InsensitiveStr::Ascii("ps"),
        dictgen::InsensitiveStr::Ascii("psable"),
        dictgen::InsensitiveStr::Ascii("pseing"),
        dictgen::InsensitiveStr::Ascii("psers"),
        dictgen::InsensitiveStr::Ascii("pted"),
        dictgen::InsensitiveStr::Ascii("quial"),
        dictgen::InsensitiveStr::Ascii("res"),
        dictgen::InsensitiveStr::Ascii("ris"),
        dictgen::InsensitiveStr::Ascii("ros"),
        dictgen::InsensitiveStr::Ascii("sion"),
        dictgen::InsensitiveStr::Ascii("spe"),
        dictgen::InsensitiveStr::Ascii("sped"),
        dictgen::InsensitiveStr::Ascii("spes"),
        dictgen::InsensitiveStr::Ascii("spible"),
        dictgen::InsensitiveStr::Ascii("sping"),
        dictgen::InsensitiveStr::Ascii("taral"),
        dictgen::InsensitiveStr::Ascii("ter"),
        dictgen::InsensitiveStr::Ascii("terial"),
        dictgen::InsensitiveStr::Ascii("terol"),
        dictgen::InsensitiveStr::Ascii("tiong"),
        dictgen::InsensitiveStr::Ascii("toral"),
    ],
    values: &[
        &["collaborate"],
        &["collaboration"],
        &["collaborate"],
        &["collaboration"],
        &["collaborative"],
        &["collaboratively"],
        &["collaborate"],
        &["collaborate"],
        &["collaborate"],
        &["collaborate"],
        &["collaboration"],
        &["collaboration"],
        &["collaborate"],
        &["collaborate"],
        &["collaborative"],
        &["collaboratively"],
        &["collection"],
        &["collaborative"],
        &["collapse"],
        &["collapse"],
        &["collapse"],
        &["collapsible"],
        &["collapsing"],
        &["collapses"],
        &["coapted", "collapse", "collapsed", "collated"],
        &["colloquial"],
        &["collars"],
        &["collars"],
        &["collars"],
        &["collision"],
        &["collapse"],
        &["collapsed"],
        &["collapses"],
        &["collapsible"],
        &["collapsing"],
        &["collateral"],
        &["collator"],
        &["collateral"],
        &["collateral"],
        &["collation"],
        &["collateral"],
    ],
    range: 2..=10,
};

static WORD_COLI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COLI_CHILDREN),
    value: None,
};

pub static WORD_COLI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("de"),
        dictgen::InsensitiveStr::Ascii("sion"),
        dictgen::InsensitiveStr::Ascii("ssion"),
    ],
    values: &[&["collide"], &["collision"], &["collision"]],
    range: 2..=5,
};

static WORD_COLG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COLG_CHILDREN),
    value: None,
};

pub static WORD_COLG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("one")],
    values: &[&["cologne"]],
    range: 3..=3,
};

static WORD_COLE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COLE_CHILDREN),
    value: None,
};

pub static WORD_COLE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ctable"),
        dictgen::InsensitiveStr::Ascii("cted"),
        dictgen::InsensitiveStr::Ascii("cting"),
        dictgen::InsensitiveStr::Ascii("ction"),
        dictgen::InsensitiveStr::Ascii("ctions"),
        dictgen::InsensitiveStr::Ascii("ctive"),
        dictgen::InsensitiveStr::Ascii("ctor"),
        dictgen::InsensitiveStr::Ascii("ctors"),
        dictgen::InsensitiveStr::Ascii("cts"),
        dictgen::InsensitiveStr::Ascii("eg"),
        dictgen::InsensitiveStr::Ascii("eges"),
        dictgen::InsensitiveStr::Ascii("egs"),
        dictgen::InsensitiveStr::Ascii("lction"),
        dictgen::InsensitiveStr::Ascii("lctive"),
        dictgen::InsensitiveStr::Ascii("lctors"),
        dictgen::InsensitiveStr::Ascii("ra"),
        dictgen::InsensitiveStr::Ascii("rscheme"),
        dictgen::InsensitiveStr::Ascii("scing"),
    ],
    values: &[
        &["collectable"],
        &["collected"],
        &["collecting"],
        &["collection"],
        &["collections"],
        &["collective"],
        &["collector"],
        &["collectors"],
        &["collects"],
        &["colleague"],
        &["colleagues"],
        &["colleagues"],
        &["collection"],
        &["collective"],
        &["collectors"],
        &["cholera"],
        &["colorscheme"],
        &["coalescing"],
    ],
    range: 2..=7,
};

static WORD_COLD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COLD_CHILDREN),
    value: None,
};

pub static WORD_COLD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("plg")],
    values: &[&["coldplug"]],
    range: 3..=3,
};

static WORD_COLA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COLA_CHILDREN),
    value: None,
};

pub static WORD_COLA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("boration"),
        dictgen::InsensitiveStr::Ascii("borations"),
        dictgen::InsensitiveStr::Ascii("psed"),
        dictgen::InsensitiveStr::Ascii("teral"),
    ],
    values: &[
        &["collaboration"],
        &["collaborations"],
        &["collapsed"],
        &["collateral"],
    ],
    range: 4..=9,
};

static WORD_COK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COK_CHILDREN),
    value: None,
};

pub static WORD_COK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ies")],
    values: &[&["cookies"]],
    range: 3..=3,
};

static WORD_COI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COI_CHILDREN),
    value: None,
};

pub static WORD_COI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ce"),
        dictgen::InsensitiveStr::Ascii("ncedental"),
        dictgen::InsensitiveStr::Ascii("ncedentally"),
        dictgen::InsensitiveStr::Ascii("ncedince"),
        dictgen::InsensitiveStr::Ascii("ncidance"),
        dictgen::InsensitiveStr::Ascii("ncidencal"),
        dictgen::InsensitiveStr::Ascii("ncidense"),
        dictgen::InsensitiveStr::Ascii("ncidentaly"),
        dictgen::InsensitiveStr::Ascii("ncidente"),
        dictgen::InsensitiveStr::Ascii("ncidentia"),
        dictgen::InsensitiveStr::Ascii("ncidential"),
        dictgen::InsensitiveStr::Ascii("ncidince"),
        dictgen::InsensitiveStr::Ascii("ncidnce"),
        dictgen::InsensitiveStr::Ascii("ndice"),
        dictgen::InsensitiveStr::Ascii("ndidental"),
        dictgen::InsensitiveStr::Ascii("nitailize"),
        dictgen::InsensitiveStr::Ascii("nside"),
        dictgen::InsensitiveStr::Ascii("nsided"),
        dictgen::InsensitiveStr::Ascii("nsidence"),
        dictgen::InsensitiveStr::Ascii("nsident"),
        dictgen::InsensitiveStr::Ascii("nsidental"),
        dictgen::InsensitiveStr::Ascii("nsidentally"),
        dictgen::InsensitiveStr::Ascii("nsides"),
        dictgen::InsensitiveStr::Ascii("nsiding"),
        dictgen::InsensitiveStr::Ascii("ntain"),
        dictgen::InsensitiveStr::Ascii("ntained"),
        dictgen::InsensitiveStr::Ascii("ntaining"),
        dictgen::InsensitiveStr::Ascii("ntains"),
        dictgen::InsensitiveStr::Ascii("nterpoint"),
    ],
    values: &[
        &["choice"],
        &["coincidental"],
        &["coincidentally"],
        &["coincidence"],
        &["coincidence"],
        &["coincidental"],
        &["coincidence"],
        &["coincidentally"],
        &["coincidence"],
        &["coincidental"],
        &["coincidental"],
        &["coincidence"],
        &["coincide"],
        &["coincide"],
        &["coincidental"],
        &["coinitialize"],
        &["coincide"],
        &["coincided"],
        &["coincidence"],
        &["coincident"],
        &["coincidental"],
        &["coincidentally"],
        &["coincides"],
        &["coinciding"],
        &["contain"],
        &["contained"],
        &["containing"],
        &["contains"],
        &["counterpoint"],
    ],
    range: 2..=11,
};

static WORD_COH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COH_CHILDREN),
    value: None,
};

pub static WORD_COH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("abitating"),
        dictgen::InsensitiveStr::Ascii("erance"),
        dictgen::InsensitiveStr::Ascii("erancy"),
        dictgen::InsensitiveStr::Ascii("erant"),
        dictgen::InsensitiveStr::Ascii("erantly"),
        dictgen::InsensitiveStr::Ascii("esie"),
    ],
    values: &[
        &["cohabiting"],
        &["coherence"],
        &["coherency"],
        &["coherent"],
        &["coherently"],
        &["cohesive"],
    ],
    range: 4..=9,
};

static WORD_COG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COG_CHILDREN),
    value: None,
};

pub static WORD_COG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("egen"),
        dictgen::InsensitiveStr::Ascii("natious"),
        dictgen::InsensitiveStr::Ascii("niscent"),
        dictgen::InsensitiveStr::Ascii("nitivie"),
        dictgen::InsensitiveStr::Ascii("nizent"),
    ],
    values: &[
        &["codegen"],
        &["contagious"],
        &["cognisant"],
        &["cognitive"],
        &["cognizant"],
    ],
    range: 4..=7,
};

static WORD_COF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COF_CHILDREN),
    value: None,
};

pub static WORD_COF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eee"),
        dictgen::InsensitiveStr::Ascii("fe"),
        dictgen::InsensitiveStr::Ascii("ficient"),
        dictgen::InsensitiveStr::Ascii("ficients"),
        dictgen::InsensitiveStr::Ascii("idence"),
        dictgen::InsensitiveStr::Ascii("iguration"),
        dictgen::InsensitiveStr::Ascii("igure"),
        dictgen::InsensitiveStr::Ascii("igured"),
        dictgen::InsensitiveStr::Ascii("igures"),
        dictgen::InsensitiveStr::Ascii("iguring"),
        dictgen::InsensitiveStr::Ascii("irm"),
        dictgen::InsensitiveStr::Ascii("irmation"),
        dictgen::InsensitiveStr::Ascii("irmations"),
        dictgen::InsensitiveStr::Ascii("irmed"),
        dictgen::InsensitiveStr::Ascii("irming"),
        dictgen::InsensitiveStr::Ascii("irms"),
        dictgen::InsensitiveStr::Ascii("orm"),
        dictgen::InsensitiveStr::Ascii("rim"),
        dictgen::InsensitiveStr::Ascii("rimation"),
        dictgen::InsensitiveStr::Ascii("rimations"),
        dictgen::InsensitiveStr::Ascii("rimed"),
        dictgen::InsensitiveStr::Ascii("riming"),
        dictgen::InsensitiveStr::Ascii("rims"),
    ],
    values: &[
        &["coffee"],
        &["coffee"],
        &["coefficient"],
        &["coefficients"],
        &["confidence"],
        &["configuration"],
        &["configure"],
        &["configured"],
        &["configures"],
        &["configuring"],
        &["confirm"],
        &["confirmation"],
        &["confirmations"],
        &["confirmed"],
        &["confirming"],
        &["confirms"],
        &["conform"],
        &["confirm"],
        &["confirmation"],
        &["confirmations"],
        &["confirmed"],
        &["confirming"],
        &["confirms"],
    ],
    range: 2..=9,
};

static WORD_COE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COE_CHILDREN),
    value: None,
};

pub static WORD_COE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ffcient"),
        dictgen::InsensitiveStr::Ascii("ffcients"),
        dictgen::InsensitiveStr::Ascii("fficeint"),
        dictgen::InsensitiveStr::Ascii("fficeints"),
        dictgen::InsensitiveStr::Ascii("fficent"),
        dictgen::InsensitiveStr::Ascii("fficents"),
        dictgen::InsensitiveStr::Ascii("fficiant"),
        dictgen::InsensitiveStr::Ascii("fficienct"),
        dictgen::InsensitiveStr::Ascii("fficiens"),
        dictgen::InsensitiveStr::Ascii("fficientss"),
        dictgen::InsensitiveStr::Ascii("ffiecient"),
        dictgen::InsensitiveStr::Ascii("ffiecients"),
        dictgen::InsensitiveStr::Ascii("ffient"),
        dictgen::InsensitiveStr::Ascii("ffients"),
        dictgen::InsensitiveStr::Ascii("ficent"),
        dictgen::InsensitiveStr::Ascii("ficents"),
        dictgen::InsensitiveStr::Ascii("ficient"),
        dictgen::InsensitiveStr::Ascii("ficients"),
        dictgen::InsensitiveStr::Ascii("lesce"),
        dictgen::InsensitiveStr::Ascii("ncidental"),
        dictgen::InsensitiveStr::Ascii("rcable"),
        dictgen::InsensitiveStr::Ascii("rceion"),
        dictgen::InsensitiveStr::Ascii("rsion"),
        dictgen::InsensitiveStr::Ascii("xhist"),
        dictgen::InsensitiveStr::Ascii("xhistance"),
        dictgen::InsensitiveStr::Ascii("xhisted"),
        dictgen::InsensitiveStr::Ascii("xhistence"),
        dictgen::InsensitiveStr::Ascii("xhisting"),
        dictgen::InsensitiveStr::Ascii("xhists"),
        dictgen::InsensitiveStr::Ascii("xinst"),
        dictgen::InsensitiveStr::Ascii("xinstence"),
        dictgen::InsensitiveStr::Ascii("xinsts"),
        dictgen::InsensitiveStr::Ascii("xistance"),
        dictgen::InsensitiveStr::Ascii("xsit"),
        dictgen::InsensitiveStr::Ascii("xsitance"),
        dictgen::InsensitiveStr::Ascii("xsited"),
        dictgen::InsensitiveStr::Ascii("xsitence"),
        dictgen::InsensitiveStr::Ascii("xsiting"),
        dictgen::InsensitiveStr::Ascii("xsits"),
    ],
    values: &[
        &["coefficient"],
        &["coefficients"],
        &["coefficient"],
        &["coefficients"],
        &["coefficient"],
        &["coefficients"],
        &["coefficient"],
        &["coefficient"],
        &["coefficients"],
        &["coefficients"],
        &["coefficient"],
        &["coefficients"],
        &["coefficient"],
        &["coefficients"],
        &["coefficient"],
        &["coefficients"],
        &["coefficient"],
        &["coefficients"],
        &["coalesce"],
        &["coincidental"],
        &["coercible"],
        &["coercion"],
        &["coercion", "conversion"],
        &["coexist"],
        &["coexistence"],
        &["coexisted"],
        &["coexistence"],
        &["coexisting"],
        &["coexists"],
        &["coexist"],
        &["coexistence"],
        &["coexists"],
        &["coexistence"],
        &["coexist"],
        &["coexistence"],
        &["coexisted"],
        &["coexistence"],
        &["coexisting"],
        &["coexists"],
    ],
    range: 4..=10,
};

static WORD_COD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COD_CHILDREN),
    value: None,
};

pub static WORD_COD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("de"),
        dictgen::InsensitiveStr::Ascii("een"),
        dictgen::InsensitiveStr::Ascii("eing"),
        dictgen::InsensitiveStr::Ascii("epoitn"),
        dictgen::InsensitiveStr::Ascii("esbase"),
        dictgen::InsensitiveStr::Ascii("esbases"),
        dictgen::InsensitiveStr::Ascii("esc"),
        dictgen::InsensitiveStr::Ascii("espel"),
        dictgen::InsensitiveStr::Ascii("esream"),
        dictgen::InsensitiveStr::Ascii("gen"),
        dictgen::InsensitiveStr::Ascii("ition"),
        dictgen::InsensitiveStr::Ascii("itioned"),
        dictgen::InsensitiveStr::Ascii("itions"),
        dictgen::InsensitiveStr::Ascii("o"),
        dictgen::InsensitiveStr::Ascii("os"),
        dictgen::InsensitiveStr::Ascii("uct"),
        dictgen::InsensitiveStr::Ascii("ucted"),
        dictgen::InsensitiveStr::Ascii("ucter"),
        dictgen::InsensitiveStr::Ascii("ucting"),
        dictgen::InsensitiveStr::Ascii("uctor"),
        dictgen::InsensitiveStr::Ascii("ucts"),
    ],
    values: &[
        &["code", "coded", "coddle"],
        &["codeine"],
        &["coding"],
        &["codepoint"],
        &["codebase"],
        &["codebases"],
        &["codecs"],
        &["codespell"],
        &["codestream"],
        &["codegen"],
        &["condition"],
        &["conditioned"],
        &["conditions"],
        &["code"],
        &["codes"],
        &["conduct"],
        &["conducted"],
        &["conductor"],
        &["conducting"],
        &["conductor"],
        &["conducts"],
    ],
    range: 1..=7,
};

static WORD_COC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COC_CHILDREN),
    value: None,
};

pub static WORD_COC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cinele"),
        dictgen::InsensitiveStr::Ascii("karoches"),
        dictgen::InsensitiveStr::Ascii("kateel"),
        dictgen::InsensitiveStr::Ascii("kateels"),
        dictgen::InsensitiveStr::Ascii("katils"),
        dictgen::InsensitiveStr::Ascii("kraoches"),
        dictgen::InsensitiveStr::Ascii("kroachers"),
        dictgen::InsensitiveStr::Ascii("kroachs"),
        dictgen::InsensitiveStr::Ascii("kroackes"),
        dictgen::InsensitiveStr::Ascii("kroahes"),
        dictgen::InsensitiveStr::Ascii("ktailers"),
        dictgen::InsensitiveStr::Ascii("ktials"),
        dictgen::InsensitiveStr::Ascii("tail"),
        dictgen::InsensitiveStr::Ascii("ument"),
        dictgen::InsensitiveStr::Ascii("umentation"),
        dictgen::InsensitiveStr::Ascii("uments"),
    ],
    values: &[
        &["coccinelle"],
        &["cockroaches"],
        &["cockatiel"],
        &["cockatiels"],
        &["cocktails"],
        &["cockroaches"],
        &["cockroaches"],
        &["cockroaches"],
        &["cockroaches"],
        &["cockroaches"],
        &["cocktails"],
        &["cocktails"],
        &["cocktail"],
        &["document"],
        &["documentation"],
        &["document"],
    ],
    range: 4..=10,
};

static WORD_COB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COB_CHILDREN),
    value: None,
};

pub static WORD_COB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ining"),
        dictgen::InsensitiveStr::Ascii("vers"),
    ],
    values: &[&["combining"], &["covers"]],
    range: 4..=5,
};

static WORD_COA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_COA_CHILDREN),
    value: None,
};

static WORD_COA_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    Some(&WORD_COAC_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_COAL_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_COAS_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_COAS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COAS_CHILDREN),
    value: None,
};

pub static WORD_COAS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("lescing")],
    values: &[&["coalescing"]],
    range: 7..=7,
};

static WORD_COAL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_COAL_CHILDREN),
    value: None,
};

static WORD_COAL_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_COALA_NODE),
    None,
    Some(&WORD_COALC_NODE),
    None,
    Some(&WORD_COALE_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_COALL_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_COALS_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_COALS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COALS_CHILDREN),
    value: None,
};

pub static WORD_COALS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ce"),
        dictgen::InsensitiveStr::Ascii("cece"),
        dictgen::InsensitiveStr::Ascii("ced"),
        dictgen::InsensitiveStr::Ascii("cence"),
        dictgen::InsensitiveStr::Ascii("cing"),
        dictgen::InsensitiveStr::Ascii("ece"),
        dictgen::InsensitiveStr::Ascii("eced"),
        dictgen::InsensitiveStr::Ascii("ecense"),
        dictgen::InsensitiveStr::Ascii("ence"),
    ],
    values: &[
        &["coalesce"],
        &["coalescence"],
        &["coalesced"],
        &["coalescence"],
        &["coalescing"],
        &["coalescence"],
        &["coalesced"],
        &["coalescence"],
        &["coalescence"],
    ],
    range: 2..=6,
};

static WORD_COALL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COALL_CHILDREN),
    value: None,
};

pub static WORD_COALL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ate"),
        dictgen::InsensitiveStr::Ascii("ates"),
        dictgen::InsensitiveStr::Ascii("ating"),
        dictgen::InsensitiveStr::Ascii("ece"),
        dictgen::InsensitiveStr::Ascii("eced"),
        dictgen::InsensitiveStr::Ascii("ecence"),
        dictgen::InsensitiveStr::Ascii("eces"),
        dictgen::InsensitiveStr::Ascii("ecing"),
        dictgen::InsensitiveStr::Ascii("ee"),
        dictgen::InsensitiveStr::Ascii("eed"),
        dictgen::InsensitiveStr::Ascii("eence"),
        dictgen::InsensitiveStr::Ascii("ees"),
        dictgen::InsensitiveStr::Ascii("eing"),
        dictgen::InsensitiveStr::Ascii("esce"),
        dictgen::InsensitiveStr::Ascii("esced"),
        dictgen::InsensitiveStr::Ascii("esceing"),
        dictgen::InsensitiveStr::Ascii("escence"),
        dictgen::InsensitiveStr::Ascii("esces"),
        dictgen::InsensitiveStr::Ascii("escing"),
        dictgen::InsensitiveStr::Ascii("ese"),
        dictgen::InsensitiveStr::Ascii("esed"),
        dictgen::InsensitiveStr::Ascii("esence"),
        dictgen::InsensitiveStr::Ascii("eses"),
        dictgen::InsensitiveStr::Ascii("esing"),
        dictgen::InsensitiveStr::Ascii("esse"),
        dictgen::InsensitiveStr::Ascii("essed"),
        dictgen::InsensitiveStr::Ascii("essence"),
        dictgen::InsensitiveStr::Ascii("esses"),
        dictgen::InsensitiveStr::Ascii("essing"),
        dictgen::InsensitiveStr::Ascii("ision"),
        dictgen::InsensitiveStr::Ascii("isions"),
        dictgen::InsensitiveStr::Ascii("ition"),
    ],
    values: &[
        &["collate"],
        &["collates"],
        &["collating"],
        &["coalesce"],
        &["coalesced"],
        &["coalescence"],
        &["coalesces"],
        &["coalescing"],
        &["coalesce"],
        &["coalesced"],
        &["coalescence"],
        &["coalesces"],
        &["coalescing"],
        &["coalesce"],
        &["coalesced"],
        &["coalescing"],
        &["coalescence"],
        &["coalesces"],
        &["coalescing"],
        &["coalesce"],
        &["coalesced"],
        &["coalescence"],
        &["coalesces"],
        &["coalescing"],
        &["coalesce"],
        &["coalesced"],
        &["coalescence"],
        &["coalesces"],
        &["coalescing"],
        &["collision"],
        &["collisions"],
        &["coalition", "collation"],
    ],
    range: 2..=7,
};

static WORD_COALE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COALE_CHILDREN),
    value: None,
};

pub static WORD_COALE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("sc"),
        dictgen::InsensitiveStr::Ascii("scsing"),
        dictgen::InsensitiveStr::Ascii("se"),
        dictgen::InsensitiveStr::Ascii("sed"),
        dictgen::InsensitiveStr::Ascii("sence"),
        dictgen::InsensitiveStr::Ascii("ss"),
        dictgen::InsensitiveStr::Ascii("ssed"),
        dictgen::InsensitiveStr::Ascii("ssense"),
        dictgen::InsensitiveStr::Ascii("sses"),
        dictgen::InsensitiveStr::Ascii("ssing"),
    ],
    values: &[
        &["coalesce"],
        &["coalescing"],
        &["coalesce"],
        &["coalesced"],
        &["coalescence"],
        &["coalesce"],
        &["coalesced"],
        &["coalescence"],
        &["coalesces"],
        &["coalescing"],
    ],
    range: 2..=6,
};

static WORD_COALC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COALC_CHILDREN),
    value: None,
};

pub static WORD_COALC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ece"),
        dictgen::InsensitiveStr::Ascii("ence"),
    ],
    values: &[&["coalescence"], &["coalescence"]],
    range: 3..=4,
};

static WORD_COALA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COALA_CHILDREN),
    value: None,
};

pub static WORD_COALA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ce"),
        dictgen::InsensitiveStr::Ascii("cece"),
        dictgen::InsensitiveStr::Ascii("ced"),
        dictgen::InsensitiveStr::Ascii("cence"),
        dictgen::InsensitiveStr::Ascii("cing"),
        dictgen::InsensitiveStr::Ascii("esce"),
        dictgen::InsensitiveStr::Ascii("esced"),
        dictgen::InsensitiveStr::Ascii("escence"),
        dictgen::InsensitiveStr::Ascii("escing"),
        dictgen::InsensitiveStr::Ascii("scece"),
        dictgen::InsensitiveStr::Ascii("scence"),
        dictgen::InsensitiveStr::Ascii("se"),
        dictgen::InsensitiveStr::Ascii("sece"),
        dictgen::InsensitiveStr::Ascii("sed"),
        dictgen::InsensitiveStr::Ascii("sence"),
        dictgen::InsensitiveStr::Ascii("ses"),
        dictgen::InsensitiveStr::Ascii("sing"),
    ],
    values: &[
        &["coalesce"],
        &["coalesce", "coalescence"],
        &["coalesced"],
        &["coalescence"],
        &["coalescing"],
        &["coalesce"],
        &["coalesced"],
        &["coalescence"],
        &["coalescing"],
        &["coalescence"],
        &["coalescence"],
        &["coalesce"],
        &["coalescence"],
        &["coalesced"],
        &["coalescence"],
        &["coalesces"],
        &["coalescing"],
    ],
    range: 2..=7,
};

static WORD_COAC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_COAC_CHILDREN),
    value: None,
};

pub static WORD_COAC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("hig")],
    values: &[&["coaching"]],
    range: 3..=3,
};

static WORD_CN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CN_CHILDREN),
    value: None,
};

pub static WORD_CN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("a"),
        dictgen::InsensitiveStr::Ascii("annel"),
        dictgen::InsensitiveStr::Ascii("figuration"),
        dictgen::InsensitiveStr::Ascii("figure"),
        dictgen::InsensitiveStr::Ascii("figured"),
        dictgen::InsensitiveStr::Ascii("figures"),
        dictgen::InsensitiveStr::Ascii("figuring"),
        dictgen::InsensitiveStr::Ascii("ofiguration"),
        dictgen::InsensitiveStr::Ascii("osole"),
        dictgen::InsensitiveStr::Ascii("osoles"),
        dictgen::InsensitiveStr::Ascii("tain"),
        dictgen::InsensitiveStr::Ascii("tains"),
        dictgen::InsensitiveStr::Ascii("ter"),
    ],
    values: &[
        &["can"],
        &["channel"],
        &["configuration"],
        &["configure"],
        &["configured"],
        &["configures"],
        &["configuring"],
        &["configuration"],
        &["console"],
        &["consoles"],
        &["contain"],
        &["contains"],
        &["center"],
    ],
    range: 1..=11,
};

static WORD_CM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CM_CHILDREN),
    value: None,
};

pub static WORD_CM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ak"),
        dictgen::InsensitiveStr::Ascii("mand"),
        dictgen::InsensitiveStr::Ascii("manded"),
        dictgen::InsensitiveStr::Ascii("manding"),
        dictgen::InsensitiveStr::Ascii("mands"),
        dictgen::InsensitiveStr::Ascii("obination"),
        dictgen::InsensitiveStr::Ascii("oputer"),
        dictgen::InsensitiveStr::Ascii("oputers"),
    ],
    values: &[
        &["cmake"],
        &["command"],
        &["commanded"],
        &["commanding"],
        &["commands"],
        &["combination"],
        &["computer"],
        &["computers"],
    ],
    range: 2..=9,
};

static WORD_CL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_CL_CHILDREN),
    value: None,
};

static WORD_CL_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_CLA_NODE),
    None,
    Some(&WORD_CLC_NODE),
    None,
    Some(&WORD_CLE_NODE),
    None,
    None,
    Some(&WORD_CLH_NODE),
    Some(&WORD_CLI_NODE),
    None,
    None,
    Some(&WORD_CLL_NODE),
    None,
    None,
    Some(&WORD_CLO_NODE),
    None,
    None,
    None,
    Some(&WORD_CLS_NODE),
    None,
    Some(&WORD_CLU_NODE),
    None,
    None,
    None,
    Some(&WORD_CLY_NODE),
    None,
];

static WORD_CLY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CLY_CHILDREN),
    value: None,
};

pub static WORD_CLY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("amore"),
        dictgen::InsensitiveStr::Ascii("inder"),
    ],
    values: &[&["claymore"], &["cylinder"]],
    range: 5..=5,
};

static WORD_CLU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CLU_CHILDREN),
    value: None,
};

pub static WORD_CLU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ase"),
        dictgen::InsensitiveStr::Ascii("ases"),
        dictgen::InsensitiveStr::Ascii("cthing"),
        dictgen::InsensitiveStr::Ascii("de"),
        dictgen::InsensitiveStr::Ascii("mn"),
        dictgen::InsensitiveStr::Ascii("msly"),
        dictgen::InsensitiveStr::Ascii("prit"),
        dictgen::InsensitiveStr::Ascii("ser"),
        dictgen::InsensitiveStr::Ascii("setr"),
        dictgen::InsensitiveStr::Ascii("sterm"),
        dictgen::InsensitiveStr::Ascii("stred"),
        dictgen::InsensitiveStr::Ascii("tchign"),
        dictgen::InsensitiveStr::Ascii("thcing"),
        dictgen::InsensitiveStr::Ascii("tser"),
        dictgen::InsensitiveStr::Ascii("tsers"),
    ],
    values: &[
        &["clause"],
        &["clauses"],
        &["clutching"],
        &["clued", "clue"],
        &["column"],
        &["clumsily"],
        &["culprit"],
        &["cluster"],
        &["cluster"],
        &["cluster"],
        &["clustered"],
        &["clutching"],
        &["clutching"],
        &["cluster", "clutter"],
        &["clusters"],
    ],
    range: 2..=6,
};

static WORD_CLS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CLS_CHILDREN),
    value: None,
};

pub static WORD_CLS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("asified"),
        dictgen::InsensitiveStr::Ascii("oe"),
        dictgen::InsensitiveStr::Ascii("sroom"),
        dictgen::InsensitiveStr::Ascii("srooms"),
    ],
    values: &[&["classified"], &["close"], &["classroom"], &["classrooms"]],
    range: 2..=7,
};

static WORD_CLO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CLO_CHILDREN),
    value: None,
};

pub static WORD_CLO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ack"),
        dictgen::InsensitiveStr::Ascii("acks"),
        dictgen::InsensitiveStr::Ascii("bal"),
        dictgen::InsensitiveStr::Ascii("berring"),
        dictgen::InsensitiveStr::Ascii("cksourc"),
        dictgen::InsensitiveStr::Ascii("des"),
        dictgen::InsensitiveStr::Ascii("ding"),
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("esd"),
        dictgen::InsensitiveStr::Ascii("esed"),
        dictgen::InsensitiveStr::Ascii("esing"),
        dictgen::InsensitiveStr::Ascii("esly"),
        dictgen::InsensitiveStr::Ascii("est"),
        dictgen::InsensitiveStr::Ascii("isonay"),
        dictgen::InsensitiveStr::Ascii("isonays"),
        dictgen::InsensitiveStr::Ascii("nez"),
        dictgen::InsensitiveStr::Ascii("nning"),
        dictgen::InsensitiveStr::Ascii("reen"),
        dictgen::InsensitiveStr::Ascii("ry"),
        dictgen::InsensitiveStr::Ascii("s"),
        dictgen::InsensitiveStr::Ascii("seing"),
        dictgen::InsensitiveStr::Ascii("seley"),
        dictgen::InsensitiveStr::Ascii("sesly"),
        dictgen::InsensitiveStr::Ascii("sests"),
        dictgen::InsensitiveStr::Ascii("sig"),
        dictgen::InsensitiveStr::Ascii("sley"),
        dictgen::InsensitiveStr::Ascii("sly"),
        dictgen::InsensitiveStr::Ascii("ssed"),
        dictgen::InsensitiveStr::Ascii("ssing"),
        dictgen::InsensitiveStr::Ascii("ssion"),
        dictgen::InsensitiveStr::Ascii("ssions"),
        dictgen::InsensitiveStr::Ascii("ude"),
        dictgen::InsensitiveStr::Ascii("udes"),
        dictgen::InsensitiveStr::Ascii("umn"),
        dictgen::InsensitiveStr::Ascii("umns"),
        dictgen::InsensitiveStr::Ascii("ure"),
        dictgen::InsensitiveStr::Ascii("usre"),
    ],
    values: &[
        &["cloak"],
        &["cloaks"],
        &["global"],
        &["clobbering"],
        &["clocksource"],
        &["closed", "clothes"],
        &["closing"],
        &["close"],
        &["closed"],
        &["closed"],
        &["closing"],
        &["closely"],
        &["closest"],
        &["cloisonné"],
        &["cloisonnés"],
        &["clones", "cloner"],
        &["cloning"],
        &["chlorine"],
        &["glory"],
        &["close"],
        &["closing"],
        &["closely"],
        &["closely"],
        &["closest", "closets"],
        &["closing"],
        &["closely"],
        &["closely"],
        &["closed"],
        &["closing"],
        &["collision"],
        &["collisions"],
        &["cloud"],
        &["clouds"],
        &["column"],
        &["columns"],
        &["clojure", "closure"],
        &["closure"],
    ],
    range: 1..=7,
};

static WORD_CLL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CLL_CHILDREN),
    value: None,
};

pub static WORD_CLL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("oud"),
        dictgen::InsensitiveStr::Ascii("ouded"),
        dictgen::InsensitiveStr::Ascii("oudes"),
        dictgen::InsensitiveStr::Ascii("ouding"),
        dictgen::InsensitiveStr::Ascii("ouds"),
    ],
    values: &[
        &["cloud"],
        &["clouded"],
        &["clouds"],
        &["clouding"],
        &["clouds"],
    ],
    range: 3..=6,
};

static WORD_CLI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CLI_CHILDREN),
    value: None,
};

pub static WORD_CLI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("amtes"),
        dictgen::InsensitiveStr::Ascii("antro"),
        dictgen::InsensitiveStr::Ascii("board"),
        dictgen::InsensitiveStr::Ascii("boards"),
        dictgen::InsensitiveStr::Ascii("bpoard"),
        dictgen::InsensitiveStr::Ascii("bpoards"),
        dictgen::InsensitiveStr::Ascii("ckare"),
        dictgen::InsensitiveStr::Ascii("ckbat"),
        dictgen::InsensitiveStr::Ascii("ckear"),
        dictgen::InsensitiveStr::Ascii("en"),
        dictgen::InsensitiveStr::Ascii("ens"),
        dictgen::InsensitiveStr::Ascii("enta"),
        dictgen::InsensitiveStr::Ascii("ente"),
        dictgen::InsensitiveStr::Ascii("entelle"),
        dictgen::InsensitiveStr::Ascii("entes"),
        dictgen::InsensitiveStr::Ascii("ffbanger"),
        dictgen::InsensitiveStr::Ascii("ffhager"),
        dictgen::InsensitiveStr::Ascii("ffhander"),
        dictgen::InsensitiveStr::Ascii("ffhangar"),
        dictgen::InsensitiveStr::Ascii("fthanger"),
        dictgen::InsensitiveStr::Ascii("k"),
        dictgen::InsensitiveStr::Ascii("kcbait"),
        dictgen::InsensitiveStr::Ascii("ks"),
        dictgen::InsensitiveStr::Ascii("mateers"),
        dictgen::InsensitiveStr::Ascii("matiser"),
        dictgen::InsensitiveStr::Ascii("mats"),
        dictgen::InsensitiveStr::Ascii("mbes"),
        dictgen::InsensitiveStr::Ascii("mer"),
        dictgen::InsensitiveStr::Ascii("mers"),
        dictgen::InsensitiveStr::Ascii("ming"),
        dictgen::InsensitiveStr::Ascii("ncial"),
        dictgen::InsensitiveStr::Ascii("ncially"),
        dictgen::InsensitiveStr::Ascii("ncis"),
        dictgen::InsensitiveStr::Ascii("net"),
        dictgen::InsensitiveStr::Ascii("nets"),
        dictgen::InsensitiveStr::Ascii("nicaly"),
        dictgen::InsensitiveStr::Ascii("nicas"),
        dictgen::InsensitiveStr::Ascii("nicos"),
        dictgen::InsensitiveStr::Ascii("pbaord"),
        dictgen::InsensitiveStr::Ascii("pboad"),
        dictgen::InsensitiveStr::Ascii("pboads"),
        dictgen::InsensitiveStr::Ascii("ped"),
        dictgen::InsensitiveStr::Ascii("poard"),
        dictgen::InsensitiveStr::Ascii("poards"),
        dictgen::InsensitiveStr::Ascii("poing"),
        dictgen::InsensitiveStr::Ascii("shay"),
        dictgen::InsensitiveStr::Ascii("shays"),
        dictgen::InsensitiveStr::Ascii("shey"),
        dictgen::InsensitiveStr::Ascii("sheys"),
        dictgen::InsensitiveStr::Ascii("tiros"),
        dictgen::InsensitiveStr::Ascii("toridis"),
        dictgen::InsensitiveStr::Ascii("tories"),
        dictgen::InsensitiveStr::Ascii("torios"),
        dictgen::InsensitiveStr::Ascii("torious"),
        dictgen::InsensitiveStr::Ascii("torius"),
        dictgen::InsensitiveStr::Ascii("tors"),
        dictgen::InsensitiveStr::Ascii("uent"),
        dictgen::InsensitiveStr::Ascii("uents"),
    ],
    values: &[
        &["climates"],
        &["cilantro"],
        &["clipboard"],
        &["clipboards"],
        &["clipboard"],
        &["clipboards"],
        &["clicker"],
        &["clickbait"],
        &["clicker"],
        &["client"],
        &["clients"],
        &["client"],
        &["client", "clientele"],
        &["clientele"],
        &["clients"],
        &["cliffhanger"],
        &["cliffhanger"],
        &["cliffhanger"],
        &["cliffhanger"],
        &["cliffhanger"],
        &["click"],
        &["clickbait"],
        &["clicks"],
        &["climates"],
        &["climates"],
        &["climates"],
        &["climbers"],
        &["climber"],
        &["climbers"],
        &["climbing"],
        &["clinical"],
        &["clinically"],
        &["clinics"],
        &["client"],
        &["clients"],
        &["clinically"],
        &["clinics"],
        &["clinics"],
        &["clipboard"],
        &["clipboard"],
        &["clipboards"],
        &["clipped"],
        &["clipboard"],
        &["clipboards"],
        &["clipping"],
        &["cliché"],
        &["clichés"],
        &["cliché"],
        &["clichés"],
        &["clitoris"],
        &["clitoris"],
        &["clitoris"],
        &["clitoris"],
        &["clitoris"],
        &["clitoris"],
        &["clitoris"],
        &["client"],
        &["clients"],
    ],
    range: 1..=8,
};

static WORD_CLH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CLH_CHILDREN),
    value: None,
};

pub static WORD_CLH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("orine")],
    values: &[&["chlorine"]],
    range: 5..=5,
};

static WORD_CLE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_CLE_CHILDREN),
    value: None,
};

static WORD_CLE_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_CLEA_NODE),
    None,
    Some(&WORD_CLEC_NODE),
    None,
    Some(&WORD_CLEE_NODE),
    Some(&WORD_CLEF_NODE),
    None,
    None,
    Some(&WORD_CLEI_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_CLEN_NODE),
    None,
    None,
    None,
    Some(&WORD_CLER_NODE),
    Some(&WORD_CLES_NODE),
    Some(&WORD_CLET_NODE),
    None,
    Some(&WORD_CLEV_NODE),
    None,
    None,
    None,
    None,
];

static WORD_CLEV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CLEV_CHILDREN),
    value: None,
};

pub static WORD_CLEV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("elry"),
        dictgen::InsensitiveStr::Ascii("ely"),
        dictgen::InsensitiveStr::Ascii("erleys"),
        dictgen::InsensitiveStr::Ascii("ery"),
    ],
    values: &[&["cleverly"], &["cleverly"], &["cleverly"], &["cleverly"]],
    range: 3..=6,
};

static WORD_CLET_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CLET_CHILDREN),
    value: None,
};

pub static WORD_CLET_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ics")],
    values: &[&["celtics"]],
    range: 3..=3,
};

static WORD_CLES_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CLES_CHILDREN),
    value: None,
};

pub static WORD_CLES_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("ius"),
    ],
    values: &[&["close"], &["closes"], &["celsius"]],
    range: 1..=3,
};

static WORD_CLER_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CLER_CHILDREN),
    value: Some(&["clear"]),
};

pub static WORD_CLER_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("a"),
        dictgen::InsensitiveStr::Ascii("ification"),
    ],
    values: &[&["clear", "sclera"], &["clarification"]],
    range: 1..=9,
};

static WORD_CLEN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CLEN_CHILDREN),
    value: Some(&["clan", "clean"]),
};

pub static WORD_CLEN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ase"),
        dictgen::InsensitiveStr::Ascii("aser"),
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("er"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("s"),
    ],
    values: &[
        &["cleanse"],
        &["cleanser"],
        &["clean", "cleaned"],
        &["cleaned"],
        &["cleaner"],
        &["cleaning"],
        &["clans", "cleans"],
    ],
    range: 1..=4,
};

static WORD_CLEI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CLEI_CHILDREN),
    value: None,
};

pub static WORD_CLEI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("nt"),
        dictgen::InsensitiveStr::Ascii("nts"),
    ],
    values: &[&["client"], &["clients"]],
    range: 2..=3,
};

static WORD_CLEF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CLEF_CHILDREN),
    value: None,
};

pub static WORD_CLEF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("f")],
    values: &[&["clef"]],
    range: 1..=1,
};

static WORD_CLEE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CLEE_CHILDREN),
    value: None,
};

pub static WORD_CLEE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("an"),
        dictgen::InsensitiveStr::Ascii("n"),
        dictgen::InsensitiveStr::Ascii("ned"),
        dictgen::InsensitiveStr::Ascii("ns"),
        dictgen::InsensitiveStr::Ascii("shay"),
        dictgen::InsensitiveStr::Ascii("shays"),
        dictgen::InsensitiveStr::Ascii("shey"),
        dictgen::InsensitiveStr::Ascii("sheys"),
    ],
    values: &[
        &["clean"],
        &["clean"],
        &["cleaned"],
        &["cleans"],
        &["cliché"],
        &["clichés"],
        &["cliché"],
        &["clichés"],
    ],
    range: 1..=5,
};

static WORD_CLEC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CLEC_CHILDREN),
    value: None,
};

pub static WORD_CLEC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("k")],
    values: &[&["check"]],
    range: 1..=1,
};

static WORD_CLEA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CLEA_CHILDREN),
    value: Some(&["clean"]),
};

pub static WORD_CLEA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("er"),
        dictgen::InsensitiveStr::Ascii("ered"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("ly"),
        dictgen::InsensitiveStr::Ascii("ncacne"),
        dictgen::InsensitiveStr::Ascii("nd"),
        dictgen::InsensitiveStr::Ascii("nes"),
        dictgen::InsensitiveStr::Ascii("ness"),
        dictgen::InsensitiveStr::Ascii("nies"),
        dictgen::InsensitiveStr::Ascii("nilness"),
        dictgen::InsensitiveStr::Ascii("nisng"),
        dictgen::InsensitiveStr::Ascii("nleness"),
        dictgen::InsensitiveStr::Ascii("nliess"),
        dictgen::InsensitiveStr::Ascii("nlyness"),
        dictgen::InsensitiveStr::Ascii("nning"),
        dictgen::InsensitiveStr::Ascii("nnup"),
        dictgen::InsensitiveStr::Ascii("np"),
        dictgen::InsensitiveStr::Ascii("npu"),
        dictgen::InsensitiveStr::Ascii("npus"),
        dictgen::InsensitiveStr::Ascii("nsiness"),
        dictgen::InsensitiveStr::Ascii("ntup"),
        dictgen::InsensitiveStr::Ascii("re"),
        dictgen::InsensitiveStr::Ascii("reance"),
        dictgen::InsensitiveStr::Ascii("res"),
        dictgen::InsensitiveStr::Ascii("rified"),
        dictgen::InsensitiveStr::Ascii("rifies"),
        dictgen::InsensitiveStr::Ascii("rify"),
        dictgen::InsensitiveStr::Ascii("rifying"),
        dictgen::InsensitiveStr::Ascii("rling"),
        dictgen::InsensitiveStr::Ascii("rnance"),
        dictgen::InsensitiveStr::Ascii("rnances"),
        dictgen::InsensitiveStr::Ascii("rouput"),
        dictgen::InsensitiveStr::Ascii("rstories"),
        dictgen::InsensitiveStr::Ascii("rstory"),
        dictgen::InsensitiveStr::Ascii("rstorys"),
        dictgen::InsensitiveStr::Ascii("rted"),
        dictgen::InsensitiveStr::Ascii("ry"),
        dictgen::InsensitiveStr::Ascii("sne"),
        dictgen::InsensitiveStr::Ascii("sner"),
        dictgen::InsensitiveStr::Ascii("sning"),
        dictgen::InsensitiveStr::Ascii("up"),
        dictgen::InsensitiveStr::Ascii("ups"),
    ],
    values: &[
        &["clear", "clearer", "cleaner"],
        &["cleared"],
        &["cleaning"],
        &["cleanly", "clearly"],
        &["cleancache"],
        &["cleaned", "cleans", "clean"],
        &["cleanse"],
        &["cleanness"],
        &["cleanse"],
        &["cleanliness"],
        &["cleansing"],
        &["cleanliness"],
        &["cleanliness"],
        &["cleanliness"],
        &["cleaning"],
        &["cleanup"],
        &["cleanup"],
        &["cleanup"],
        &["cleanups"],
        &["cleanliness"],
        &["cleanup"],
        &["cleared", "clear"],
        &["clearance"],
        &["clears"],
        &["clarified"],
        &["clarifies"],
        &["clarify"],
        &["clarifying"],
        &["clearing"],
        &["clearance"],
        &["clearances"],
        &["clearoutput"],
        &["clerestories"],
        &["clerestory"],
        &["clerestories"],
        &["cleared"],
        &["clearly"],
        &["cleanse"],
        &["cleanser"],
        &["cleansing"],
        &["cleanup"],
        &["cleanups"],
    ],
    range: 2..=8,
};

static WORD_CLC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CLC_CHILDREN),
    value: None,
};

pub static WORD_CLC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("oksource"),
        dictgen::InsensitiveStr::Ascii("osed"),
    ],
    values: &[&["clocksource"], &["closed"]],
    range: 4..=8,
};

static WORD_CLA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_CLA_CHILDREN),
    value: None,
};

static WORD_CLA_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_CLAA_NODE),
    None,
    Some(&WORD_CLAC_NODE),
    None,
    Some(&WORD_CLAE_NODE),
    None,
    Some(&WORD_CLAG_NODE),
    None,
    Some(&WORD_CLAI_NODE),
    None,
    None,
    None,
    Some(&WORD_CLAM_NODE),
    Some(&WORD_CLAN_NODE),
    None,
    None,
    None,
    Some(&WORD_CLAR_NODE),
    Some(&WORD_CLAS_NODE),
    Some(&WORD_CLAT_NODE),
    Some(&WORD_CLAU_NODE),
    None,
    None,
    None,
    Some(&WORD_CLAY_NODE),
    None,
];

static WORD_CLAY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CLAY_CHILDREN),
    value: None,
};

pub static WORD_CLAY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("mer"),
        dictgen::InsensitiveStr::Ascii("moe"),
    ],
    values: &[&["claymore"], &["claymore"]],
    range: 3..=3,
};

static WORD_CLAU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CLAU_CHILDREN),
    value: None,
};

pub static WORD_CLAU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("s"),
        dictgen::InsensitiveStr::Ascii("sens"),
    ],
    values: &[&["clause"], &["clauses"]],
    range: 1..=4,
};

static WORD_CLAT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CLAT_CHILDREN),
    value: None,
};

pub static WORD_CLAT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ified")],
    values: &[&["clarified"]],
    range: 5..=5,
};

static WORD_CLAS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CLAS_CHILDREN),
    value: Some(&["class"]),
};

pub static WORD_CLAS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("ic"),
        dictgen::InsensitiveStr::Ascii("ical"),
        dictgen::InsensitiveStr::Ascii("ically"),
        dictgen::InsensitiveStr::Ascii("ification"),
        dictgen::InsensitiveStr::Ascii("ified"),
        dictgen::InsensitiveStr::Ascii("ifies"),
        dictgen::InsensitiveStr::Ascii("ify"),
        dictgen::InsensitiveStr::Ascii("ifying"),
        dictgen::InsensitiveStr::Ascii("room"),
        dictgen::InsensitiveStr::Ascii("rooms"),
        dictgen::InsensitiveStr::Ascii("se"),
        dictgen::InsensitiveStr::Ascii("sess"),
        dictgen::InsensitiveStr::Ascii("sesss"),
        dictgen::InsensitiveStr::Ascii("sicals"),
        dictgen::InsensitiveStr::Ascii("sicos"),
        dictgen::InsensitiveStr::Ascii("sicus"),
        dictgen::InsensitiveStr::Ascii("sied"),
        dictgen::InsensitiveStr::Ascii("sifcation"),
        dictgen::InsensitiveStr::Ascii("sifcations"),
        dictgen::InsensitiveStr::Ascii("sifed"),
        dictgen::InsensitiveStr::Ascii("sifer"),
        dictgen::InsensitiveStr::Ascii("sifers"),
        dictgen::InsensitiveStr::Ascii("sificaion"),
        dictgen::InsensitiveStr::Ascii("sificaiton"),
        dictgen::InsensitiveStr::Ascii("sificaitons"),
        dictgen::InsensitiveStr::Ascii("sificato"),
        dictgen::InsensitiveStr::Ascii("sifides"),
        dictgen::InsensitiveStr::Ascii("sifiy"),
        dictgen::InsensitiveStr::Ascii("sis"),
        dictgen::InsensitiveStr::Ascii("srom"),
        dictgen::InsensitiveStr::Ascii("sroms"),
        dictgen::InsensitiveStr::Ascii("srooom"),
        dictgen::InsensitiveStr::Ascii("ss"),
        dictgen::InsensitiveStr::Ascii("sses"),
        dictgen::InsensitiveStr::Ascii("ssic"),
        dictgen::InsensitiveStr::Ascii("ues"),
    ],
    values: &[
        &["cases", "clashes", "classes"],
        &["classic"],
        &["classical"],
        &["classically"],
        &["clarification", "classification"],
        &["classified"],
        &["classifies"],
        &["classify"],
        &["classifying"],
        &["classroom"],
        &["classrooms"],
        &["class", "classes"],
        &["classes"],
        &["classes"],
        &["classics"],
        &["classics"],
        &["classics"],
        &["classified"],
        &["classification"],
        &["classifications"],
        &["classified"],
        &["classifier"],
        &["classifiers"],
        &["classification"],
        &["classification"],
        &["classifications"],
        &["classification"],
        &["classified"],
        &["classify"],
        &["classics"],
        &["classroom"],
        &["classrooms"],
        &["classroom"],
        &["class"],
        &["classes"],
        &["classics"],
        &["clauses"],
    ],
    range: 2..=11,
};

static WORD_CLAR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CLAR_CHILDREN),
    value: None,
};

pub static WORD_CLAR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("avoyant"),
        dictgen::InsensitiveStr::Ascii("avoyantes"),
        dictgen::InsensitiveStr::Ascii("avoyants"),
        dictgen::InsensitiveStr::Ascii("ead"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("ety"),
        dictgen::InsensitiveStr::Ascii("fiy"),
        dictgen::InsensitiveStr::Ascii("ificaiton"),
        dictgen::InsensitiveStr::Ascii("ifiy"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("skon"),
    ],
    values: &[
        &["clairvoyant"],
        &["clairvoyants"],
        &["clairvoyants"],
        &["cleared"],
        &["cleared"],
        &["clarity"],
        &["clarify"],
        &["clarification"],
        &["clarify"],
        &["clearing"],
        &["clarkson"],
    ],
    range: 2..=9,
};

static WORD_CLAN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CLAN_CHILDREN),
    value: None,
};

pub static WORD_CLAN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("and"),
        dictgen::InsensitiveStr::Ascii("nand"),
    ],
    values: &[&["clannad"], &["clannad"]],
    range: 3..=4,
};

static WORD_CLAM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CLAM_CHILDREN),
    value: None,
};

pub static WORD_CLAM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("mer"),
        dictgen::InsensitiveStr::Ascii("pled"),
    ],
    values: &[&["claim"], &["clamber", "clamor"], &["clamped"]],
    range: 1..=4,
};

static WORD_CLAI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CLAI_CHILDREN),
    value: None,
};

pub static WORD_CLAI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("bre"),
        dictgen::InsensitiveStr::Ascii("bscale"),
        dictgen::InsensitiveStr::Ascii("me"),
        dictgen::InsensitiveStr::Ascii("mes"),
        dictgen::InsensitiveStr::Ascii("rfy"),
        dictgen::InsensitiveStr::Ascii("rfying"),
        dictgen::InsensitiveStr::Ascii("rty"),
        dictgen::InsensitiveStr::Ascii("rvoiant"),
        dictgen::InsensitiveStr::Ascii("rvoiantes"),
        dictgen::InsensitiveStr::Ascii("rvoiants"),
    ],
    values: &[
        &["calibre"],
        &["calibscale"],
        &["claim"],
        &["claims"],
        &["clarify"],
        &["clarifying"],
        &["clarity"],
        &["clairvoyant"],
        &["clairvoyants"],
        &["clairvoyants"],
    ],
    range: 2..=9,
};

static WORD_CLAG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CLAG_CHILDREN),
    value: None,
};

pub static WORD_CLAG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ary")],
    values: &[&["calgary"]],
    range: 3..=3,
};

static WORD_CLAE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CLAE_CHILDREN),
    value: None,
};

pub static WORD_CLAE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("r"),
        dictgen::InsensitiveStr::Ascii("rer"),
        dictgen::InsensitiveStr::Ascii("rly"),
    ],
    values: &[&["clear"], &["clearer"], &["clearly"]],
    range: 1..=3,
};

static WORD_CLAC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CLAC_CHILDREN),
    value: None,
};

pub static WORD_CLAC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ium"),
        dictgen::InsensitiveStr::Ascii("ulate"),
        dictgen::InsensitiveStr::Ascii("ulation"),
        dictgen::InsensitiveStr::Ascii("ulations"),
        dictgen::InsensitiveStr::Ascii("ulator"),
        dictgen::InsensitiveStr::Ascii("ulators"),
    ],
    values: &[
        &["calcium"],
        &["calculate"],
        &["calculation"],
        &["calculations"],
        &["calculator"],
        &["calculators"],
    ],
    range: 3..=8,
};

static WORD_CLAA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CLAA_CHILDREN),
    value: None,
};

pub static WORD_CLAA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("es")],
    values: &[&["classes"]],
    range: 2..=2,
};

static WORD_CK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CK_CHILDREN),
    value: None,
};

pub static WORD_CK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eck"),
        dictgen::InsensitiveStr::Ascii("ecksum"),
    ],
    values: &[&["check"], &["checksum"]],
    range: 3..=6,
};

static WORD_CJ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CJ_CHILDREN),
    value: None,
};

pub static WORD_CJ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ange"),
        dictgen::InsensitiveStr::Ascii("anged"),
        dictgen::InsensitiveStr::Ascii("anges"),
        dictgen::InsensitiveStr::Ascii("oice"),
        dictgen::InsensitiveStr::Ascii("oices"),
    ],
    values: &[
        &["change"],
        &["changed"],
        &["changes"],
        &["choice"],
        &["choices"],
    ],
    range: 4..=5,
};

static WORD_CI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_CI_CHILDREN),
    value: None,
};

static WORD_CI_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    Some(&WORD_CIC_NODE),
    None,
    Some(&WORD_CIE_NODE),
    None,
    Some(&WORD_CIG_NODE),
    Some(&WORD_CIH_NODE),
    None,
    None,
    None,
    Some(&WORD_CIL_NODE),
    Some(&WORD_CIM_NODE),
    Some(&WORD_CIN_NODE),
    Some(&WORD_CIO_NODE),
    Some(&WORD_CIP_NODE),
    None,
    Some(&WORD_CIR_NODE),
    None,
    Some(&WORD_CIT_NODE),
    None,
    Some(&WORD_CIV_NODE),
    None,
    None,
    None,
    None,
];

static WORD_CIV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CIV_CHILDREN),
    value: None,
};

pub static WORD_CIV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("alasation"),
        dictgen::InsensitiveStr::Ascii("alasations"),
        dictgen::InsensitiveStr::Ascii("alazation"),
        dictgen::InsensitiveStr::Ascii("alazations"),
        dictgen::InsensitiveStr::Ascii("alesation"),
        dictgen::InsensitiveStr::Ascii("alesations"),
        dictgen::InsensitiveStr::Ascii("alezation"),
        dictgen::InsensitiveStr::Ascii("alezations"),
        dictgen::InsensitiveStr::Ascii("alisation"),
        dictgen::InsensitiveStr::Ascii("alisations"),
        dictgen::InsensitiveStr::Ascii("alization"),
        dictgen::InsensitiveStr::Ascii("alizations"),
        dictgen::InsensitiveStr::Ascii("elesation"),
        dictgen::InsensitiveStr::Ascii("elesations"),
        dictgen::InsensitiveStr::Ascii("elezation"),
        dictgen::InsensitiveStr::Ascii("elezations"),
        dictgen::InsensitiveStr::Ascii("elisation"),
        dictgen::InsensitiveStr::Ascii("elisations"),
        dictgen::InsensitiveStr::Ascii("elization"),
        dictgen::InsensitiveStr::Ascii("elizations"),
        dictgen::InsensitiveStr::Ascii("ilains"),
        dictgen::InsensitiveStr::Ascii("ilasation"),
        dictgen::InsensitiveStr::Ascii("ilasations"),
        dictgen::InsensitiveStr::Ascii("ilazation"),
        dictgen::InsensitiveStr::Ascii("ilazations"),
        dictgen::InsensitiveStr::Ascii("ilesation"),
        dictgen::InsensitiveStr::Ascii("ilesations"),
        dictgen::InsensitiveStr::Ascii("ilezation"),
        dictgen::InsensitiveStr::Ascii("ilezations"),
        dictgen::InsensitiveStr::Ascii("iliaztion"),
        dictgen::InsensitiveStr::Ascii("ilications"),
        dictgen::InsensitiveStr::Ascii("ilizacion"),
        dictgen::InsensitiveStr::Ascii("ilizaiton"),
        dictgen::InsensitiveStr::Ascii("ilizaitons"),
        dictgen::InsensitiveStr::Ascii("ilizatin"),
        dictgen::InsensitiveStr::Ascii("ilizatoin"),
        dictgen::InsensitiveStr::Ascii("ilizaton"),
        dictgen::InsensitiveStr::Ascii("ilizatons"),
        dictgen::InsensitiveStr::Ascii("illian"),
        dictgen::InsensitiveStr::Ascii("illians"),
        dictgen::InsensitiveStr::Ascii("ilziation"),
        dictgen::InsensitiveStr::Ascii("izilation"),
    ],
    values: &[
        &["civilisation"],
        &["civilisations"],
        &["civilization"],
        &["civilizations"],
        &["civilisation"],
        &["civilisations"],
        &["civilization"],
        &["civilizations"],
        &["civilisation"],
        &["civilisations"],
        &["civilization"],
        &["civilizations"],
        &["civilisation"],
        &["civilisations"],
        &["civilization"],
        &["civilizations"],
        &["civilisation"],
        &["civilisations"],
        &["civilization"],
        &["civilizations"],
        &["civilians"],
        &["civilisation"],
        &["civilisations"],
        &["civilization"],
        &["civilizations"],
        &["civilisation"],
        &["civilisations"],
        &["civilization"],
        &["civilizations"],
        &["civilizations"],
        &["civilizations"],
        &["civilization"],
        &["civilization"],
        &["civilizations"],
        &["civilizations"],
        &["civilizations"],
        &["civilization"],
        &["civilizations"],
        &["civilian"],
        &["civilians"],
        &["civilizations"],
        &["civilizations"],
    ],
    range: 6..=10,
};

static WORD_CIT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CIT_CHILDREN),
    value: None,
};

pub static WORD_CIT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("icenship"),
        dictgen::InsensitiveStr::Ascii("isenship"),
        dictgen::InsensitiveStr::Ascii("izinship"),
    ],
    values: &[&["citizenship"], &["citizenship"], &["citizenship"]],
    range: 8..=8,
};

static WORD_CIR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_CIR_CHILDREN),
    value: None,
};

static WORD_CIR_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    Some(&WORD_CIRC_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_CIRI_NODE),
    None,
    None,
    Some(&WORD_CIRL_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_CIRR_NODE),
    Some(&WORD_CIRS_NODE),
    Some(&WORD_CIRT_NODE),
    Some(&WORD_CIRU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_CIRU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CIRU_CHILDREN),
    value: None,
};

pub static WORD_CIRU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cal"),
        dictgen::InsensitiveStr::Ascii("cit"),
        dictgen::InsensitiveStr::Ascii("cits"),
        dictgen::InsensitiveStr::Ascii("clar"),
        dictgen::InsensitiveStr::Ascii("clating"),
        dictgen::InsensitiveStr::Ascii("clation"),
        dictgen::InsensitiveStr::Ascii("clator"),
        dictgen::InsensitiveStr::Ascii("cmference"),
        dictgen::InsensitiveStr::Ascii("cmflex"),
        dictgen::InsensitiveStr::Ascii("cmstances"),
        dictgen::InsensitiveStr::Ascii("cular"),
        dictgen::InsensitiveStr::Ascii("cumstance"),
        dictgen::InsensitiveStr::Ascii("cumstances"),
        dictgen::InsensitiveStr::Ascii("it"),
        dictgen::InsensitiveStr::Ascii("its"),
        dictgen::InsensitiveStr::Ascii("mflex"),
        dictgen::InsensitiveStr::Ascii("mstance"),
        dictgen::InsensitiveStr::Ascii("mstances"),
    ],
    values: &[
        &["circular"],
        &["circuit"],
        &["circuits"],
        &["circular"],
        &["circulating"],
        &["circulation"],
        &["circulator"],
        &["circumference"],
        &["circumflex"],
        &["circumstances"],
        &["circular"],
        &["circumstance"],
        &["circumstances"],
        &["circuit"],
        &["circuits"],
        &["circumflex"],
        &["circumstance"],
        &["circumstances"],
    ],
    range: 2..=10,
};

static WORD_CIRT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CIRT_CHILDREN),
    value: None,
};

pub static WORD_CIRT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cuit"),
        dictgen::InsensitiveStr::Ascii("icise"),
        dictgen::InsensitiveStr::Ascii("icising"),
    ],
    values: &[&["circuit"], &["criticise"], &["criticising"]],
    range: 4..=7,
};

static WORD_CIRS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CIRS_CHILDREN),
    value: None,
};

pub static WORD_CIRS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("umstances")],
    values: &[&["circumstances"]],
    range: 9..=9,
};

static WORD_CIRR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CIRR_CHILDREN),
    value: None,
};

pub static WORD_CIRR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ently"),
        dictgen::InsensitiveStr::Ascii("uculum"),
    ],
    values: &[&["currently"], &["curriculum"]],
    range: 5..=6,
};

static WORD_CIRL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CIRL_CHILDREN),
    value: None,
};

pub static WORD_CIRL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ce"),
        dictgen::InsensitiveStr::Ascii("ces"),
        dictgen::InsensitiveStr::Ascii("cing"),
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("es"),
    ],
    values: &[
        &["circle"],
        &["circles"],
        &["circling"],
        &["circle"],
        &["circles"],
    ],
    range: 1..=4,
};

static WORD_CIRI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CIRI_CHILDREN),
    value: None,
};

pub static WORD_CIRI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cle"),
        dictgen::InsensitiveStr::Ascii("cles"),
        dictgen::InsensitiveStr::Ascii("cuit"),
        dictgen::InsensitiveStr::Ascii("cuits"),
        dictgen::InsensitiveStr::Ascii("cular"),
        dictgen::InsensitiveStr::Ascii("cularise"),
        dictgen::InsensitiveStr::Ascii("cularize"),
        dictgen::InsensitiveStr::Ascii("culum"),
        dictgen::InsensitiveStr::Ascii("lic"),
        dictgen::InsensitiveStr::Ascii("llic"),
        dictgen::InsensitiveStr::Ascii("tc"),
        dictgen::InsensitiveStr::Ascii("tcal"),
        dictgen::InsensitiveStr::Ascii("tcality"),
        dictgen::InsensitiveStr::Ascii("tcals"),
        dictgen::InsensitiveStr::Ascii("tcs"),
        dictgen::InsensitiveStr::Ascii("teria"),
        dictgen::InsensitiveStr::Ascii("tic"),
        dictgen::InsensitiveStr::Ascii("tical"),
        dictgen::InsensitiveStr::Ascii("ticality"),
        dictgen::InsensitiveStr::Ascii("ticals"),
        dictgen::InsensitiveStr::Ascii("tics"),
    ],
    values: &[
        &["circle"],
        &["circles"],
        &["circuit"],
        &["circuits"],
        &["circular"],
        &["circularise"],
        &["circularize"],
        &["curriculum"],
        &["cyrillic"],
        &["cyrillic"],
        &["critic"],
        &["critical"],
        &["criticality"],
        &["criticals"],
        &["critics"],
        &["criteria"],
        &["critic"],
        &["critical"],
        &["criticality"],
        &["criticals"],
        &["critics"],
    ],
    range: 2..=8,
};

static WORD_CIRC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_CIRC_CHILDREN),
    value: None,
};

static WORD_CIRC_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    None,
    None,
    Some(&WORD_CIRCE_NODE),
    None,
    None,
    None,
    Some(&WORD_CIRCI_NODE),
    None,
    Some(&WORD_CIRCK_NODE),
    Some(&WORD_CIRCL_NODE),
    None,
    None,
    Some(&WORD_CIRCO_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_CIRCU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_CIRCU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CIRCU_CHILDREN),
    value: None,
};

pub static WORD_CIRCU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("al"),
        dictgen::InsensitiveStr::Ascii("altion"),
        dictgen::InsensitiveStr::Ascii("is"),
        dictgen::InsensitiveStr::Ascii("itery"),
        dictgen::InsensitiveStr::Ascii("itos"),
        dictgen::InsensitiveStr::Ascii("lacion"),
        dictgen::InsensitiveStr::Ascii("laire"),
        dictgen::InsensitiveStr::Ascii("latiing"),
        dictgen::InsensitiveStr::Ascii("lationg"),
        dictgen::InsensitiveStr::Ascii("laton"),
        dictgen::InsensitiveStr::Ascii("mcisied"),
        dictgen::InsensitiveStr::Ascii("mcison"),
        dictgen::InsensitiveStr::Ascii("mcission"),
        dictgen::InsensitiveStr::Ascii("mcition"),
        dictgen::InsensitiveStr::Ascii("mferance"),
        dictgen::InsensitiveStr::Ascii("mferencial"),
        dictgen::InsensitiveStr::Ascii("msice"),
        dictgen::InsensitiveStr::Ascii("msiced"),
        dictgen::InsensitiveStr::Ascii("msicion"),
        dictgen::InsensitiveStr::Ascii("msicions"),
        dictgen::InsensitiveStr::Ascii("msied"),
        dictgen::InsensitiveStr::Ascii("msised"),
        dictgen::InsensitiveStr::Ascii("msision"),
        dictgen::InsensitiveStr::Ascii("msition"),
        dictgen::InsensitiveStr::Ascii("msizion"),
        dictgen::InsensitiveStr::Ascii("mstace"),
        dictgen::InsensitiveStr::Ascii("mstancial"),
        dictgen::InsensitiveStr::Ascii("mstanes"),
        dictgen::InsensitiveStr::Ascii("mstanial"),
        dictgen::InsensitiveStr::Ascii("mstansial"),
        dictgen::InsensitiveStr::Ascii("mstanta"),
        dictgen::InsensitiveStr::Ascii("mstantal"),
        dictgen::InsensitiveStr::Ascii("mstante"),
        dictgen::InsensitiveStr::Ascii("mstantional"),
        dictgen::InsensitiveStr::Ascii("mstantual"),
        dictgen::InsensitiveStr::Ascii("mstential"),
        dictgen::InsensitiveStr::Ascii("mstnaces"),
        dictgen::InsensitiveStr::Ascii("mstnce"),
        dictgen::InsensitiveStr::Ascii("mstnces"),
        dictgen::InsensitiveStr::Ascii("mstncial"),
        dictgen::InsensitiveStr::Ascii("mstntial"),
        dictgen::InsensitiveStr::Ascii("mvernt"),
        dictgen::InsensitiveStr::Ascii("mvrent"),
        dictgen::InsensitiveStr::Ascii("mwent"),
        dictgen::InsensitiveStr::Ascii("ncised"),
        dictgen::InsensitiveStr::Ascii("ncision"),
        dictgen::InsensitiveStr::Ascii("nference"),
        dictgen::InsensitiveStr::Ascii("nferences"),
        dictgen::InsensitiveStr::Ascii("nstance"),
        dictgen::InsensitiveStr::Ascii("nstances"),
        dictgen::InsensitiveStr::Ascii("nstantial"),
        dictgen::InsensitiveStr::Ascii("nvent"),
        dictgen::InsensitiveStr::Ascii("stances"),
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("ts"),
    ],
    values: &[
        &["circular"],
        &["circulation"],
        &["circuits"],
        &["circuitry"],
        &["circuits"],
        &["circulation"],
        &["circular"],
        &["circulating"],
        &["circulating"],
        &["circulation"],
        &["circumcised"],
        &["circumcision"],
        &["circumcision"],
        &["circumcision"],
        &["circumference"],
        &["circumferential"],
        &["circumcised"],
        &["circumcised"],
        &["circumcision"],
        &["circumcision"],
        &["circumcised"],
        &["circumcised"],
        &["circumcision"],
        &["circumcision"],
        &["circumcision"],
        &["circumstance"],
        &["circumstantial"],
        &["circumstance"],
        &["circumstantial"],
        &["circumstantial"],
        &["circumstantial"],
        &["circumstantial"],
        &["circumstance"],
        &["circumstantial"],
        &["circumstantial"],
        &["circumstantial"],
        &["circumstance"],
        &["circumstance"],
        &["circumstances"],
        &["circumstantial"],
        &["circumstantial"],
        &["circumvent"],
        &["circumvent"],
        &["circumvent"],
        &["circumcised"],
        &["circumcision"],
        &["circumference"],
        &["circumferences"],
        &["circumstance"],
        &["circumstances"],
        &["circumstantial"],
        &["circumvent"],
        &["circumstances"],
        &["circuit"],
        &["circuits"],
    ],
    range: 1..=11,
};

static WORD_CIRCO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CIRCO_CHILDREN),
    value: None,
};

pub static WORD_CIRCO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("mference"),
        dictgen::InsensitiveStr::Ascii("mstance"),
        dictgen::InsensitiveStr::Ascii("mstances"),
        dictgen::InsensitiveStr::Ascii("mvent"),
        dictgen::InsensitiveStr::Ascii("mvented"),
        dictgen::InsensitiveStr::Ascii("mvents"),
    ],
    values: &[
        &["circumference"],
        &["circumstance"],
        &["circumstances"],
        &["circumvent"],
        &["circumvented"],
        &["circumvents"],
    ],
    range: 5..=8,
};

static WORD_CIRCL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CIRCL_CHILDREN),
    value: None,
};

pub static WORD_CIRCL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ebs"),
        dictgen::InsensitiveStr::Ascii("uar"),
        dictgen::InsensitiveStr::Ascii("uarly"),
        dictgen::InsensitiveStr::Ascii("uars"),
        dictgen::InsensitiveStr::Ascii("uating"),
    ],
    values: &[
        &["circles"],
        &["circular"],
        &["circularly"],
        &["circulars"],
        &["circulating"],
    ],
    range: 3..=6,
};

static WORD_CIRCK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CIRCK_CHILDREN),
    value: None,
};

pub static WORD_CIRCK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ets")],
    values: &[&["crickets"]],
    range: 3..=3,
};

static WORD_CIRCI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CIRCI_CHILDREN),
    value: None,
};

pub static WORD_CIRCI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("mcised"),
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("ts"),
        dictgen::InsensitiveStr::Ascii("uts"),
    ],
    values: &[&["circumcised"], &["circuit"], &["circuits"], &["circuits"]],
    range: 1..=6,
};

static WORD_CIRCE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CIRCE_CHILDREN),
    value: None,
};

pub static WORD_CIRCE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ls")],
    values: &[&["circles"]],
    range: 2..=2,
};

static WORD_CIP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CIP_CHILDREN),
    value: None,
};

pub static WORD_CIP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("er"),
        dictgen::InsensitiveStr::Ascii("ers"),
        dictgen::InsensitiveStr::Ascii("ersuite"),
        dictgen::InsensitiveStr::Ascii("ersuites"),
        dictgen::InsensitiveStr::Ascii("ertext"),
        dictgen::InsensitiveStr::Ascii("ertexts"),
        dictgen::InsensitiveStr::Ascii("h"),
        dictgen::InsensitiveStr::Ascii("he"),
        dictgen::InsensitiveStr::Ascii("herntext"),
        dictgen::InsensitiveStr::Ascii("hersuit"),
        dictgen::InsensitiveStr::Ascii("hersuits"),
        dictgen::InsensitiveStr::Ascii("hersute"),
        dictgen::InsensitiveStr::Ascii("hersutes"),
        dictgen::InsensitiveStr::Ascii("heruite"),
        dictgen::InsensitiveStr::Ascii("heruites"),
        dictgen::InsensitiveStr::Ascii("hes"),
        dictgen::InsensitiveStr::Ascii("hr"),
        dictgen::InsensitiveStr::Ascii("hrs"),
        dictgen::InsensitiveStr::Ascii("s"),
    ],
    values: &[
        &["cipher"],
        &["ciphers"],
        &["ciphersuite"],
        &["ciphersuites"],
        &["ciphertext"],
        &["ciphertexts"],
        &["cipher", "chip"],
        &["cipher"],
        &["ciphertext"],
        &["ciphersuite"],
        &["ciphersuites"],
        &["ciphersuite"],
        &["ciphersuites"],
        &["ciphersuite"],
        &["ciphersuites"],
        &["ciphers"],
        &["cipher"],
        &["ciphers"],
        &["chips"],
    ],
    range: 1..=8,
};

static WORD_CIO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CIO_CHILDREN),
    value: None,
};

pub static WORD_CIO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ntrol"),
        dictgen::InsensitiveStr::Ascii("tee"),
        dictgen::InsensitiveStr::Ascii("tees"),
    ],
    values: &[&["control"], &["coyote"], &["coyotes"]],
    range: 3..=5,
};

static WORD_CIN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CIN_CHILDREN),
    value: None,
};

pub static WORD_CIN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cinatti"),
        dictgen::InsensitiveStr::Ascii("cinnasti"),
        dictgen::InsensitiveStr::Ascii("cinnatti"),
        dictgen::InsensitiveStr::Ascii("cinnnati"),
        dictgen::InsensitiveStr::Ascii("ematagraphy"),
        dictgen::InsensitiveStr::Ascii("ematagrophy"),
        dictgen::InsensitiveStr::Ascii("ematograhpy"),
        dictgen::InsensitiveStr::Ascii("ematograhy"),
        dictgen::InsensitiveStr::Ascii("ematograpy"),
        dictgen::InsensitiveStr::Ascii("ematogrophy"),
        dictgen::InsensitiveStr::Ascii("ematogrpahy"),
        dictgen::InsensitiveStr::Ascii("emetography"),
        dictgen::InsensitiveStr::Ascii("figuration"),
        dictgen::InsensitiveStr::Ascii("figurations"),
        dictgen::InsensitiveStr::Ascii("imatography"),
        dictgen::InsensitiveStr::Ascii("ncinati"),
        dictgen::InsensitiveStr::Ascii("tainer"),
        dictgen::InsensitiveStr::Ascii("taner"),
    ],
    values: &[
        &["cincinnati"],
        &["cincinnati"],
        &["cincinnati"],
        &["cincinnati"],
        &["cinematography"],
        &["cinematography"],
        &["cinematography"],
        &["cinematography"],
        &["cinematography"],
        &["cinematography"],
        &["cinematography"],
        &["cinematography"],
        &["configuration"],
        &["configurations"],
        &["cinematography"],
        &["cincinnati"],
        &["container"],
        &["container"],
    ],
    range: 5..=11,
};

static WORD_CIM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CIM_CHILDREN),
    value: None,
};

pub static WORD_CIM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("etric"),
        dictgen::InsensitiveStr::Ascii("etrical"),
        dictgen::InsensitiveStr::Ascii("etricaly"),
        dictgen::InsensitiveStr::Ascii("etriclly"),
        dictgen::InsensitiveStr::Ascii("etricly"),
        dictgen::InsensitiveStr::Ascii("metric"),
        dictgen::InsensitiveStr::Ascii("metrical"),
        dictgen::InsensitiveStr::Ascii("metricaly"),
        dictgen::InsensitiveStr::Ascii("metriclly"),
        dictgen::InsensitiveStr::Ascii("metricly"),
        dictgen::InsensitiveStr::Ascii("piler"),
        dictgen::InsensitiveStr::Ascii("pilers"),
        dictgen::InsensitiveStr::Ascii("ptom"),
        dictgen::InsensitiveStr::Ascii("ptomatic"),
        dictgen::InsensitiveStr::Ascii("ptomatically"),
        dictgen::InsensitiveStr::Ascii("ptomaticaly"),
        dictgen::InsensitiveStr::Ascii("ptomaticlly"),
        dictgen::InsensitiveStr::Ascii("ptomaticly"),
        dictgen::InsensitiveStr::Ascii("ptoms"),
        dictgen::InsensitiveStr::Ascii("ptum"),
        dictgen::InsensitiveStr::Ascii("ptumatic"),
        dictgen::InsensitiveStr::Ascii("ptumatically"),
        dictgen::InsensitiveStr::Ascii("ptumaticaly"),
        dictgen::InsensitiveStr::Ascii("ptumaticlly"),
        dictgen::InsensitiveStr::Ascii("ptumaticly"),
        dictgen::InsensitiveStr::Ascii("ptums"),
    ],
    values: &[
        &["symmetric"],
        &["symmetrical"],
        &["symmetrically"],
        &["symmetrically"],
        &["symmetricly"],
        &["symmetric"],
        &["symmetrical"],
        &["symmetrically"],
        &["symmetrically"],
        &["symmetricly"],
        &["compiler"],
        &["compilers"],
        &["symptom"],
        &["symptomatic"],
        &["symptomatically"],
        &["symptomatically"],
        &["symptomatically"],
        &["symptomatically"],
        &["symptoms"],
        &["symptom"],
        &["symptomatic"],
        &["symptomatically"],
        &["symptomatically"],
        &["symptomatically"],
        &["symptomatically"],
        &["symptoms"],
    ],
    range: 4..=12,
};

static WORD_CIL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CIL_CHILDREN),
    value: None,
};

pub static WORD_CIL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("anto"),
        dictgen::InsensitiveStr::Ascii("dren"),
        dictgen::InsensitiveStr::Ascii("ent"),
        dictgen::InsensitiveStr::Ascii("ents"),
        dictgen::InsensitiveStr::Ascii("incer"),
        dictgen::InsensitiveStr::Ascii("incers"),
        dictgen::InsensitiveStr::Ascii("inder"),
        dictgen::InsensitiveStr::Ascii("inders"),
        dictgen::InsensitiveStr::Ascii("indrical"),
        dictgen::InsensitiveStr::Ascii("ivians"),
        dictgen::InsensitiveStr::Ascii("ivization"),
        dictgen::InsensitiveStr::Ascii("mbers"),
        dictgen::InsensitiveStr::Ascii("natro"),
        dictgen::InsensitiveStr::Ascii("pboard"),
        dictgen::InsensitiveStr::Ascii("toris"),
        dictgen::InsensitiveStr::Ascii("ynders"),
        dictgen::InsensitiveStr::Ascii("yndre"),
        dictgen::InsensitiveStr::Ascii("yndres"),
        dictgen::InsensitiveStr::Ascii("yndrs"),
    ],
    values: &[
        &["cilantro"],
        &["children"],
        &["client", "silent"],
        &["clients", "silents", "silence"],
        &["cylinder", "silencer"],
        &["cylinders", "silencers"],
        &["cylinder"],
        &["cylinders"],
        &["cylindrical"],
        &["civilians"],
        &["civilizations"],
        &["climbers"],
        &["cilantro"],
        &["clipboard"],
        &["clitoris"],
        &["cylinders"],
        &["cylinder"],
        &["cylinders"],
        &["cylinders"],
    ],
    range: 3..=9,
};

static WORD_CIH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CIH_CHILDREN),
    value: None,
};

pub static WORD_CIH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("pher"),
        dictgen::InsensitiveStr::Ascii("phers"),
    ],
    values: &[&["cipher"], &["ciphers"]],
    range: 4..=5,
};

static WORD_CIG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CIG_CHILDREN),
    value: None,
};

pub static WORD_CIG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("arattes"),
        dictgen::InsensitiveStr::Ascii("arete"),
        dictgen::InsensitiveStr::Ascii("aretes"),
        dictgen::InsensitiveStr::Ascii("arett"),
        dictgen::InsensitiveStr::Ascii("aretts"),
        dictgen::InsensitiveStr::Ascii("arret"),
        dictgen::InsensitiveStr::Ascii("arrete"),
        dictgen::InsensitiveStr::Ascii("arretes"),
        dictgen::InsensitiveStr::Ascii("arrets"),
        dictgen::InsensitiveStr::Ascii("arrett"),
        dictgen::InsensitiveStr::Ascii("arrette"),
        dictgen::InsensitiveStr::Ascii("arrettes"),
        dictgen::InsensitiveStr::Ascii("arretts"),
        dictgen::InsensitiveStr::Ascii("eratte"),
        dictgen::InsensitiveStr::Ascii("erattes"),
        dictgen::InsensitiveStr::Ascii("uret"),
        dictgen::InsensitiveStr::Ascii("urete"),
        dictgen::InsensitiveStr::Ascii("uretes"),
        dictgen::InsensitiveStr::Ascii("urets"),
    ],
    values: &[
        &["cigarettes"],
        &["cigarets", "cigarette"],
        &["cigarettes"],
        &["cigarette"],
        &["cigarettes"],
        &["cigaret"],
        &["cigarette"],
        &["cigarettes"],
        &["cigarets"],
        &["cigarette"],
        &["cigarette"],
        &["cigarettes"],
        &["cigarettes"],
        &["cigarette"],
        &["cigarettes"],
        &["cigaret"],
        &["cigarette"],
        &["cigarettes"],
        &["cigarets"],
    ],
    range: 4..=8,
};

static WORD_CIE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CIE_CHILDREN),
    value: None,
};

pub static WORD_CIE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("lings"),
        dictgen::InsensitiveStr::Ascii("nts"),
    ],
    values: &[&["ceilings"], &["clients"]],
    range: 3..=5,
};

static WORD_CIC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CIC_CHILDREN),
    value: None,
};

pub static WORD_CIC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("k"),
        dictgen::InsensitiveStr::Ascii("rle"),
        dictgen::InsensitiveStr::Ascii("ruit"),
        dictgen::InsensitiveStr::Ascii("ruits"),
        dictgen::InsensitiveStr::Ascii("rulating"),
        dictgen::InsensitiveStr::Ascii("ular"),
        dictgen::InsensitiveStr::Ascii("ulars"),
    ],
    values: &[
        &["click"],
        &["circle"],
        &["circuit"],
        &["circuits"],
        &["circulating"],
        &["circular"],
        &["circulars"],
    ],
    range: 1..=8,
};

static WORD_CH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_CH_CHILDREN),
    value: None,
};

static WORD_CH_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_CHA_NODE),
    None,
    Some(&WORD_CHC_NODE),
    None,
    Some(&WORD_CHE_NODE),
    None,
    Some(&WORD_CHG_NODE),
    None,
    Some(&WORD_CHI_NODE),
    None,
    Some(&WORD_CHK_NODE),
    Some(&WORD_CHL_NODE),
    Some(&WORD_CHM_NODE),
    Some(&WORD_CHN_NODE),
    Some(&WORD_CHO_NODE),
    None,
    None,
    Some(&WORD_CHR_NODE),
    None,
    Some(&WORD_CHT_NODE),
    Some(&WORD_CHU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_CHU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CHU_CHILDREN),
    value: None,
};

pub static WORD_CHU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ch"),
        dictgen::InsensitiveStr::Ascii("ckels"),
        dictgen::InsensitiveStr::Ascii("ks"),
        dictgen::InsensitiveStr::Ascii("naks"),
        dictgen::InsensitiveStr::Ascii("nc"),
        dictgen::InsensitiveStr::Ascii("nck"),
        dictgen::InsensitiveStr::Ascii("ncked"),
        dictgen::InsensitiveStr::Ascii("ncking"),
        dictgen::InsensitiveStr::Ascii("ncks"),
        dictgen::InsensitiveStr::Ascii("ncksize"),
        dictgen::InsensitiveStr::Ascii("ncs"),
        dictgen::InsensitiveStr::Ascii("ned"),
        dictgen::InsensitiveStr::Ascii("rchers"),
        dictgen::InsensitiveStr::Ascii("rchs"),
    ],
    values: &[
        &["church"],
        &["chuckles"],
        &["chunks"],
        &["chunks"],
        &["chunk"],
        &["chunk"],
        &["chunked"],
        &["chunking"],
        &["chunks"],
        &["chunksize"],
        &["chunks"],
        &["chunked"],
        &["churches"],
        &["churches"],
    ],
    range: 2..=7,
};

static WORD_CHT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CHT_CHILDREN),
    value: None,
};

pub static WORD_CHT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ulhu")],
    values: &[&["cthulhu"]],
    range: 4..=4,
};

static WORD_CHR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CHR_CHILDREN),
    value: None,
};

pub static WORD_CHR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("acter"),
        dictgen::InsensitiveStr::Ascii("acters"),
        dictgen::InsensitiveStr::Ascii("actor"),
        dictgen::InsensitiveStr::Ascii("actors"),
        dictgen::InsensitiveStr::Ascii("ash"),
        dictgen::InsensitiveStr::Ascii("ashed"),
        dictgen::InsensitiveStr::Ascii("ashes"),
        dictgen::InsensitiveStr::Ascii("ashing"),
        dictgen::InsensitiveStr::Ascii("ashs"),
        dictgen::InsensitiveStr::Ascii("enobyl"),
        dictgen::InsensitiveStr::Ascii("isitan"),
        dictgen::InsensitiveStr::Ascii("isitanity"),
        dictgen::InsensitiveStr::Ascii("isitans"),
        dictgen::InsensitiveStr::Ascii("istain"),
        dictgen::InsensitiveStr::Ascii("istainity"),
        dictgen::InsensitiveStr::Ascii("istains"),
        dictgen::InsensitiveStr::Ascii("istams"),
        dictgen::InsensitiveStr::Ascii("istiaan"),
        dictgen::InsensitiveStr::Ascii("istiantiy"),
        dictgen::InsensitiveStr::Ascii("istianty"),
        dictgen::InsensitiveStr::Ascii("istimas"),
        dictgen::InsensitiveStr::Ascii("istin"),
        dictgen::InsensitiveStr::Ascii("istinaity"),
        dictgen::InsensitiveStr::Ascii("istinas"),
        dictgen::InsensitiveStr::Ascii("istines"),
        dictgen::InsensitiveStr::Ascii("istmans"),
        dictgen::InsensitiveStr::Ascii("minance"),
        dictgen::InsensitiveStr::Ascii("oline"),
        dictgen::InsensitiveStr::Ascii("omasome"),
        dictgen::InsensitiveStr::Ascii("omasomes"),
        dictgen::InsensitiveStr::Ascii("omesome"),
        dictgen::InsensitiveStr::Ascii("omesomes"),
        dictgen::InsensitiveStr::Ascii("omisome"),
        dictgen::InsensitiveStr::Ascii("omisomes"),
        dictgen::InsensitiveStr::Ascii("omose"),
        dictgen::InsensitiveStr::Ascii("omosmes"),
        dictgen::InsensitiveStr::Ascii("omosomers"),
        dictgen::InsensitiveStr::Ascii("omosoms"),
        dictgen::InsensitiveStr::Ascii("omosone"),
        dictgen::InsensitiveStr::Ascii("omosones"),
        dictgen::InsensitiveStr::Ascii("omosoom"),
        dictgen::InsensitiveStr::Ascii("omossome"),
        dictgen::InsensitiveStr::Ascii("omozome"),
        dictgen::InsensitiveStr::Ascii("omozomes"),
        dictgen::InsensitiveStr::Ascii("omum"),
        dictgen::InsensitiveStr::Ascii("onciles"),
        dictgen::InsensitiveStr::Ascii("onicales"),
        dictgen::InsensitiveStr::Ascii("onicals"),
        dictgen::InsensitiveStr::Ascii("onice"),
        dictgen::InsensitiveStr::Ascii("onicels"),
        dictgen::InsensitiveStr::Ascii("onichles"),
        dictgen::InsensitiveStr::Ascii("onocles"),
        dictgen::InsensitiveStr::Ascii("onoligical"),
        dictgen::InsensitiveStr::Ascii("onologial"),
        dictgen::InsensitiveStr::Ascii("onologicly"),
        dictgen::InsensitiveStr::Ascii("onosome"),
        dictgen::InsensitiveStr::Ascii("sitian"),
        dictgen::InsensitiveStr::Ascii("sitianity"),
        dictgen::InsensitiveStr::Ascii("sitians"),
        dictgen::InsensitiveStr::Ascii("sitmas"),
        dictgen::InsensitiveStr::Ascii("uches"),
    ],
    values: &[
        &["character"],
        &["characters"],
        &["character"],
        &["characters"],
        &["crash", "thrash", "trash"],
        &["crashed", "thrashed", "trashed"],
        &["crashes", "thrashes", "trashes"],
        &["crashing", "thrashing", "trashing"],
        &["crashes", "thrashes", "trashes"],
        &["chernobyl"],
        &["christian"],
        &["christianity"],
        &["christians"],
        &["christian"],
        &["christianity"],
        &["christians"],
        &["christmas"],
        &["christian"],
        &["christianity"],
        &["christianity"],
        &["christians"],
        &["christian"],
        &["christianity"],
        &["christians"],
        &["christians"],
        &["christians"],
        &["chrominance"],
        &["chlorine"],
        &["chromosome"],
        &["chromosomes"],
        &["chromosome"],
        &["chromosomes"],
        &["chromosome"],
        &["chromosomes"],
        &["chromosome"],
        &["chromosomes"],
        &["chromosomes"],
        &["chromosomes"],
        &["chromosome"],
        &["chromosomes"],
        &["chromosome"],
        &["chromosomes"],
        &["chromosome"],
        &["chromosomes"],
        &["chromium"],
        &["chronicles"],
        &["chronicles"],
        &["chronicles"],
        &["chronicles"],
        &["chronicles"],
        &["chronicles"],
        &["chronicles"],
        &["chronological"],
        &["chronological"],
        &["chronological"],
        &["chromosome"],
        &["christian"],
        &["christianity"],
        &["christians"],
        &["christmas"],
        &["churches"],
    ],
    range: 3..=10,
};

static WORD_CHO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CHO_CHILDREN),
    value: None,
};

pub static WORD_CHO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("atic"),
        dictgen::InsensitiveStr::Ascii("calates"),
        dictgen::InsensitiveStr::Ascii("chka"),
        dictgen::InsensitiveStr::Ascii("chkas"),
        dictgen::InsensitiveStr::Ascii("cies"),
        dictgen::InsensitiveStr::Ascii("clate"),
        dictgen::InsensitiveStr::Ascii("cloate"),
        dictgen::InsensitiveStr::Ascii("cloates"),
        dictgen::InsensitiveStr::Ascii("coalte"),
        dictgen::InsensitiveStr::Ascii("coaltes"),
        dictgen::InsensitiveStr::Ascii("colae"),
        dictgen::InsensitiveStr::Ascii("colateers"),
        dictgen::InsensitiveStr::Ascii("colatie"),
        dictgen::InsensitiveStr::Ascii("colatos"),
        dictgen::InsensitiveStr::Ascii("colats"),
        dictgen::InsensitiveStr::Ascii("colatte"),
        dictgen::InsensitiveStr::Ascii("colet"),
        dictgen::InsensitiveStr::Ascii("colot"),
        dictgen::InsensitiveStr::Ascii("colote"),
        dictgen::InsensitiveStr::Ascii("colotes"),
        dictgen::InsensitiveStr::Ascii("colots"),
        dictgen::InsensitiveStr::Ascii("colste"),
        dictgen::InsensitiveStr::Ascii("esive"),
        dictgen::InsensitiveStr::Ascii("icers"),
        dictgen::InsensitiveStr::Ascii("icing"),
        dictgen::InsensitiveStr::Ascii("ise"),
        dictgen::InsensitiveStr::Ascii("ises"),
        dictgen::InsensitiveStr::Ascii("ising"),
        dictgen::InsensitiveStr::Ascii("lesteral"),
        dictgen::InsensitiveStr::Ascii("lestoral"),
        dictgen::InsensitiveStr::Ascii("lestorol"),
        dictgen::InsensitiveStr::Ascii("lestrol"),
        dictgen::InsensitiveStr::Ascii("locate"),
        dictgen::InsensitiveStr::Ascii("losterol"),
        dictgen::InsensitiveStr::Ascii("lrine"),
        dictgen::InsensitiveStr::Ascii("oose"),
        dictgen::InsensitiveStr::Ascii("os"),
        dictgen::InsensitiveStr::Ascii("osed"),
        dictgen::InsensitiveStr::Ascii("osen"),
        dictgen::InsensitiveStr::Ascii("pipng"),
        dictgen::InsensitiveStr::Ascii("py"),
        dictgen::InsensitiveStr::Ascii("rline"),
        dictgen::InsensitiveStr::Ascii("rmosome"),
        dictgen::InsensitiveStr::Ascii("rmosomes"),
        dictgen::InsensitiveStr::Ascii("rnicles"),
        dictgen::InsensitiveStr::Ascii("rnological"),
        dictgen::InsensitiveStr::Ascii("ronological"),
        dictgen::InsensitiveStr::Ascii("sed"),
        dictgen::InsensitiveStr::Ascii("seen"),
        dictgen::InsensitiveStr::Ascii("ser"),
        dictgen::InsensitiveStr::Ascii("sing"),
        dictgen::InsensitiveStr::Ascii("sse"),
        dictgen::InsensitiveStr::Ascii("ssen"),
        dictgen::InsensitiveStr::Ascii("uld"),
        dictgen::InsensitiveStr::Ascii("use"),
        dictgen::InsensitiveStr::Ascii("wse"),
        dictgen::InsensitiveStr::Ascii("wsing"),
    ],
    values: &[
        &["chaotic"],
        &["chocolates"],
        &["tchotchke"],
        &["tchotchkes"],
        &["choices"],
        &["chocolate"],
        &["chocolate"],
        &["chocolates"],
        &["chocolate"],
        &["chocolates"],
        &["chocolates"],
        &["chocolates"],
        &["chocolates"],
        &["chocolates"],
        &["chocolates"],
        &["chocolates"],
        &["chocolates"],
        &["chocolate"],
        &["chocolate"],
        &["chocolates"],
        &["chocolates"],
        &["chocolates"],
        &["cohesive"],
        &["choices"],
        &["choosing"],
        &["choice"],
        &["choices"],
        &["choosing"],
        &["cholesterol"],
        &["cholesterol"],
        &["cholesterol"],
        &["cholesterol"],
        &["chocolate"],
        &["cholesterol"],
        &["chlorine"],
        &["choose"],
        &["choose"],
        &["chose", "chosen"],
        &["chosen"],
        &["chopping"],
        &["choppy", "chop"],
        &["chlorine"],
        &["chromosome"],
        &["chromosomes"],
        &["chronicles"],
        &["chronological"],
        &["chronological"],
        &["chose"],
        &["chosen"],
        &["chooser"],
        &["choosing"],
        &["choose", "chose"],
        &["chosen"],
        &["should", "could"],
        &["choose", "chose", "choux"],
        &["choose", "chose"],
        &["choosing"],
    ],
    range: 2..=11,
};

static WORD_CHN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CHN_CHILDREN),
    value: None,
};

pub static WORD_CHN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("age"),
        dictgen::InsensitiveStr::Ascii("aged"),
        dictgen::InsensitiveStr::Ascii("ages"),
        dictgen::InsensitiveStr::Ascii("aging"),
        dictgen::InsensitiveStr::Ascii("ange"),
        dictgen::InsensitiveStr::Ascii("anged"),
        dictgen::InsensitiveStr::Ascii("anges"),
        dictgen::InsensitiveStr::Ascii("anging"),
        dictgen::InsensitiveStr::Ascii("ge"),
        dictgen::InsensitiveStr::Ascii("ged"),
        dictgen::InsensitiveStr::Ascii("ges"),
        dictgen::InsensitiveStr::Ascii("ging"),
        dictgen::InsensitiveStr::Ascii("nel"),
    ],
    values: &[
        &["change"],
        &["changed"],
        &["changes"],
        &["changing"],
        &["change"],
        &["changed"],
        &["changes"],
        &["changing"],
        &["change"],
        &["changed"],
        &["changes"],
        &["changing"],
        &["channel"],
    ],
    range: 2..=6,
};

static WORD_CHM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CHM_CHILDREN),
    value: None,
};

pub static WORD_CHM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("abers")],
    values: &[&["chambers"]],
    range: 5..=5,
};

static WORD_CHL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CHL_CHILDREN),
    value: None,
};

pub static WORD_CHL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("esea"),
        dictgen::InsensitiveStr::Ascii("id"),
        dictgen::InsensitiveStr::Ascii("idfree"),
        dictgen::InsensitiveStr::Ascii("idish"),
        dictgen::InsensitiveStr::Ascii("idrens"),
        dictgen::InsensitiveStr::Ascii("ids"),
        dictgen::InsensitiveStr::Ascii("oesterol"),
        dictgen::InsensitiveStr::Ascii("roine"),
    ],
    values: &[
        &["chelsea"],
        &["child"],
        &["childfree"],
        &["childish"],
        &["childrens"],
        &["children"],
        &["cholesterol"],
        &["chlorine"],
    ],
    range: 2..=8,
};

static WORD_CHK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CHK_CHILDREN),
    value: None,
};

pub static WORD_CHK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ed")],
    values: &[&["checked"]],
    range: 2..=2,
};

static WORD_CHI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_CHI_CHILDREN),
    value: None,
};

static WORD_CHI_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_CHIA_NODE),
    None,
    None,
    Some(&WORD_CHID_NODE),
    Some(&WORD_CHIE_NODE),
    None,
    None,
    Some(&WORD_CHIH_NODE),
    None,
    None,
    None,
    Some(&WORD_CHIL_NODE),
    Some(&WORD_CHIM_NODE),
    Some(&WORD_CHIN_NODE),
    Some(&WORD_CHIO_NODE),
    Some(&WORD_CHIP_NODE),
    None,
    Some(&WORD_CHIR_NODE),
    Some(&WORD_CHIS_NODE),
    None,
    Some(&WORD_CHIU_NODE),
    Some(&WORD_CHIV_NODE),
    None,
    None,
    None,
    Some(&WORD_CHIZ_NODE),
];

static WORD_CHIZ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CHIZ_CHILDREN),
    value: None,
};

pub static WORD_CHIZ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ell"),
        dictgen::InsensitiveStr::Ascii("elle"),
        dictgen::InsensitiveStr::Ascii("elled"),
        dictgen::InsensitiveStr::Ascii("elles"),
        dictgen::InsensitiveStr::Ascii("elling"),
        dictgen::InsensitiveStr::Ascii("il"),
        dictgen::InsensitiveStr::Ascii("iled"),
        dictgen::InsensitiveStr::Ascii("iles"),
        dictgen::InsensitiveStr::Ascii("iling"),
        dictgen::InsensitiveStr::Ascii("le"),
        dictgen::InsensitiveStr::Ascii("led"),
        dictgen::InsensitiveStr::Ascii("les"),
        dictgen::InsensitiveStr::Ascii("ling"),
        dictgen::InsensitiveStr::Ascii("zel"),
        dictgen::InsensitiveStr::Ascii("zell"),
        dictgen::InsensitiveStr::Ascii("zelle"),
        dictgen::InsensitiveStr::Ascii("zelled"),
        dictgen::InsensitiveStr::Ascii("zelles"),
        dictgen::InsensitiveStr::Ascii("zelling"),
        dictgen::InsensitiveStr::Ascii("zil"),
        dictgen::InsensitiveStr::Ascii("ziled"),
        dictgen::InsensitiveStr::Ascii("ziles"),
        dictgen::InsensitiveStr::Ascii("ziling"),
        dictgen::InsensitiveStr::Ascii("zle"),
        dictgen::InsensitiveStr::Ascii("zled"),
        dictgen::InsensitiveStr::Ascii("zles"),
        dictgen::InsensitiveStr::Ascii("zling"),
    ],
    values: &[
        &["chisel"],
        &["chisel"],
        &["chiselled"],
        &["chisels"],
        &["chiselling"],
        &["chisel"],
        &["chiseled"],
        &["chisels"],
        &["chiseling"],
        &["chisel"],
        &["chiseled"],
        &["chisels"],
        &["chiseling"],
        &["chisel"],
        &["chisel"],
        &["chisel"],
        &["chiselled"],
        &["chisels"],
        &["chiselling"],
        &["chisel"],
        &["chiseled"],
        &["chisels"],
        &["chiseling"],
        &["chisel"],
        &["chiseled"],
        &["chisels"],
        &["chiseling"],
    ],
    range: 2..=7,
};

static WORD_CHIV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CHIV_CHILDREN),
    value: None,
};

pub static WORD_CHIV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aly"),
        dictgen::InsensitiveStr::Ascii("arly"),
        dictgen::InsensitiveStr::Ascii("lary"),
    ],
    values: &[&["chivalry"], &["chivalry"], &["chivalry"]],
    range: 3..=4,
};

static WORD_CHIU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CHIU_CHILDREN),
    value: None,
};

pub static WORD_CHIU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("hahua"),
        dictgen::InsensitiveStr::Ascii("ldren"),
    ],
    values: &[&["chihuahua"], &["children"]],
    range: 5..=5,
};

static WORD_CHIS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CHIS_CHILDREN),
    value: None,
};

pub static WORD_CHIS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ell"),
        dictgen::InsensitiveStr::Ascii("elle"),
        dictgen::InsensitiveStr::Ascii("elles"),
        dictgen::InsensitiveStr::Ascii("il"),
        dictgen::InsensitiveStr::Ascii("iled"),
        dictgen::InsensitiveStr::Ascii("iles"),
        dictgen::InsensitiveStr::Ascii("iling"),
        dictgen::InsensitiveStr::Ascii("le"),
        dictgen::InsensitiveStr::Ascii("led"),
        dictgen::InsensitiveStr::Ascii("les"),
        dictgen::InsensitiveStr::Ascii("ling"),
        dictgen::InsensitiveStr::Ascii("pet"),
    ],
    values: &[
        &["chisel"],
        &["chisel"],
        &["chisels"],
        &["chisel"],
        &["chiseled"],
        &["chisels"],
        &["chiseling"],
        &["chisel"],
        &["chiseled"],
        &["chisels"],
        &["chiseling"],
        &["chipset"],
    ],
    range: 2..=5,
};

static WORD_CHIR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CHIR_CHILDREN),
    value: None,
};

pub static WORD_CHIR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("stian"),
        dictgen::InsensitiveStr::Ascii("stianity"),
        dictgen::InsensitiveStr::Ascii("stians"),
        dictgen::InsensitiveStr::Ascii("stmas"),
    ],
    values: &[
        &["christian"],
        &["christianity"],
        &["christians"],
        &["christmas"],
    ],
    range: 5..=8,
};

static WORD_CHIP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CHIP_CHILDREN),
    value: None,
};

pub static WORD_CHIP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("er"),
        dictgen::InsensitiveStr::Ascii("ers"),
        dictgen::InsensitiveStr::Ascii("ersuite"),
        dictgen::InsensitiveStr::Ascii("ersuites"),
        dictgen::InsensitiveStr::Ascii("ertext"),
        dictgen::InsensitiveStr::Ascii("ertexts"),
        dictgen::InsensitiveStr::Ascii("est"),
        dictgen::InsensitiveStr::Ascii("et"),
        dictgen::InsensitiveStr::Ascii("slect"),
        dictgen::InsensitiveStr::Ascii("stes"),
    ],
    values: &[
        &["cipher", "chipper", "chimer"],
        &["ciphers", "chippers", "chimers"],
        &["ciphersuite"],
        &["ciphersuites"],
        &["ciphertext"],
        &["ciphertexts"],
        &["chipset"],
        &["chipset"],
        &["chipselect"],
        &["chipsets"],
    ],
    range: 2..=8,
};

static WORD_CHIO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CHIO_CHILDREN),
    value: None,
};

pub static WORD_CHIO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("p")],
    values: &[&["chip", "chop"]],
    range: 1..=1,
};

static WORD_CHIN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CHIN_CHILDREN),
    value: None,
};

pub static WORD_CHIN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ees"),
        dictgen::InsensitiveStr::Ascii("eese"),
        dictgen::InsensitiveStr::Ascii("ense"),
        dictgen::InsensitiveStr::Ascii("esse"),
        dictgen::InsensitiveStr::Ascii("mey"),
    ],
    values: &[
        &["chinese"],
        &["chinese"],
        &["chinese"],
        &["chinese"],
        &["chimney"],
    ],
    range: 3..=4,
};

static WORD_CHIM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CHIM_CHILDREN),
    value: None,
};

pub static WORD_CHIM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eny"),
        dictgen::InsensitiveStr::Ascii("menies"),
        dictgen::InsensitiveStr::Ascii("meny"),
    ],
    values: &[&["chimney"], &["chimneys"], &["chimney"]],
    range: 3..=6,
};

static WORD_CHIL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CHIL_CHILDREN),
    value: None,
};

pub static WORD_CHIL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("dbird"),
        dictgen::InsensitiveStr::Ascii("dbrith"),
        dictgen::InsensitiveStr::Ascii("den"),
        dictgen::InsensitiveStr::Ascii("deren"),
        dictgen::InsensitiveStr::Ascii("dern"),
        dictgen::InsensitiveStr::Ascii("derns"),
        dictgen::InsensitiveStr::Ascii("disch"),
        dictgen::InsensitiveStr::Ascii("dlren"),
        dictgen::InsensitiveStr::Ascii("drends"),
        dictgen::InsensitiveStr::Ascii("drenis"),
        dictgen::InsensitiveStr::Ascii("drenmrs"),
        dictgen::InsensitiveStr::Ascii("drents"),
        dictgen::InsensitiveStr::Ascii("dres"),
        dictgen::InsensitiveStr::Ascii("dresn"),
        dictgen::InsensitiveStr::Ascii("ds"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("edren"),
        dictgen::InsensitiveStr::Ascii("lade"),
        dictgen::InsensitiveStr::Ascii("lead"),
        dictgen::InsensitiveStr::Ascii("lend"),
        dictgen::InsensitiveStr::Ascii("ren"),
        dictgen::InsensitiveStr::Ascii("vary"),
    ],
    values: &[
        &["childbirth"],
        &["childbirth"],
        &["children"],
        &["children"],
        &["children"],
        &["childrens"],
        &["childish"],
        &["children"],
        &["childrens"],
        &["childrens"],
        &["childrens"],
        &["childrens"],
        &["childrens", "children"],
        &["childrens"],
        &["children"],
        &["child", "chilled"],
        &["children"],
        &["chilled"],
        &["chilled"],
        &["chilled"],
        &["children"],
        &["chivalry"],
    ],
    range: 2..=7,
};

static WORD_CHIH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CHIH_CHILDREN),
    value: None,
};

pub static WORD_CHIH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("auhua"),
        dictgen::InsensitiveStr::Ascii("uaha"),
        dictgen::InsensitiveStr::Ascii("uahau"),
        dictgen::InsensitiveStr::Ascii("uahuha"),
        dictgen::InsensitiveStr::Ascii("uahuita"),
    ],
    values: &[
        &["chihuahua"],
        &["chihuahua"],
        &["chihuahua"],
        &["chihuahua"],
        &["chihuahua"],
    ],
    range: 4..=7,
};

static WORD_CHIE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CHIE_CHILDREN),
    value: None,
};

pub static WORD_CHIE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("nse")],
    values: &[&["chinese"]],
    range: 3..=3,
};

static WORD_CHID_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CHID_CHILDREN),
    value: None,
};

pub static WORD_CHID_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("lbirth"),
        dictgen::InsensitiveStr::Ascii("lfree"),
        dictgen::InsensitiveStr::Ascii("lish"),
        dictgen::InsensitiveStr::Ascii("lrens"),
        dictgen::InsensitiveStr::Ascii("ren"),
    ],
    values: &[
        &["childbirth"],
        &["childfree"],
        &["childish"],
        &["childrens"],
        &["children"],
    ],
    range: 3..=6,
};

static WORD_CHIA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CHIA_CHILDREN),
    value: None,
};

pub static WORD_CHIA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("nsaw")],
    values: &[&["chainsaw"]],
    range: 4..=4,
};

static WORD_CHG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CHG_CHILDREN),
    value: None,
};

pub static WORD_CHG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ange"),
        dictgen::InsensitiveStr::Ascii("anged"),
        dictgen::InsensitiveStr::Ascii("anges"),
        dictgen::InsensitiveStr::Ascii("anging"),
    ],
    values: &[&["change"], &["changed"], &["changes"], &["changing"]],
    range: 4..=6,
};

static WORD_CHE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_CHE_CHILDREN),
    value: None,
};

static WORD_CHE_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_CHEA_NODE),
    None,
    Some(&WORD_CHEC_NODE),
    Some(&WORD_CHED_NODE),
    Some(&WORD_CHEE_NODE),
    None,
    None,
    None,
    Some(&WORD_CHEI_NODE),
    None,
    Some(&WORD_CHEK_NODE),
    Some(&WORD_CHEL_NODE),
    Some(&WORD_CHEM_NODE),
    Some(&WORD_CHEN_NODE),
    None,
    None,
    None,
    Some(&WORD_CHER_NODE),
    Some(&WORD_CHES_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_CHES_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CHES_CHILDREN),
    value: None,
};

pub static WORD_CHES_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cksums"),
        dictgen::InsensitiveStr::Ascii("lea"),
    ],
    values: &[&["checksums"], &["chelsea"]],
    range: 3..=6,
};

static WORD_CHER_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CHER_CHILDREN),
    value: None,
};

pub static WORD_CHER_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ch"),
        dictgen::InsensitiveStr::Ascii("ching"),
        dictgen::InsensitiveStr::Ascii("chs"),
        dictgen::InsensitiveStr::Ascii("ck"),
        dictgen::InsensitiveStr::Ascii("cked"),
        dictgen::InsensitiveStr::Ascii("cking"),
        dictgen::InsensitiveStr::Ascii("cks"),
        dictgen::InsensitiveStr::Ascii("nboyl"),
        dictgen::InsensitiveStr::Ascii("nobl"),
        dictgen::InsensitiveStr::Ascii("nobly"),
        dictgen::InsensitiveStr::Ascii("noybl"),
        dictgen::InsensitiveStr::Ascii("nyobl"),
        dictgen::InsensitiveStr::Ascii("onbyl"),
    ],
    values: &[
        &["church"],
        &["checking", "churching"],
        &["churches"],
        &["check"],
        &["checked", "checkered"],
        &["checking"],
        &["checks"],
        &["chernobyl"],
        &["chernobyl"],
        &["chernobyl"],
        &["chernobyl"],
        &["chernobyl"],
        &["chernobyl"],
    ],
    range: 2..=5,
};

static WORD_CHEN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CHEN_CHILDREN),
    value: None,
};

pub static WORD_CHEN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ged"),
        dictgen::InsensitiveStr::Ascii("nel"),
    ],
    values: &[&["changed"], &["channel"]],
    range: 3..=3,
};

static WORD_CHEM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CHEM_CHILDREN),
    value: None,
};

pub static WORD_CHEM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cial"),
        dictgen::InsensitiveStr::Ascii("cially"),
        dictgen::InsensitiveStr::Ascii("estry"),
        dictgen::InsensitiveStr::Ascii("icaly"),
        dictgen::InsensitiveStr::Ascii("isty"),
        dictgen::InsensitiveStr::Ascii("sitry"),
    ],
    values: &[
        &["chemical"],
        &["chemically"],
        &["chemistry"],
        &["chemically"],
        &["chemistry"],
        &["chemistry"],
    ],
    range: 4..=6,
};

static WORD_CHEL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CHEL_CHILDREN),
    value: None,
};

pub static WORD_CHEL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("lo"),
        dictgen::InsensitiveStr::Ascii("sae"),
    ],
    values: &[&["cello"], &["chelsea"]],
    range: 2..=3,
};

static WORD_CHEK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CHEK_CHILDREN),
    value: Some(&["check"]),
};

pub static WORD_CHEK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("c"),
        dictgen::InsensitiveStr::Ascii("cer"),
        dictgen::InsensitiveStr::Ascii("cing"),
        dictgen::InsensitiveStr::Ascii("cmate"),
        dictgen::InsensitiveStr::Ascii("cout"),
        dictgen::InsensitiveStr::Ascii("d"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("ers"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("s"),
        dictgen::InsensitiveStr::Ascii("sum"),
        dictgen::InsensitiveStr::Ascii("sums"),
    ],
    values: &[
        &["check"],
        &["checker"],
        &["checking"],
        &["checkmate"],
        &["checkout"],
        &["checked"],
        &["checked"],
        &["checkers"],
        &["checking"],
        &["checks"],
        &["checksum"],
        &["checksums"],
    ],
    range: 1..=5,
};

static WORD_CHEI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CHEI_CHILDREN),
    value: None,
};

pub static WORD_CHEI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("f"),
        dictgen::InsensitiveStr::Ascii("fs"),
    ],
    values: &[&["chief"], &["chiefs"]],
    range: 1..=2,
};

static WORD_CHEE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CHEE_CHILDREN),
    value: None,
};

pub static WORD_CHEE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ck"),
        dictgen::InsensitiveStr::Ascii("ots"),
        dictgen::InsensitiveStr::Ascii("per"),
        dictgen::InsensitiveStr::Ascii("rleadra"),
        dictgen::InsensitiveStr::Ascii("rlearder"),
        dictgen::InsensitiveStr::Ascii("rleards"),
        dictgen::InsensitiveStr::Ascii("rleeder"),
        dictgen::InsensitiveStr::Ascii("rleeders"),
        dictgen::InsensitiveStr::Ascii("seberger"),
        dictgen::InsensitiveStr::Ascii("seborger"),
        dictgen::InsensitiveStr::Ascii("sebruger"),
        dictgen::InsensitiveStr::Ascii("sebuger"),
        dictgen::InsensitiveStr::Ascii("seburgare"),
        dictgen::InsensitiveStr::Ascii("seburges"),
        dictgen::InsensitiveStr::Ascii("seburgie"),
        dictgen::InsensitiveStr::Ascii("seburgler"),
        dictgen::InsensitiveStr::Ascii("seburgs"),
        dictgen::InsensitiveStr::Ascii("seburguer"),
        dictgen::InsensitiveStr::Ascii("seburguers"),
        dictgen::InsensitiveStr::Ascii("secase"),
        dictgen::InsensitiveStr::Ascii("secave"),
        dictgen::InsensitiveStr::Ascii("sees"),
        dictgen::InsensitiveStr::Ascii("seface"),
        dictgen::InsensitiveStr::Ascii("seus"),
        dictgen::InsensitiveStr::Ascii("sse"),
        dictgen::InsensitiveStr::Ascii("ta"),
        dictgen::InsensitiveStr::Ascii("toos"),
        dictgen::InsensitiveStr::Ascii("zeburger"),
        dictgen::InsensitiveStr::Ascii("zeburgers"),
        dictgen::InsensitiveStr::Ascii("zecake"),
    ],
    values: &[
        &["check", "cheek"],
        &["cheetos"],
        &["cheaper"],
        &["cheerleader"],
        &["cheerleader"],
        &["cheerleaders"],
        &["cheerleader"],
        &["cheerleaders"],
        &["cheeseburger"],
        &["cheeseburger"],
        &["cheeseburgers"],
        &["cheeseburger"],
        &["cheeseburger"],
        &["cheeseburgers"],
        &["cheeseburger"],
        &["cheeseburger"],
        &["cheeseburgers"],
        &["cheeseburger"],
        &["cheeseburgers"],
        &["cheesecake"],
        &["cheesecake"],
        &["cheeses"],
        &["cheesecake"],
        &["cheeses"],
        &["cheeses"],
        &["cheetah"],
        &["cheetos"],
        &["cheeseburger"],
        &["cheeseburgers"],
        &["cheesecake"],
    ],
    range: 2..=10,
};

static WORD_CHED_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CHED_CHILDREN),
    value: None,
};

pub static WORD_CHED_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("uling")],
    values: &[&["scheduling"]],
    range: 5..=5,
};

static WORD_CHEC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CHEC_CHILDREN),
    value: Some(&["check"]),
};

pub static WORD_CHEC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("box"),
        dictgen::InsensitiveStr::Ascii("boxes"),
        dictgen::InsensitiveStr::Ascii("ck"),
        dictgen::InsensitiveStr::Ascii("g"),
        dictgen::InsensitiveStr::Ascii("ged"),
        dictgen::InsensitiveStr::Ascii("h"),
        dictgen::InsensitiveStr::Ascii("heckpoit"),
        dictgen::InsensitiveStr::Ascii("heckpoits"),
        dictgen::InsensitiveStr::Ascii("hed"),
        dictgen::InsensitiveStr::Ascii("hing"),
        dictgen::InsensitiveStr::Ascii("hk"),
        dictgen::InsensitiveStr::Ascii("hpoint"),
        dictgen::InsensitiveStr::Ascii("hs"),
        dictgen::InsensitiveStr::Ascii("kalaises"),
        dictgen::InsensitiveStr::Ascii("kare"),
        dictgen::InsensitiveStr::Ascii("kcsum"),
        dictgen::InsensitiveStr::Ascii("kd"),
        dictgen::InsensitiveStr::Ascii("kear"),
        dictgen::InsensitiveStr::Ascii("kes"),
        dictgen::InsensitiveStr::Ascii("ket"),
        dictgen::InsensitiveStr::Ascii("kk"),
        dictgen::InsensitiveStr::Ascii("kmeat"),
        dictgen::InsensitiveStr::Ascii("kng"),
        dictgen::InsensitiveStr::Ascii("koslovakia"),
        dictgen::InsensitiveStr::Ascii("kox"),
        dictgen::InsensitiveStr::Ascii("kpiont"),
        dictgen::InsensitiveStr::Ascii("kpoing"),
        dictgen::InsensitiveStr::Ascii("kpoins"),
        dictgen::InsensitiveStr::Ascii("kpointusa"),
        dictgen::InsensitiveStr::Ascii("kpoit"),
        dictgen::InsensitiveStr::Ascii("kponts"),
        dictgen::InsensitiveStr::Ascii("ksm"),
        dictgen::InsensitiveStr::Ascii("ksms"),
        dictgen::InsensitiveStr::Ascii("kstum"),
        dictgen::InsensitiveStr::Ascii("kstuming"),
        dictgen::InsensitiveStr::Ascii("kstumming"),
        dictgen::InsensitiveStr::Ascii("kstums"),
        dictgen::InsensitiveStr::Ascii("ksume"),
        dictgen::InsensitiveStr::Ascii("ksumed"),
        dictgen::InsensitiveStr::Ascii("ksuming"),
        dictgen::InsensitiveStr::Ascii("kt"),
        dictgen::InsensitiveStr::Ascii("kts"),
        dictgen::InsensitiveStr::Ascii("kum"),
        dictgen::InsensitiveStr::Ascii("kums"),
        dictgen::InsensitiveStr::Ascii("kuot"),
        dictgen::InsensitiveStr::Ascii("l"),
        dictgen::InsensitiveStr::Ascii("led"),
        dictgen::InsensitiveStr::Ascii("ling"),
        dictgen::InsensitiveStr::Ascii("ls"),
    ],
    values: &[
        &["checkbox"],
        &["checkboxes"],
        &["check"],
        &["check"],
        &["checked"],
        &["check", "czech"],
        &["checkpoint"],
        &["checkpoints"],
        &["checked"],
        &["checking"],
        &["check"],
        &["checkpoint"],
        &["checks"],
        &["checkaliases"],
        &["checker"],
        &["checksum"],
        &["checked"],
        &["checker"],
        &["checks"],
        &["checked"],
        &["check"],
        &["checkmate"],
        &["checking"],
        &["czechoslovakia"],
        &["checkbox"],
        &["checkpoint"],
        &["checkpoint"],
        &["checkpoints"],
        &["checkpoints"],
        &["checkpoints"],
        &["checkpoints"],
        &["checksum"],
        &["checksums"],
        &["checksum"],
        &["checksumming"],
        &["checksumming"],
        &["checksums"],
        &["checksum"],
        &["checksummed"],
        &["checksumming"],
        &["checked"],
        &["checked", "checks"],
        &["checksum"],
        &["checksums"],
        &["checkout"],
        &["check"],
        &["checked"],
        &["checking"],
        &["checks"],
    ],
    range: 1..=10,
};

static WORD_CHEA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CHEA_CHILDREN),
    value: None,
};

pub static WORD_CHEA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("peast"),
        dictgen::InsensitiveStr::Ascii("tta"),
    ],
    values: &[&["cheapest"], &["cheetah"]],
    range: 3..=5,
};

static WORD_CHC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CHC_CHILDREN),
    value: None,
};

pub static WORD_CHC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ek"),
        dictgen::InsensitiveStr::Ascii("eked"),
        dictgen::InsensitiveStr::Ascii("eking"),
        dictgen::InsensitiveStr::Ascii("eks"),
        dictgen::InsensitiveStr::Ascii("k"),
        dictgen::InsensitiveStr::Ascii("kbox"),
        dictgen::InsensitiveStr::Ascii("ukles"),
    ],
    values: &[
        &["check"],
        &["checked"],
        &["checking"],
        &["checks"],
        &["check"],
        &["checkbox"],
        &["chuckles"],
    ],
    range: 1..=5,
};

static WORD_CHA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_CHA_CHILDREN),
    value: None,
};

static WORD_CHA_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_CHAA_NODE),
    None,
    Some(&WORD_CHAC_NODE),
    None,
    Some(&WORD_CHAE_NODE),
    None,
    Some(&WORD_CHAG_NODE),
    Some(&WORD_CHAH_NODE),
    Some(&WORD_CHAI_NODE),
    None,
    None,
    Some(&WORD_CHAL_NODE),
    Some(&WORD_CHAM_NODE),
    Some(&WORD_CHAN_NODE),
    None,
    Some(&WORD_CHAP_NODE),
    None,
    Some(&WORD_CHAR_NODE),
    Some(&WORD_CHAS_NODE),
    Some(&WORD_CHAT_NODE),
    None,
    None,
    Some(&WORD_CHAW_NODE),
    None,
    None,
    None,
];

static WORD_CHAW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CHAW_CHILDREN),
    value: None,
};

pub static WORD_CHAW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("k")],
    values: &[&["chalk"]],
    range: 1..=1,
};

static WORD_CHAT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CHAT_CHILDREN),
    value: None,
};

pub static WORD_CHAT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("acter"),
        dictgen::InsensitiveStr::Ascii("acters"),
        dictgen::InsensitiveStr::Ascii("ch"),
        dictgen::InsensitiveStr::Ascii("ched"),
        dictgen::InsensitiveStr::Ascii("eao"),
        dictgen::InsensitiveStr::Ascii("eaos"),
        dictgen::InsensitiveStr::Ascii("edral"),
        dictgen::InsensitiveStr::Ascii("eo"),
        dictgen::InsensitiveStr::Ascii("eos"),
        dictgen::InsensitiveStr::Ascii("er"),
        dictgen::InsensitiveStr::Ascii("oic"),
        dictgen::InsensitiveStr::Ascii("olic"),
        dictgen::InsensitiveStr::Ascii("olics"),
        dictgen::InsensitiveStr::Ascii("ou"),
        dictgen::InsensitiveStr::Ascii("ous"),
        dictgen::InsensitiveStr::Ascii("ow"),
        dictgen::InsensitiveStr::Ascii("ows"),
    ],
    values: &[
        &["character"],
        &["characters"],
        &["catch"],
        &["caught", "chatted"],
        &["château"],
        &["châteaux"],
        &["cathedral"],
        &["château"],
        &["châteaux"],
        &["chapter"],
        &["chaotic"],
        &["catholic"],
        &["catholics"],
        &["château"],
        &["châteaux"],
        &["château"],
        &["châteaux"],
    ],
    range: 2..=6,
};

static WORD_CHAS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CHAS_CHILDREN),
    value: None,
};

pub static WORD_CHAS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("iers"),
        dictgen::InsensitiveStr::Ascii("im"),
        dictgen::InsensitiveStr::Ascii("ims"),
        dictgen::InsensitiveStr::Ascii("iss"),
        dictgen::InsensitiveStr::Ascii("nge"),
        dictgen::InsensitiveStr::Ascii("r"),
        dictgen::InsensitiveStr::Ascii("sids"),
        dictgen::InsensitiveStr::Ascii("sies"),
        dictgen::InsensitiveStr::Ascii("sim"),
        dictgen::InsensitiveStr::Ascii("sims"),
        dictgen::InsensitiveStr::Ascii("sm"),
        dictgen::InsensitiveStr::Ascii("sms"),
        dictgen::InsensitiveStr::Ascii("sy"),
    ],
    values: &[
        &["cashiers"],
        &["chasm"],
        &["chasms"],
        &["chassis"],
        &["change", "changes"],
        &["chaser", "chase"],
        &["chassis"],
        &["chassis"],
        &["chasm"],
        &["chasms"],
        &["chasm"],
        &["chasms"],
        &["chassis"],
    ],
    range: 1..=4,
};

static WORD_CHAR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_CHAR_CHILDREN),
    value: None,
};

static WORD_CHAR_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_CHARA_NODE),
    None,
    Some(&WORD_CHARC_NODE),
    None,
    Some(&WORD_CHARE_NODE),
    None,
    Some(&WORD_CHARG_NODE),
    None,
    Some(&WORD_CHARI_NODE),
    None,
    None,
    None,
    Some(&WORD_CHARM_NODE),
    None,
    Some(&WORD_CHARO_NODE),
    None,
    None,
    None,
    Some(&WORD_CHARS_NODE),
    Some(&WORD_CHART_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_CHART_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CHART_CHILDREN),
    value: None,
};

pub static WORD_CHART_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("iable"),
        dictgen::InsensitiveStr::Ascii("roose"),
    ],
    values: &[&["charitable"], &["chartreuse"]],
    range: 5..=5,
};

static WORD_CHARS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CHARS_CHILDREN),
    value: None,
};

pub static WORD_CHARS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ima"),
        dictgen::InsensitiveStr::Ascii("imatic"),
    ],
    values: &[&["charisma"], &["charismatic"]],
    range: 3..=6,
};

static WORD_CHARO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CHARO_CHILDREN),
    value: None,
};

pub static WORD_CHARO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("cal")],
    values: &[&["charcoal"]],
    range: 3..=3,
};

static WORD_CHARM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CHARM_CHILDREN),
    value: None,
};

pub static WORD_CHARM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("isa")],
    values: &[&["charisma"]],
    range: 3..=3,
};

static WORD_CHARI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CHARI_CHILDREN),
    value: None,
};

pub static WORD_CHARI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cter"),
        dictgen::InsensitiveStr::Ascii("cterization"),
        dictgen::InsensitiveStr::Ascii("cterized"),
        dictgen::InsensitiveStr::Ascii("cters"),
        dictgen::InsensitiveStr::Ascii("ctor"),
        dictgen::InsensitiveStr::Ascii("ctors"),
        dictgen::InsensitiveStr::Ascii("man"),
        dictgen::InsensitiveStr::Ascii("mastic"),
        dictgen::InsensitiveStr::Ascii("msa"),
        dictgen::InsensitiveStr::Ascii("sa"),
        dictgen::InsensitiveStr::Ascii("smastic"),
        dictgen::InsensitiveStr::Ascii("smatisch"),
        dictgen::InsensitiveStr::Ascii("stics"),
        dictgen::InsensitiveStr::Ascii("tible"),
        dictgen::InsensitiveStr::Ascii("zma"),
    ],
    values: &[
        &["character"],
        &["characterization"],
        &["characterized"],
        &["characters"],
        &["character"],
        &["characters"],
        &["chairman"],
        &["charismatic"],
        &["charisma"],
        &["charisma"],
        &["charismatic"],
        &["charismatic"],
        &["characteristics"],
        &["charitable"],
        &["charisma"],
    ],
    range: 2..=11,
};

static WORD_CHARG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CHARG_CHILDREN),
    value: None,
};

pub static WORD_CHARG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ehr"),
        dictgen::InsensitiveStr::Ascii("eur"),
        dictgen::InsensitiveStr::Ascii("ind"),
    ],
    values: &[&["charger"], &["charger"], &["charging"]],
    range: 3..=3,
};

static WORD_CHARE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CHARE_CHILDREN),
    value: None,
};

pub static WORD_CHARE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cter"),
        dictgen::InsensitiveStr::Ascii("cteristic"),
        dictgen::InsensitiveStr::Ascii("cteristics"),
        dictgen::InsensitiveStr::Ascii("cterization"),
        dictgen::InsensitiveStr::Ascii("cters"),
        dictgen::InsensitiveStr::Ascii("ctor"),
    ],
    values: &[
        &["character"],
        &["characteristic"],
        &["characteristics"],
        &["characterization"],
        &["characters"],
        &["character"],
    ],
    range: 4..=11,
};

static WORD_CHARC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CHARC_CHILDREN),
    value: None,
};

pub static WORD_CHARC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aol"),
        dictgen::InsensitiveStr::Ascii("ater"),
        dictgen::InsensitiveStr::Ascii("aters"),
        dictgen::InsensitiveStr::Ascii("ol"),
        dictgen::InsensitiveStr::Ascii("ter"),
        dictgen::InsensitiveStr::Ascii("teristic"),
        dictgen::InsensitiveStr::Ascii("teristics"),
        dictgen::InsensitiveStr::Ascii("ters"),
        dictgen::InsensitiveStr::Ascii("tor"),
        dictgen::InsensitiveStr::Ascii("tors"),
    ],
    values: &[
        &["charcoal"],
        &["character"],
        &["characters"],
        &["charcoal"],
        &["character"],
        &["characteristic"],
        &["characteristics"],
        &["characters"],
        &["character"],
        &["characters"],
    ],
    range: 2..=9,
};

static WORD_CHARA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_CHARA_CHILDREN),
    value: None,
};

static WORD_CHARA_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    Some(&WORD_CHARAC_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_CHARAK_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_CHARAR_NODE),
    Some(&WORD_CHARAS_NODE),
    Some(&WORD_CHARAT_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_CHARAT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CHARAT_CHILDREN),
    value: None,
};

pub static WORD_CHARAT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("able"),
        dictgen::InsensitiveStr::Ascii("er"),
        dictgen::InsensitiveStr::Ascii("erize"),
        dictgen::InsensitiveStr::Ascii("erized"),
        dictgen::InsensitiveStr::Ascii("ers"),
        dictgen::InsensitiveStr::Ascii("or"),
        dictgen::InsensitiveStr::Ascii("ors"),
    ],
    values: &[
        &["charitable"],
        &["character"],
        &["characterize"],
        &["characterized"],
        &["characters"],
        &["character"],
        &["characters"],
    ],
    range: 2..=6,
};

static WORD_CHARAS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CHARAS_CHILDREN),
    value: Some(&["chars"]),
};

pub static WORD_CHARAS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cter"),
        dictgen::InsensitiveStr::Ascii("cters"),
        dictgen::InsensitiveStr::Ascii("et"),
        dictgen::InsensitiveStr::Ascii("ets"),
        dictgen::InsensitiveStr::Ascii("matic"),
        dictgen::InsensitiveStr::Ascii("teristic"),
    ],
    values: &[
        &["character"],
        &["characters"],
        &["charset"],
        &["charsets"],
        &["charismatic"],
        &["characteristics"],
    ],
    range: 2..=8,
};

static WORD_CHARAR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CHARAR_CHILDREN),
    value: None,
};

pub static WORD_CHARAR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("acter"),
        dictgen::InsensitiveStr::Ascii("acters"),
        dictgen::InsensitiveStr::Ascii("cter"),
        dictgen::InsensitiveStr::Ascii("cters"),
    ],
    values: &[
        &["character"],
        &["characters"],
        &["character"],
        &["characters"],
    ],
    range: 4..=6,
};

static WORD_CHARAK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CHARAK_CHILDREN),
    value: None,
};

pub static WORD_CHARAK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ter"),
        dictgen::InsensitiveStr::Ascii("ters"),
    ],
    values: &[&["character"], &["characters"]],
    range: 3..=4,
};

static WORD_CHARAC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_CHARAC_CHILDREN),
    value: None,
};

static WORD_CHARAC_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_CHARACA_NODE),
    None,
    None,
    None,
    Some(&WORD_CHARACE_NODE),
    None,
    None,
    Some(&WORD_CHARACH_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_CHARACS_NODE),
    Some(&WORD_CHARACT_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_CHARACT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_CHARACT_CHILDREN),
    value: None,
};

static WORD_CHARACT_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_CHARACTA_NODE),
    None,
    None,
    None,
    Some(&WORD_CHARACTE_NODE),
    None,
    None,
    Some(&WORD_CHARACTH_NODE),
    Some(&WORD_CHARACTI_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_CHARACTO_NODE),
    None,
    None,
    Some(&WORD_CHARACTR_NODE),
    Some(&WORD_CHARACTS_NODE),
    None,
    Some(&WORD_CHARACTU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_CHARACTU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CHARACTU_CHILDREN),
    value: None,
};

pub static WORD_CHARACTU_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[dictgen::InsensitiveStr::Ascii("re")],
        values: &[&["character"]],
        range: 2..=2,
    };

static WORD_CHARACTS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CHARACTS_CHILDREN),
    value: Some(&["characters"]),
};

pub static WORD_CHARACTS_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[],
        values: &[],
        range: 0..=0,
    };

static WORD_CHARACTR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CHARACTR_CHILDREN),
    value: None,
};

pub static WORD_CHARACTR_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("istic"),
            dictgen::InsensitiveStr::Ascii("istically"),
            dictgen::InsensitiveStr::Ascii("istics"),
            dictgen::InsensitiveStr::Ascii("s"),
        ],
        values: &[
            &["characteristic"],
            &["characteristically"],
            &["characteristics"],
            &["characters"],
        ],
        range: 1..=9,
    };

static WORD_CHARACTO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CHARACTO_CHILDREN),
    value: None,
};

pub static WORD_CHARACTO_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("r"),
            dictgen::InsensitiveStr::Ascii("ristics"),
            dictgen::InsensitiveStr::Ascii("rs"),
        ],
        values: &[&["character"], &["characteristics"], &["characters"]],
        range: 1..=7,
    };

static WORD_CHARACTI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CHARACTI_CHILDREN),
    value: None,
};

pub static WORD_CHARACTI_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("ristic"),
            dictgen::InsensitiveStr::Ascii("ristically"),
            dictgen::InsensitiveStr::Ascii("ristics"),
        ],
        values: &[
            &["characteristic"],
            &["characteristically"],
            &["characteristics"],
        ],
        range: 6..=10,
    };

static WORD_CHARACTH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CHARACTH_CHILDREN),
    value: None,
};

pub static WORD_CHARACTH_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[dictgen::InsensitiveStr::Ascii("er")],
        values: &[&["character"]],
        range: 2..=2,
    };

static WORD_CHARACTE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CHARACTE_CHILDREN),
    value: Some(&["character"]),
};

pub static WORD_CHARACTE_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("ar"),
            dictgen::InsensitiveStr::Ascii("ars"),
            dictgen::InsensitiveStr::Ascii("d"),
            dictgen::InsensitiveStr::Ascii("ds"),
            dictgen::InsensitiveStr::Ascii("er"),
            dictgen::InsensitiveStr::Ascii("ers"),
            dictgen::InsensitiveStr::Ascii("isation"),
            dictgen::InsensitiveStr::Ascii("ization"),
            dictgen::InsensitiveStr::Ascii("or"),
            dictgen::InsensitiveStr::Ascii("ors"),
            dictgen::InsensitiveStr::Ascii("razation"),
            dictgen::InsensitiveStr::Ascii("re"),
            dictgen::InsensitiveStr::Ascii("res"),
            dictgen::InsensitiveStr::Ascii("risic"),
            dictgen::InsensitiveStr::Ascii("risically"),
            dictgen::InsensitiveStr::Ascii("risicly"),
            dictgen::InsensitiveStr::Ascii("risics"),
            dictgen::InsensitiveStr::Ascii("risitc"),
            dictgen::InsensitiveStr::Ascii("risitcs"),
            dictgen::InsensitiveStr::Ascii("risitic"),
            dictgen::InsensitiveStr::Ascii("risitics"),
            dictgen::InsensitiveStr::Ascii("ristc"),
            dictgen::InsensitiveStr::Ascii("ristcs"),
            dictgen::InsensitiveStr::Ascii("risticly"),
            dictgen::InsensitiveStr::Ascii("rists"),
            dictgen::InsensitiveStr::Ascii("ristsics"),
            dictgen::InsensitiveStr::Ascii("ritic"),
            dictgen::InsensitiveStr::Ascii("ritics"),
            dictgen::InsensitiveStr::Ascii("ritisc"),
            dictgen::InsensitiveStr::Ascii("ritiscs"),
            dictgen::InsensitiveStr::Ascii("rizarion"),
            dictgen::InsensitiveStr::Ascii("rizaton"),
            dictgen::InsensitiveStr::Ascii("rsistic"),
            dictgen::InsensitiveStr::Ascii("rsistically"),
            dictgen::InsensitiveStr::Ascii("rsistics"),
            dictgen::InsensitiveStr::Ascii("rsitic"),
            dictgen::InsensitiveStr::Ascii("rsitics"),
            dictgen::InsensitiveStr::Ascii("rsm"),
            dictgen::InsensitiveStr::Ascii("rss"),
            dictgen::InsensitiveStr::Ascii("rstic"),
            dictgen::InsensitiveStr::Ascii("rstically"),
            dictgen::InsensitiveStr::Ascii("rstics"),
            dictgen::InsensitiveStr::Ascii("rtistic"),
            dictgen::InsensitiveStr::Ascii("rtistically"),
            dictgen::InsensitiveStr::Ascii("rtistics"),
            dictgen::InsensitiveStr::Ascii("rz"),
            dictgen::InsensitiveStr::Ascii("s"),
            dictgen::InsensitiveStr::Ascii("t"),
            dictgen::InsensitiveStr::Ascii("ter"),
            dictgen::InsensitiveStr::Ascii("teristic"),
            dictgen::InsensitiveStr::Ascii("teristics"),
            dictgen::InsensitiveStr::Ascii("ters"),
            dictgen::InsensitiveStr::Ascii("tistic"),
            dictgen::InsensitiveStr::Ascii("tistics"),
            dictgen::InsensitiveStr::Ascii("tr"),
            dictgen::InsensitiveStr::Ascii("trs"),
            dictgen::InsensitiveStr::Ascii("ts"),
        ],
        values: &[
            &["character"],
            &["characters"],
            &["character"],
            &["characters"],
            &["character"],
            &["characters"],
            &["characterisation"],
            &["characterization"],
            &["character"],
            &["characters"],
            &["characterization"],
            &["characterize"],
            &["characters"],
            &["characteristic"],
            &["characteristically"],
            &["characteristically"],
            &["characteristics"],
            &["characteristics"],
            &["characteristics"],
            &["characteristic"],
            &["characteristics"],
            &["characteristics"],
            &["characteristics"],
            &["characteristically"],
            &["characteristics"],
            &["characteristic"],
            &["characteristic"],
            &["characteristic", "characteristics"],
            &["characteristic"],
            &["characteristics"],
            &["characterization"],
            &["characterization"],
            &["characteristic"],
            &["characteristically"],
            &["characteristics"],
            &["characteristics", "characteristic"],
            &["characteristics"],
            &["characters"],
            &["characters"],
            &["characteristic"],
            &["characteristically"],
            &["characteristics"],
            &["characteristic"],
            &["characteristically"],
            &["characteristics"],
            &["characterize"],
            &["characters"],
            &["character"],
            &["character"],
            &["characteristic"],
            &["characteristics"],
            &["characters"],
            &["characteristic"],
            &["characteristics"],
            &["character"],
            &["characters"],
            &["characters"],
        ],
        range: 1..=11,
    };

static WORD_CHARACTA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CHARACTA_CHILDREN),
    value: None,
};

pub static WORD_CHARACTA_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("r"),
            dictgen::InsensitiveStr::Ascii("ristic"),
            dictgen::InsensitiveStr::Ascii("ristics"),
            dictgen::InsensitiveStr::Ascii("rization"),
            dictgen::InsensitiveStr::Ascii("rize"),
            dictgen::InsensitiveStr::Ascii("rized"),
            dictgen::InsensitiveStr::Ascii("rs"),
        ],
        values: &[
            &["character"],
            &["characteristic"],
            &["characteristics"],
            &["characterization"],
            &["characterize"],
            &["characterized"],
            &["characters"],
        ],
        range: 1..=8,
    };

static WORD_CHARACS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CHARACS_CHILDREN),
    value: None,
};

pub static WORD_CHARACS_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[dictgen::InsensitiveStr::Ascii("tyle")],
        values: &[&["charstyle"]],
        range: 4..=4,
    };

static WORD_CHARACH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CHARACH_CHILDREN),
    value: None,
};

pub static WORD_CHARACH_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("er"),
            dictgen::InsensitiveStr::Ascii("ers"),
            dictgen::InsensitiveStr::Ascii("ter"),
            dictgen::InsensitiveStr::Ascii("ters"),
        ],
        values: &[
            &["character"],
            &["characters"],
            &["character"],
            &["characters"],
        ],
        range: 2..=4,
    };

static WORD_CHARACE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CHARACE_CHILDREN),
    value: None,
};

pub static WORD_CHARACE_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("r"),
            dictgen::InsensitiveStr::Ascii("rs"),
            dictgen::InsensitiveStr::Ascii("ter"),
            dictgen::InsensitiveStr::Ascii("ters"),
            dictgen::InsensitiveStr::Ascii("trs"),
        ],
        values: &[
            &["character"],
            &["characters"],
            &["character"],
            &["characters"],
            &["characters"],
        ],
        range: 1..=4,
    };

static WORD_CHARACA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CHARACA_CHILDREN),
    value: None,
};

pub static WORD_CHARACA_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("ter"),
            dictgen::InsensitiveStr::Ascii("ters"),
        ],
        values: &[&["caricature", "character"], &["characters"]],
        range: 3..=4,
    };

static WORD_CHAP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CHAP_CHILDREN),
    value: None,
};

pub static WORD_CHAP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("er")],
    values: &[&["chapter"]],
    range: 2..=2,
};

static WORD_CHAN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CHAN_CHILDREN),
    value: None,
};

pub static WORD_CHAN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("age"),
        dictgen::InsensitiveStr::Ascii("aged"),
        dictgen::InsensitiveStr::Ascii("ager"),
        dictgen::InsensitiveStr::Ascii("ages"),
        dictgen::InsensitiveStr::Ascii("aging"),
        dictgen::InsensitiveStr::Ascii("celed"),
        dictgen::InsensitiveStr::Ascii("celing"),
        dictgen::InsensitiveStr::Ascii("celler"),
        dictgen::InsensitiveStr::Ascii("cellour"),
        dictgen::InsensitiveStr::Ascii("ched"),
        dictgen::InsensitiveStr::Ascii("cillor"),
        dictgen::InsensitiveStr::Ascii("cnel"),
        dictgen::InsensitiveStr::Ascii("daleer"),
        dictgen::InsensitiveStr::Ascii("daleers"),
        dictgen::InsensitiveStr::Ascii("dalier"),
        dictgen::InsensitiveStr::Ascii("daliers"),
        dictgen::InsensitiveStr::Ascii("deleer"),
        dictgen::InsensitiveStr::Ascii("deleers"),
        dictgen::InsensitiveStr::Ascii("dlure"),
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("eged"),
        dictgen::InsensitiveStr::Ascii("eging"),
        dictgen::InsensitiveStr::Ascii("el"),
        dictgen::InsensitiveStr::Ascii("ell"),
        dictgen::InsensitiveStr::Ascii("els"),
        dictgen::InsensitiveStr::Ascii("gable"),
        dictgen::InsensitiveStr::Ascii("geble"),
        dictgen::InsensitiveStr::Ascii("gee"),
        dictgen::InsensitiveStr::Ascii("geing"),
        dictgen::InsensitiveStr::Ascii("gge"),
        dictgen::InsensitiveStr::Ascii("gged"),
        dictgen::InsensitiveStr::Ascii("ggeling"),
        dictgen::InsensitiveStr::Ascii("gges"),
        dictgen::InsensitiveStr::Ascii("gin"),
        dictgen::InsensitiveStr::Ascii("gings"),
        dictgen::InsensitiveStr::Ascii("glog"),
        dictgen::InsensitiveStr::Ascii("guing"),
        dictgen::InsensitiveStr::Ascii("ined"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("inging"),
        dictgen::InsensitiveStr::Ascii("isaw"),
        dictgen::InsensitiveStr::Ascii("lder"),
        dictgen::InsensitiveStr::Ascii("llenge"),
        dictgen::InsensitiveStr::Ascii("llenging"),
        dictgen::InsensitiveStr::Ascii("nael"),
        dictgen::InsensitiveStr::Ascii("ne"),
        dictgen::InsensitiveStr::Ascii("neles"),
        dictgen::InsensitiveStr::Ascii("nes"),
        dictgen::InsensitiveStr::Ascii("nge"),
        dictgen::InsensitiveStr::Ascii("nged"),
        dictgen::InsensitiveStr::Ascii("nges"),
        dictgen::InsensitiveStr::Ascii("nging"),
        dictgen::InsensitiveStr::Ascii("nl"),
        dictgen::InsensitiveStr::Ascii("nle"),
        dictgen::InsensitiveStr::Ascii("nles"),
        dictgen::InsensitiveStr::Ascii("nnel"),
        dictgen::InsensitiveStr::Ascii("nnels"),
        dictgen::InsensitiveStr::Ascii("pionship"),
        dictgen::InsensitiveStr::Ascii("pionships"),
        dictgen::InsensitiveStr::Ascii("sellor"),
        dictgen::InsensitiveStr::Ascii("ses"),
    ],
    values: &[
        &["change"],
        &["changed"],
        &["changer"],
        &["changes"],
        &["changing"],
        &["canceled"],
        &["canceling"],
        &["chancellor"],
        &["chancellor"],
        &["changed"],
        &["chancellor"],
        &["channel", "cancel"],
        &["chandelier"],
        &["chandeliers"],
        &["chandelier"],
        &["chandeliers"],
        &["chandelier"],
        &["chandeliers"],
        &["chandler"],
        &["change", "chain"],
        &["changed", "chained"],
        &["changed"],
        &["changing"],
        &["channel"],
        &["channel"],
        &["channels"],
        &["changeable"],
        &["changeable"],
        &["change", "changed", "changes"],
        &["changing"],
        &["change"],
        &["changed"],
        &["changeling"],
        &["changes"],
        &["changing"],
        &["changes"],
        &["changelog"],
        &["changing"],
        &["chained"],
        &["chaining", "changing"],
        &["changing"],
        &["chainsaw"],
        &["chandler"],
        &["challenge"],
        &["challenging"],
        &["channel"],
        &["channel"],
        &["channels"],
        &["channels", "chances", "changes"],
        &["change"],
        &["changed"],
        &["changes"],
        &["changing"],
        &["channel"],
        &["channel"],
        &["channels"],
        &["channel"],
        &["channels"],
        &["championship"],
        &["championships"],
        &["chancellor"],
        &["chances"],
    ],
    range: 1..=9,
};

static WORD_CHAM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CHAM_CHILDREN),
    value: None,
};

pub static WORD_CHAM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("bear"),
        dictgen::InsensitiveStr::Ascii("bre"),
        dictgen::InsensitiveStr::Ascii("bres"),
        dictgen::InsensitiveStr::Ascii("eleooon"),
        dictgen::InsensitiveStr::Ascii("eloen"),
        dictgen::InsensitiveStr::Ascii("iponship"),
        dictgen::InsensitiveStr::Ascii("page"),
        dictgen::InsensitiveStr::Ascii("pagen"),
        dictgen::InsensitiveStr::Ascii("pain"),
        dictgen::InsensitiveStr::Ascii("pane"),
        dictgen::InsensitiveStr::Ascii("pange"),
        dictgen::InsensitiveStr::Ascii("pinoship"),
        dictgen::InsensitiveStr::Ascii("pionchip"),
        dictgen::InsensitiveStr::Ascii("pionchips"),
        dictgen::InsensitiveStr::Ascii("pionshiop"),
        dictgen::InsensitiveStr::Ascii("pionshp"),
        dictgen::InsensitiveStr::Ascii("pionsihp"),
        dictgen::InsensitiveStr::Ascii("pionsip"),
        dictgen::InsensitiveStr::Ascii("pionsips"),
        dictgen::InsensitiveStr::Ascii("pionsship"),
        dictgen::InsensitiveStr::Ascii("piosnhip"),
        dictgen::InsensitiveStr::Ascii("poinship"),
    ],
    values: &[
        &["chamber"],
        &["chamber"],
        &["chambers"],
        &["chameleon"],
        &["chameleon"],
        &["championships"],
        &["champagne"],
        &["champagne"],
        &["champagne"],
        &["champagne"],
        &["champagne"],
        &["championships"],
        &["championship"],
        &["championship"],
        &["championships"],
        &["championship"],
        &["championships"],
        &["championship"],
        &["championships"],
        &["championships"],
        &["championships"],
        &["championship"],
    ],
    range: 3..=9,
};

static WORD_CHAL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CHAL_CHILDREN),
    value: None,
};

pub static WORD_CHAL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("enging"),
        dictgen::InsensitiveStr::Ascii("lanage"),
        dictgen::InsensitiveStr::Ascii("lange"),
        dictgen::InsensitiveStr::Ascii("langed"),
        dictgen::InsensitiveStr::Ascii("langes"),
        dictgen::InsensitiveStr::Ascii("langing"),
        dictgen::InsensitiveStr::Ascii("lege"),
        dictgen::InsensitiveStr::Ascii("legner"),
        dictgen::InsensitiveStr::Ascii("lender"),
        dictgen::InsensitiveStr::Ascii("leneged"),
        dictgen::InsensitiveStr::Ascii("leneger"),
        dictgen::InsensitiveStr::Ascii("leneges"),
        dictgen::InsensitiveStr::Ascii("lengeing"),
        dictgen::InsensitiveStr::Ascii("lengr"),
        dictgen::InsensitiveStr::Ascii("lengs"),
        dictgen::InsensitiveStr::Ascii("lengue"),
        dictgen::InsensitiveStr::Ascii("lengur"),
        dictgen::InsensitiveStr::Ascii("lening"),
        dictgen::InsensitiveStr::Ascii("lneger"),
    ],
    values: &[
        &["challenging"],
        &["challenge"],
        &["challenge"],
        &["challenged"],
        &["challenges"],
        &["challenging"],
        &["challenge"],
        &["challenger"],
        &["challenger"],
        &["challenged"],
        &["challenger"],
        &["challenges"],
        &["challenging"],
        &["challenger"],
        &["challenges"],
        &["challenger"],
        &["challenger"],
        &["challenging"],
        &["challenger"],
    ],
    range: 4..=8,
};

static WORD_CHAI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CHAI_CHILDREN),
    value: None,
};

pub static WORD_CHAI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("ng"),
        dictgen::InsensitiveStr::Ascii("rmain"),
        dictgen::InsensitiveStr::Ascii("rtable"),
    ],
    values: &[&["chained"], &["chain"], &["chairman"], &["charitable"]],
    range: 2..=6,
};

static WORD_CHAH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CHAH_CHILDREN),
    value: None,
};

pub static WORD_CHAH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ged"),
        dictgen::InsensitiveStr::Ascii("ging"),
    ],
    values: &[&["changed"], &["changing"]],
    range: 3..=4,
};

static WORD_CHAG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CHAG_CHILDREN),
    value: None,
};

pub static WORD_CHAG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("ne"),
        dictgen::InsensitiveStr::Ascii("ned"),
        dictgen::InsensitiveStr::Ascii("nes"),
    ],
    values: &[
        &["change", "charge"],
        &["changed", "charged"],
        &["changes", "charges"],
        &["changing", "charging"],
        &["change"],
        &["changed"],
        &["changes"],
    ],
    range: 1..=3,
};

static WORD_CHAE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CHAE_CHILDREN),
    value: None,
};

pub static WORD_CHAE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ck"),
        dictgen::InsensitiveStr::Ascii("cked"),
        dictgen::InsensitiveStr::Ascii("cker"),
        dictgen::InsensitiveStr::Ascii("cking"),
        dictgen::InsensitiveStr::Ascii("cks"),
    ],
    values: &[
        &["check"],
        &["checked"],
        &["checker"],
        &["checking"],
        &["checks"],
    ],
    range: 2..=5,
};

static WORD_CHAC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CHAC_CHILDREN),
    value: None,
};

pub static WORD_CHAC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("acter"),
        dictgen::InsensitiveStr::Ascii("acters"),
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("he"),
        dictgen::InsensitiveStr::Ascii("hed"),
        dictgen::InsensitiveStr::Ascii("heline"),
    ],
    values: &[
        &["character"],
        &["characters"],
        &["cache", "chance"],
        &["cache"],
        &["cached"],
        &["cacheline"],
    ],
    range: 1..=6,
};

static WORD_CHAA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CHAA_CHILDREN),
    value: None,
};

pub static WORD_CHAA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("rcter"),
        dictgen::InsensitiveStr::Ascii("rcters"),
        dictgen::InsensitiveStr::Ascii("rges"),
    ],
    values: &[&["character"], &["characters"], &["charges"]],
    range: 4..=6,
};

static WORD_CG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CG_CHILDREN),
    value: None,
};

pub static WORD_CG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ywin")],
    values: &[&["cygwin"]],
    range: 4..=4,
};

static WORD_CE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_CE_CHILDREN),
    value: None,
};

static WORD_CE_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_CEA_NODE),
    None,
    Some(&WORD_CEC_NODE),
    Some(&WORD_CED_NODE),
    None,
    None,
    None,
    Some(&WORD_CEH_NODE),
    None,
    None,
    None,
    Some(&WORD_CEL_NODE),
    Some(&WORD_CEM_NODE),
    Some(&WORD_CEN_NODE),
    None,
    None,
    None,
    Some(&WORD_CER_NODE),
    Some(&WORD_CES_NODE),
    Some(&WORD_CET_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_CET_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CET_CHILDREN),
    value: None,
};

pub static WORD_CET_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ain"),
        dictgen::InsensitiveStr::Ascii("ainly"),
        dictgen::InsensitiveStr::Ascii("ainty"),
        dictgen::InsensitiveStr::Ascii("lics"),
        dictgen::InsensitiveStr::Ascii("rainly"),
        dictgen::InsensitiveStr::Ascii("ting"),
    ],
    values: &[
        &["certain"],
        &["certainly"],
        &["certainty"],
        &["celtics"],
        &["certainly"],
        &["setting"],
    ],
    range: 3..=6,
};

static WORD_CES_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CES_CHILDREN),
    value: None,
};

pub static WORD_CES_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("sationalism"),
        dictgen::InsensitiveStr::Ascii("sationalist"),
        dictgen::InsensitiveStr::Ascii("spol"),
        dictgen::InsensitiveStr::Ascii("spoool"),
    ],
    values: &[
        &["sensationalism"],
        &["sensationalist"],
        &["cesspool"],
        &["cesspool"],
    ],
    range: 4..=11,
};

static WORD_CER_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_CER_CHILDREN),
    value: None,
};

static WORD_CER_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_CERA_NODE),
    Some(&WORD_CERB_NODE),
    Some(&WORD_CERC_NODE),
    None,
    Some(&WORD_CERE_NODE),
    None,
    None,
    None,
    Some(&WORD_CERI_NODE),
    None,
    None,
    None,
    Some(&WORD_CERM_NODE),
    Some(&WORD_CERN_NODE),
    Some(&WORD_CERO_NODE),
    None,
    None,
    Some(&WORD_CERR_NODE),
    None,
    Some(&WORD_CERT_NODE),
    None,
    Some(&WORD_CERV_NODE),
    None,
    None,
    None,
    None,
];

static WORD_CERV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CERV_CHILDREN),
    value: None,
};

pub static WORD_CERV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ial")],
    values: &[&["cervical", "servile", "serval"]],
    range: 3..=3,
};

static WORD_CERT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_CERT_CHILDREN),
    value: None,
};

static WORD_CERT_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_CERTA_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_CERTF_NODE),
    None,
    None,
    Some(&WORD_CERTI_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_CERTI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CERTI_CHILDREN),
    value: Some(&["certificate", "certify"]),
};

pub static WORD_CERTI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ain"),
        dictgen::InsensitiveStr::Ascii("ainly"),
        dictgen::InsensitiveStr::Ascii("an"),
        dictgen::InsensitiveStr::Ascii("anly"),
        dictgen::InsensitiveStr::Ascii("anty"),
        dictgen::InsensitiveStr::Ascii("cate"),
        dictgen::InsensitiveStr::Ascii("cated"),
        dictgen::InsensitiveStr::Ascii("cates"),
        dictgen::InsensitiveStr::Ascii("cation"),
        dictgen::InsensitiveStr::Ascii("cicate"),
        dictgen::InsensitiveStr::Ascii("facte"),
        dictgen::InsensitiveStr::Ascii("facted"),
        dictgen::InsensitiveStr::Ascii("factes"),
        dictgen::InsensitiveStr::Ascii("faction"),
        dictgen::InsensitiveStr::Ascii("fcate"),
        dictgen::InsensitiveStr::Ascii("fcated"),
        dictgen::InsensitiveStr::Ascii("fcates"),
        dictgen::InsensitiveStr::Ascii("fcation"),
        dictgen::InsensitiveStr::Ascii("fciate"),
        dictgen::InsensitiveStr::Ascii("fciated"),
        dictgen::InsensitiveStr::Ascii("fciates"),
        dictgen::InsensitiveStr::Ascii("fciation"),
        dictgen::InsensitiveStr::Ascii("fiate"),
        dictgen::InsensitiveStr::Ascii("fiated"),
        dictgen::InsensitiveStr::Ascii("fiates"),
        dictgen::InsensitiveStr::Ascii("fiating"),
        dictgen::InsensitiveStr::Ascii("fiation"),
        dictgen::InsensitiveStr::Ascii("fiations"),
        dictgen::InsensitiveStr::Ascii("fic"),
        dictgen::InsensitiveStr::Ascii("ficaat"),
        dictgen::InsensitiveStr::Ascii("ficaiton"),
        dictgen::InsensitiveStr::Ascii("ficare"),
        dictgen::InsensitiveStr::Ascii("ficat"),
        dictgen::InsensitiveStr::Ascii("ficatd"),
        dictgen::InsensitiveStr::Ascii("ficatin"),
        dictgen::InsensitiveStr::Ascii("ficationkits"),
        dictgen::InsensitiveStr::Ascii("ficato"),
        dictgen::InsensitiveStr::Ascii("ficaton"),
        dictgen::InsensitiveStr::Ascii("ficats"),
        dictgen::InsensitiveStr::Ascii("fice"),
        dictgen::InsensitiveStr::Ascii("ficed"),
        dictgen::InsensitiveStr::Ascii("fices"),
        dictgen::InsensitiveStr::Ascii("ficiate"),
        dictgen::InsensitiveStr::Ascii("ficion"),
        dictgen::InsensitiveStr::Ascii("ficste"),
        dictgen::InsensitiveStr::Ascii("ficsted"),
        dictgen::InsensitiveStr::Ascii("ficstes"),
        dictgen::InsensitiveStr::Ascii("ficsting"),
        dictgen::InsensitiveStr::Ascii("ficstion"),
        dictgen::InsensitiveStr::Ascii("fificate"),
        dictgen::InsensitiveStr::Ascii("fificated"),
        dictgen::InsensitiveStr::Ascii("fificates"),
        dictgen::InsensitiveStr::Ascii("fification"),
        dictgen::InsensitiveStr::Ascii("ticate"),
        dictgen::InsensitiveStr::Ascii("ticated"),
        dictgen::InsensitiveStr::Ascii("ticates"),
        dictgen::InsensitiveStr::Ascii("tication"),
    ],
    values: &[
        &["certain"],
        &["certainly"],
        &["certain"],
        &["certainly"],
        &["certainty"],
        &["certificate"],
        &["certificated"],
        &["certificates"],
        &["certification"],
        &["certificate"],
        &["certificate"],
        &["certificated"],
        &["certificates"],
        &["certification"],
        &["certificate"],
        &["certificated"],
        &["certificates"],
        &["certification"],
        &["certificate"],
        &["certificated"],
        &["certificates"],
        &["certification"],
        &["certificate"],
        &["certificated"],
        &["certificates"],
        &["certificating"],
        &["certification"],
        &["certifications"],
        &["certificate", "certification"],
        &["certificate"],
        &["certification"],
        &["certificate"],
        &["certificate"],
        &["certificated"],
        &["certificating", "certification"],
        &["certifications"],
        &["certification"],
        &["certification"],
        &["certificates"],
        &["certificate"],
        &["certificated"],
        &["certificates"],
        &["certificate"],
        &["certification"],
        &["certificate"],
        &["certificated"],
        &["certificates"],
        &["certificating"],
        &["certification"],
        &["certificate"],
        &["certificated"],
        &["certificates"],
        &["certification"],
        &["certificate"],
        &["certificated"],
        &["certificates"],
        &["certification"],
    ],
    range: 2..=12,
};

static WORD_CERTF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CERTF_CHILDREN),
    value: None,
};

pub static WORD_CERTF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("icate"),
        dictgen::InsensitiveStr::Ascii("icated"),
        dictgen::InsensitiveStr::Ascii("icates"),
        dictgen::InsensitiveStr::Ascii("ication"),
        dictgen::InsensitiveStr::Ascii("ications"),
        dictgen::InsensitiveStr::Ascii("iciate"),
        dictgen::InsensitiveStr::Ascii("iciated"),
        dictgen::InsensitiveStr::Ascii("iciates"),
        dictgen::InsensitiveStr::Ascii("iciation"),
        dictgen::InsensitiveStr::Ascii("iciations"),
        dictgen::InsensitiveStr::Ascii("ied"),
        dictgen::InsensitiveStr::Ascii("y"),
    ],
    values: &[
        &["certificate"],
        &["certificated"],
        &["certificates"],
        &["certification"],
        &["certifications"],
        &["certificate"],
        &["certificated"],
        &["certificates"],
        &["certification"],
        &["certifications"],
        &["certified"],
        &["certify"],
    ],
    range: 1..=9,
};

static WORD_CERTA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CERTA_CHILDREN),
    value: None,
};

pub static WORD_CERTA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ily"),
        dictgen::InsensitiveStr::Ascii("incy"),
        dictgen::InsensitiveStr::Ascii("inity"),
        dictgen::InsensitiveStr::Ascii("inlyt"),
        dictgen::InsensitiveStr::Ascii("int"),
        dictgen::InsensitiveStr::Ascii("intity"),
        dictgen::InsensitiveStr::Ascii("intly"),
        dictgen::InsensitiveStr::Ascii("iny"),
        dictgen::InsensitiveStr::Ascii("ion"),
        dictgen::InsensitiveStr::Ascii("n"),
        dictgen::InsensitiveStr::Ascii("nity"),
    ],
    values: &[
        &["certainly"],
        &["certainty"],
        &["certainty"],
        &["certainty"],
        &["certain"],
        &["certainty"],
        &["certainly"],
        &["certainty"],
        &["certain"],
        &["certain"],
        &["certainty"],
    ],
    range: 1..=6,
};

static WORD_CERR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CERR_CHILDREN),
    value: None,
};

pub static WORD_CERR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ebral"),
        dictgen::InsensitiveStr::Ascii("ebrally"),
    ],
    values: &[&["cerebral"], &["cerebrally"]],
    range: 5..=7,
};

static WORD_CERO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CERO_CHILDREN),
    value: None,
};

pub static WORD_CERO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("mony")],
    values: &[&["ceremony"]],
    range: 4..=4,
};

static WORD_CERN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CERN_CHILDREN),
    value: None,
};

pub static WORD_CERN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("omial"),
        dictgen::InsensitiveStr::Ascii("omially"),
        dictgen::InsensitiveStr::Ascii("omies"),
        dictgen::InsensitiveStr::Ascii("omy"),
    ],
    values: &[
        &["ceremonial"],
        &["ceremonially"],
        &["ceremonies"],
        &["ceremony"],
    ],
    range: 3..=7,
};

static WORD_CERM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CERM_CHILDREN),
    value: None,
};

pub static WORD_CERM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aic"),
        dictgen::InsensitiveStr::Ascii("onial"),
        dictgen::InsensitiveStr::Ascii("onially"),
        dictgen::InsensitiveStr::Ascii("onies"),
        dictgen::InsensitiveStr::Ascii("ony"),
    ],
    values: &[
        &["ceramic"],
        &["ceremonial"],
        &["ceremonially"],
        &["ceremonies"],
        &["ceremony"],
    ],
    range: 3..=7,
};

static WORD_CERI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CERI_CHILDREN),
    value: None,
};

pub static WORD_CERI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ficate"),
        dictgen::InsensitiveStr::Ascii("fication"),
        dictgen::InsensitiveStr::Ascii("fications"),
        dictgen::InsensitiveStr::Ascii("fied"),
        dictgen::InsensitiveStr::Ascii("fies"),
        dictgen::InsensitiveStr::Ascii("fy"),
        dictgen::InsensitiveStr::Ascii("fying"),
        dictgen::InsensitiveStr::Ascii("monial"),
        dictgen::InsensitiveStr::Ascii("monies"),
        dictgen::InsensitiveStr::Ascii("monious"),
        dictgen::InsensitiveStr::Ascii("mony"),
        dictgen::InsensitiveStr::Ascii("nomial"),
        dictgen::InsensitiveStr::Ascii("nomially"),
        dictgen::InsensitiveStr::Ascii("nomies"),
        dictgen::InsensitiveStr::Ascii("nomy"),
        dictgen::InsensitiveStr::Ascii("tfication"),
    ],
    values: &[
        &["certificate"],
        &["verification", "certification"],
        &["certifications", "verifications"],
        &["certified", "verified"],
        &["certifies", "verifies"],
        &["certify", "verify"],
        &["certifying", "verifying"],
        &["ceremonial"],
        &["ceremonies"],
        &["ceremonious"],
        &["ceremony"],
        &["ceremonial"],
        &["ceremonially"],
        &["ceremonies"],
        &["ceremony"],
        &["certifications"],
    ],
    range: 2..=9,
};

static WORD_CERE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CERE_CHILDREN),
    value: None,
};

pub static WORD_CERE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ates"),
        dictgen::InsensitiveStr::Ascii("brawl"),
        dictgen::InsensitiveStr::Ascii("mone"),
        dictgen::InsensitiveStr::Ascii("monias"),
        dictgen::InsensitiveStr::Ascii("moniis"),
        dictgen::InsensitiveStr::Ascii("monije"),
    ],
    values: &[
        &["creates"],
        &["cerebral"],
        &["ceremonies"],
        &["ceremonies"],
        &["ceremonies"],
        &["ceremonies"],
    ],
    range: 4..=6,
};

static WORD_CERC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CERC_CHILDREN),
    value: None,
};

pub static WORD_CERC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("omstance"),
        dictgen::InsensitiveStr::Ascii("omstances"),
        dictgen::InsensitiveStr::Ascii("omstancial"),
        dictgen::InsensitiveStr::Ascii("omstantial"),
        dictgen::InsensitiveStr::Ascii("umstance"),
        dictgen::InsensitiveStr::Ascii("umstances"),
        dictgen::InsensitiveStr::Ascii("umstancial"),
        dictgen::InsensitiveStr::Ascii("umstantial"),
    ],
    values: &[
        &["circumstance"],
        &["circumstances"],
        &["circumstantial"],
        &["circumstantial"],
        &["circumstance"],
        &["circumstances"],
        &["circumstantial"],
        &["circumstantial"],
    ],
    range: 8..=10,
};

static WORD_CERB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CERB_CHILDREN),
    value: None,
};

pub static WORD_CERB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eral"),
        dictgen::InsensitiveStr::Ascii("reus"),
        dictgen::InsensitiveStr::Ascii("ures"),
    ],
    values: &[&["cerebral"], &["cerberus"], &["cerberus"]],
    range: 4..=4,
};

static WORD_CERA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CERA_CHILDREN),
    value: None,
};

pub static WORD_CERA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("in"),
        dictgen::InsensitiveStr::Ascii("inly"),
        dictgen::InsensitiveStr::Ascii("inty"),
        dictgen::InsensitiveStr::Ascii("te"),
        dictgen::InsensitiveStr::Ascii("ted"),
        dictgen::InsensitiveStr::Ascii("tine"),
    ],
    values: &[
        &["certain"],
        &["certainly"],
        &["certainty"],
        &["create"],
        &["created", "serrated"],
        &["creatine"],
    ],
    range: 2..=4,
};

static WORD_CEN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CEN_CHILDREN),
    value: None,
};

pub static WORD_CEN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ario"),
        dictgen::InsensitiveStr::Ascii("arios"),
        dictgen::InsensitiveStr::Ascii("crete"),
        dictgen::InsensitiveStr::Ascii("cretely"),
        dictgen::InsensitiveStr::Ascii("cter"),
        dictgen::InsensitiveStr::Ascii("cus"),
        dictgen::InsensitiveStr::Ascii("gter"),
        dictgen::InsensitiveStr::Ascii("itpede"),
        dictgen::InsensitiveStr::Ascii("sabilities"),
        dictgen::InsensitiveStr::Ascii("sability"),
        dictgen::InsensitiveStr::Ascii("sable"),
        dictgen::InsensitiveStr::Ascii("sably"),
        dictgen::InsensitiveStr::Ascii("sequence"),
        dictgen::InsensitiveStr::Ascii("sibility"),
        dictgen::InsensitiveStr::Ascii("sible"),
        dictgen::InsensitiveStr::Ascii("sibly"),
        dictgen::InsensitiveStr::Ascii("sorhsip"),
        dictgen::InsensitiveStr::Ascii("sur"),
        dictgen::InsensitiveStr::Ascii("surship"),
        dictgen::InsensitiveStr::Ascii("tain"),
        dictgen::InsensitiveStr::Ascii("tenal"),
        dictgen::InsensitiveStr::Ascii("tenals"),
        dictgen::InsensitiveStr::Ascii("tentenial"),
        dictgen::InsensitiveStr::Ascii("tepide"),
        dictgen::InsensitiveStr::Ascii("terd"),
        dictgen::InsensitiveStr::Ascii("teres"),
        dictgen::InsensitiveStr::Ascii("terfuge"),
        dictgen::InsensitiveStr::Ascii("terfuges"),
        dictgen::InsensitiveStr::Ascii("terns"),
        dictgen::InsensitiveStr::Ascii("tipeddle"),
        dictgen::InsensitiveStr::Ascii("tipedle"),
        dictgen::InsensitiveStr::Ascii("tipeed"),
        dictgen::InsensitiveStr::Ascii("tisencond"),
        dictgen::InsensitiveStr::Ascii("tisenconds"),
        dictgen::InsensitiveStr::Ascii("trafuge"),
        dictgen::InsensitiveStr::Ascii("trafuges"),
        dictgen::InsensitiveStr::Ascii("trase"),
        dictgen::InsensitiveStr::Ascii("trifugeable"),
        dictgen::InsensitiveStr::Ascii("trigrade"),
        dictgen::InsensitiveStr::Ascii("triod"),
        dictgen::InsensitiveStr::Ascii("triods"),
        dictgen::InsensitiveStr::Ascii("truies"),
        dictgen::InsensitiveStr::Ascii("truy"),
        dictgen::InsensitiveStr::Ascii("tuties"),
        dictgen::InsensitiveStr::Ascii("tuty"),
        dictgen::InsensitiveStr::Ascii("vention"),
        dictgen::InsensitiveStr::Ascii("ventions"),
    ],
    values: &[
        &["scenario"],
        &["scenarios"],
        &["concrete"],
        &["concretely"],
        &["center"],
        &["census"],
        &["center"],
        &["centipede"],
        &["sensibilities"],
        &["sensibility"],
        &["sensible"],
        &["sensibly"],
        &["consequence"],
        &["sensibility"],
        &["sensible"],
        &["sensibly"],
        &["censorship"],
        &["censor", "censure"],
        &["censorship"],
        &["certain"],
        &["centennial", "sentinel"],
        &["centennials", "sentinels"],
        &["centennial"],
        &["centipede"],
        &["centered"],
        &["centers"],
        &["centrifuge"],
        &["centrifuges"],
        &["centers"],
        &["centipede"],
        &["centipede"],
        &["centipede"],
        &["centisecond"],
        &["centiseconds"],
        &["centrifuge"],
        &["centrifuges"],
        &["centres"],
        &["centrifugable"],
        &["centigrade"],
        &["centroid"],
        &["centroids"],
        &["centuries"],
        &["century"],
        &["centuries"],
        &["century"],
        &["convention"],
        &["conventions"],
    ],
    range: 3..=11,
};

static WORD_CEM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CEM_CHILDREN),
    value: None,
};

pub static WORD_CEM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("entary"),
        dictgen::InsensitiveStr::Ascii("etarey"),
        dictgen::InsensitiveStr::Ascii("etaries"),
        dictgen::InsensitiveStr::Ascii("etary"),
    ],
    values: &[&["cemetery"], &["cemetery"], &["cemeteries"], &["cemetery"]],
    range: 5..=7,
};

static WORD_CEL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CEL_CHILDREN),
    value: None,
};

pub static WORD_CEL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cius"),
        dictgen::InsensitiveStr::Ascii("ebartion"),
        dictgen::InsensitiveStr::Ascii("ebirties"),
        dictgen::InsensitiveStr::Ascii("ebirty"),
        dictgen::InsensitiveStr::Ascii("ebracion"),
        dictgen::InsensitiveStr::Ascii("ebrasion"),
        dictgen::InsensitiveStr::Ascii("ebratin"),
        dictgen::InsensitiveStr::Ascii("ebratings"),
        dictgen::InsensitiveStr::Ascii("ebrationis"),
        dictgen::InsensitiveStr::Ascii("ebrationists"),
        dictgen::InsensitiveStr::Ascii("ebrato"),
        dictgen::InsensitiveStr::Ascii("ebratons"),
        dictgen::InsensitiveStr::Ascii("ebrite"),
        dictgen::InsensitiveStr::Ascii("ebrites"),
        dictgen::InsensitiveStr::Ascii("ebritites"),
        dictgen::InsensitiveStr::Ascii("ebritiy"),
        dictgen::InsensitiveStr::Ascii("esital"),
        dictgen::InsensitiveStr::Ascii("estail"),
        dictgen::InsensitiveStr::Ascii("ibrations"),
        dictgen::InsensitiveStr::Ascii("isus"),
        dictgen::InsensitiveStr::Ascii("itcs"),
        dictgen::InsensitiveStr::Ascii("labrate"),
        dictgen::InsensitiveStr::Ascii("labrated"),
        dictgen::InsensitiveStr::Ascii("labrates"),
        dictgen::InsensitiveStr::Ascii("labrating"),
        dictgen::InsensitiveStr::Ascii("labration"),
        dictgen::InsensitiveStr::Ascii("labrations"),
        dictgen::InsensitiveStr::Ascii("lebrate"),
        dictgen::InsensitiveStr::Ascii("lebrated"),
        dictgen::InsensitiveStr::Ascii("lebrates"),
        dictgen::InsensitiveStr::Ascii("lebrating"),
        dictgen::InsensitiveStr::Ascii("lebration"),
        dictgen::InsensitiveStr::Ascii("lebrations"),
        dictgen::InsensitiveStr::Ascii("ler"),
        dictgen::InsensitiveStr::Ascii("lers"),
        dictgen::InsensitiveStr::Ascii("les"),
        dictgen::InsensitiveStr::Ascii("lpading"),
        dictgen::InsensitiveStr::Ascii("lst"),
        dictgen::InsensitiveStr::Ascii("lulaire"),
        dictgen::InsensitiveStr::Ascii("lural"),
        dictgen::InsensitiveStr::Ascii("lxs"),
        dictgen::InsensitiveStr::Ascii("suis"),
        dictgen::InsensitiveStr::Ascii("ullar"),
        dictgen::InsensitiveStr::Ascii("verly"),
    ],
    values: &[
        &["celsius"],
        &["celebrations"],
        &["celebrities"],
        &["celebrity"],
        &["celebration"],
        &["celebrations"],
        &["celebration"],
        &["celebrations"],
        &["celebrations"],
        &["celebrations"],
        &["celebration"],
        &["celebrations"],
        &["celebrities"],
        &["celebrities"],
        &["celebrities"],
        &["celebrity"],
        &["celestial"],
        &["celestial"],
        &["celebrations"],
        &["celsius"],
        &["celtics"],
        &["celebrate"],
        &["celebrated"],
        &["celebrates"],
        &["celebrating"],
        &["celebration"],
        &["celebrations"],
        &["celebrate"],
        &["celebrated"],
        &["celebrates"],
        &["celebrating"],
        &["celebration"],
        &["celebrations"],
        &["cellar"],
        &["cellars"],
        &["cells"],
        &["cellpadding"],
        &["cells"],
        &["cellular"],
        &["cellular"],
        &["cells"],
        &["celsius"],
        &["cellular"],
        &["cleverly"],
    ],
    range: 3..=12,
};

static WORD_CEH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CEH_CHILDREN),
    value: None,
};

pub static WORD_CEH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ck"),
        dictgen::InsensitiveStr::Ascii("cked"),
        dictgen::InsensitiveStr::Ascii("cker"),
        dictgen::InsensitiveStr::Ascii("cking"),
        dictgen::InsensitiveStr::Ascii("cks"),
    ],
    values: &[
        &["check"],
        &["checked"],
        &["checker"],
        &["checking"],
        &["checks"],
    ],
    range: 2..=5,
};

static WORD_CED_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CED_CHILDREN),
    value: None,
};

pub static WORD_CED_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ential"),
        dictgen::InsensitiveStr::Ascii("entials"),
    ],
    values: &[&["credential"], &["credentials"]],
    range: 6..=7,
};

static WORD_CEC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CEC_CHILDREN),
    value: None,
};

pub static WORD_CEC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("k"),
        dictgen::InsensitiveStr::Ascii("ked"),
        dictgen::InsensitiveStr::Ascii("ker"),
        dictgen::InsensitiveStr::Ascii("king"),
        dictgen::InsensitiveStr::Ascii("ks"),
    ],
    values: &[
        &["check"],
        &["checked"],
        &["checker"],
        &["checking"],
        &["checks"],
    ],
    range: 1..=4,
};

static WORD_CEA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CEA_CHILDREN),
    value: None,
};

pub static WORD_CEA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("rtype"),
        dictgen::InsensitiveStr::Ascii("sar"),
        dictgen::InsensitiveStr::Ascii("sars"),
        dictgen::InsensitiveStr::Ascii("ser"),
        dictgen::InsensitiveStr::Ascii("sers"),
        dictgen::InsensitiveStr::Ascii("sser"),
        dictgen::InsensitiveStr::Ascii("ssers"),
        dictgen::InsensitiveStr::Ascii("te"),
        dictgen::InsensitiveStr::Ascii("ted"),
        dictgen::InsensitiveStr::Ascii("tes"),
        dictgen::InsensitiveStr::Ascii("ting"),
        dictgen::InsensitiveStr::Ascii("tion"),
    ],
    values: &[
        &["cleartype"],
        &["cesar"],
        &["caesars"],
        &["cesar"],
        &["caesars"],
        &["caesar"],
        &["caesars"],
        &["create"],
        &["created"],
        &["creates"],
        &["creating"],
        &["creation"],
    ],
    range: 2..=5,
};

static WORD_CD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CD_CHILDREN),
    value: None,
};

pub static WORD_CD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ecompress")],
    values: &[&["decompress"]],
    range: 9..=9,
};

static WORD_CC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CC_CHILDREN),
    value: None,
};

pub static WORD_CC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ahe"),
        dictgen::InsensitiveStr::Ascii("ale"),
        dictgen::InsensitiveStr::Ascii("annot"),
        dictgen::InsensitiveStr::Ascii("ertificate"),
        dictgen::InsensitiveStr::Ascii("ertificated"),
        dictgen::InsensitiveStr::Ascii("ertificates"),
        dictgen::InsensitiveStr::Ascii("ertification"),
        dictgen::InsensitiveStr::Ascii("essible"),
        dictgen::InsensitiveStr::Ascii("he"),
        dictgen::InsensitiveStr::Ascii("onfiguration"),
        dictgen::InsensitiveStr::Ascii("ordinate"),
        dictgen::InsensitiveStr::Ascii("ordinates"),
        dictgen::InsensitiveStr::Ascii("ordinats"),
        dictgen::InsensitiveStr::Ascii("outant"),
        dictgen::InsensitiveStr::Ascii("pcheck"),
        dictgen::InsensitiveStr::Ascii("urred"),
        dictgen::InsensitiveStr::Ascii("ustom"),
        dictgen::InsensitiveStr::Ascii("ustoms"),
    ],
    values: &[
        &["cache"],
        &["scale"],
        &["cannot"],
        &["certificate"],
        &["certificated"],
        &["certificates"],
        &["certification"],
        &["accessible"],
        &["cache"],
        &["configuration"],
        &["coordinate"],
        &["coordinates"],
        &["coordinates"],
        &["accountant"],
        &["cppcheck"],
        &["occurred"],
        &["custom"],
        &["customs"],
    ],
    range: 2..=12,
};

static WORD_CA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_CA_CHILDREN),
    value: None,
};

static WORD_CA_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    Some(&WORD_CAB_NODE),
    Some(&WORD_CAC_NODE),
    Some(&WORD_CAD_NODE),
    Some(&WORD_CAE_NODE),
    Some(&WORD_CAF_NODE),
    None,
    Some(&WORD_CAH_NODE),
    Some(&WORD_CAI_NODE),
    None,
    None,
    Some(&WORD_CAL_NODE),
    Some(&WORD_CAM_NODE),
    Some(&WORD_CAN_NODE),
    Some(&WORD_CAO_NODE),
    Some(&WORD_CAP_NODE),
    None,
    Some(&WORD_CAR_NODE),
    Some(&WORD_CAS_NODE),
    Some(&WORD_CAT_NODE),
    Some(&WORD_CAU_NODE),
    Some(&WORD_CAV_NODE),
    None,
    None,
    None,
    None,
];

static WORD_CAV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CAV_CHILDREN),
    value: None,
};

pub static WORD_CAV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aet"),
        dictgen::InsensitiveStr::Ascii("aets"),
        dictgen::InsensitiveStr::Ascii("arly"),
        dictgen::InsensitiveStr::Ascii("lary"),
        dictgen::InsensitiveStr::Ascii("ren"),
        dictgen::InsensitiveStr::Ascii("rens"),
    ],
    values: &[
        &["caveat"],
        &["caveats"],
        &["cavalry"],
        &["cavalry"],
        &["cavern"],
        &["caverns"],
    ],
    range: 3..=4,
};

static WORD_CAU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CAU_CHILDREN),
    value: None,
};

pub static WORD_CAU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("caisan"),
        dictgen::InsensitiveStr::Ascii("casain"),
        dictgen::InsensitiveStr::Ascii("casin"),
        dictgen::InsensitiveStr::Ascii("casion"),
        dictgen::InsensitiveStr::Ascii("ched"),
        dictgen::InsensitiveStr::Ascii("gt"),
        dictgen::InsensitiveStr::Ascii("hgt"),
        dictgen::InsensitiveStr::Ascii("ilflower"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("lfilower"),
        dictgen::InsensitiveStr::Ascii("ncks"),
        dictgen::InsensitiveStr::Ascii("sacian"),
        dictgen::InsensitiveStr::Ascii("sailty"),
        dictgen::InsensitiveStr::Ascii("salties"),
        dictgen::InsensitiveStr::Ascii("salty"),
        dictgen::InsensitiveStr::Ascii("sees"),
        dictgen::InsensitiveStr::Ascii("sion"),
        dictgen::InsensitiveStr::Ascii("sioned"),
        dictgen::InsensitiveStr::Ascii("sions"),
        dictgen::InsensitiveStr::Ascii("sious"),
        dictgen::InsensitiveStr::Ascii("tio"),
        dictgen::InsensitiveStr::Ascii("tionsly"),
    ],
    values: &[
        &["caucasian"],
        &["caucasian"],
        &["caucasian"],
        &["caucasian"],
        &["caught"],
        &["caught"],
        &["caught"],
        &["cauliflower"],
        &["causing"],
        &["cauliflower"],
        &["canucks"],
        &["caucasian"],
        &["causality"],
        &["casualties"],
        &["casualty"],
        &["causes"],
        &["caution"],
        &["cautioned"],
        &["cautions"],
        &["cautious"],
        &["caution"],
        &["cautiously"],
    ],
    range: 2..=8,
};

static WORD_CAT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_CAT_CHILDREN),
    value: None,
};

static WORD_CAT_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_CATA_NODE),
    None,
    Some(&WORD_CATC_NODE),
    None,
    Some(&WORD_CATE_NODE),
    None,
    Some(&WORD_CATG_NODE),
    Some(&WORD_CATH_NODE),
    Some(&WORD_CATI_NODE),
    None,
    None,
    Some(&WORD_CATL_NODE),
    None,
    None,
    Some(&WORD_CATO_NODE),
    Some(&WORD_CATP_NODE),
    None,
    None,
    None,
    Some(&WORD_CATT_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_CATT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CATT_CHILDREN),
    value: None,
};

pub static WORD_CATT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("erpilar"),
        dictgen::InsensitiveStr::Ascii("erpilars"),
        dictgen::InsensitiveStr::Ascii("erpillar"),
        dictgen::InsensitiveStr::Ascii("erpillars"),
        dictgen::InsensitiveStr::Ascii("leship"),
    ],
    values: &[
        &["caterpillar"],
        &["caterpillars"],
        &["caterpillar"],
        &["caterpillars"],
        &["battleship"],
    ],
    range: 6..=9,
};

static WORD_CATP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CATP_CHILDREN),
    value: None,
};

pub static WORD_CATP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ture"),
        dictgen::InsensitiveStr::Ascii("ure"),
        dictgen::InsensitiveStr::Ascii("ured"),
        dictgen::InsensitiveStr::Ascii("ures"),
    ],
    values: &[&["capture"], &["capture"], &["captured"], &["captures"]],
    range: 3..=4,
};

static WORD_CATO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CATO_CHILDREN),
    value: None,
};

pub static WORD_CATO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("gerized"),
        dictgen::InsensitiveStr::Ascii("ry"),
        dictgen::InsensitiveStr::Ascii("straphic"),
        dictgen::InsensitiveStr::Ascii("strophic"),
    ],
    values: &[
        &["categorized"],
        &["factory"],
        &["catastrophic"],
        &["catastrophic"],
    ],
    range: 2..=8,
};

static WORD_CATL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CATL_CHILDREN),
    value: None,
};

pub static WORD_CATL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ayst"),
        dictgen::InsensitiveStr::Ascii("oag"),
        dictgen::InsensitiveStr::Ascii("oaged"),
        dictgen::InsensitiveStr::Ascii("oags"),
    ],
    values: &[&["catalyst"], &["catalog"], &["cataloged"], &["catalogs"]],
    range: 3..=5,
};

static WORD_CATI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CATI_CHILDREN),
    value: None,
};

pub static WORD_CATI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("gorically"),
        dictgen::InsensitiveStr::Ascii("strophic"),
        dictgen::InsensitiveStr::Ascii("vating"),
    ],
    values: &[&["categorically"], &["catastrophic"], &["activating"]],
    range: 6..=9,
};

static WORD_CATH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CATH_CHILDREN),
    value: None,
};

pub static WORD_CATH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("deral"),
        dictgen::InsensitiveStr::Ascii("erdal"),
        dictgen::InsensitiveStr::Ascii("lic"),
        dictgen::InsensitiveStr::Ascii("loic"),
        dictgen::InsensitiveStr::Ascii("loics"),
        dictgen::InsensitiveStr::Ascii("olacism"),
        dictgen::InsensitiveStr::Ascii("olicisim"),
        dictgen::InsensitiveStr::Ascii("olicsim"),
        dictgen::InsensitiveStr::Ascii("olicsm"),
        dictgen::InsensitiveStr::Ascii("olicus"),
        dictgen::InsensitiveStr::Ascii("olisicm"),
        dictgen::InsensitiveStr::Ascii("olisim"),
        dictgen::InsensitiveStr::Ascii("olisism"),
        dictgen::InsensitiveStr::Ascii("olizism"),
        dictgen::InsensitiveStr::Ascii("olocisim"),
        dictgen::InsensitiveStr::Ascii("olocism"),
        dictgen::InsensitiveStr::Ascii("redal"),
    ],
    values: &[
        &["cathedral"],
        &["cathedral"],
        &["catholic"],
        &["catholic"],
        &["catholics"],
        &["catholicism"],
        &["catholicism"],
        &["catholicism"],
        &["catholicism"],
        &["catholics"],
        &["catholicism"],
        &["catholicism"],
        &["catholicism"],
        &["catholicism"],
        &["catholicism"],
        &["catholicism"],
        &["cathedral"],
    ],
    range: 3..=8,
};

static WORD_CATG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CATG_CHILDREN),
    value: None,
};

pub static WORD_CATG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("orical"),
        dictgen::InsensitiveStr::Ascii("orically"),
        dictgen::InsensitiveStr::Ascii("ories"),
        dictgen::InsensitiveStr::Ascii("ory"),
    ],
    values: &[
        &["categorical"],
        &["categorically"],
        &["categories"],
        &["category"],
    ],
    range: 3..=8,
};

static WORD_CATE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CATE_CHILDREN),
    value: None,
};

pub static WORD_CATE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("gogical"),
        dictgen::InsensitiveStr::Ascii("gogically"),
        dictgen::InsensitiveStr::Ascii("gogies"),
        dictgen::InsensitiveStr::Ascii("gogy"),
        dictgen::InsensitiveStr::Ascii("goricaly"),
        dictgen::InsensitiveStr::Ascii("gorice"),
        dictgen::InsensitiveStr::Ascii("gorie"),
        dictgen::InsensitiveStr::Ascii("goried"),
        dictgen::InsensitiveStr::Ascii("goriei"),
        dictgen::InsensitiveStr::Ascii("goriezed"),
        dictgen::InsensitiveStr::Ascii("goy"),
        dictgen::InsensitiveStr::Ascii("groized"),
        dictgen::InsensitiveStr::Ascii("ogrical"),
        dictgen::InsensitiveStr::Ascii("ogrically"),
        dictgen::InsensitiveStr::Ascii("ogries"),
        dictgen::InsensitiveStr::Ascii("ogrize"),
        dictgen::InsensitiveStr::Ascii("ogry"),
        dictgen::InsensitiveStr::Ascii("pillar"),
        dictgen::InsensitiveStr::Ascii("pillars"),
        dictgen::InsensitiveStr::Ascii("rgorize"),
        dictgen::InsensitiveStr::Ascii("rgorized"),
        dictgen::InsensitiveStr::Ascii("rogized"),
        dictgen::InsensitiveStr::Ascii("rpilar"),
        dictgen::InsensitiveStr::Ascii("rpilars"),
        dictgen::InsensitiveStr::Ascii("rpiller"),
        dictgen::InsensitiveStr::Ascii("rpillers"),
        dictgen::InsensitiveStr::Ascii("strophic"),
    ],
    values: &[
        &["categorical"],
        &["categorically"],
        &["categories"],
        &["category"],
        &["categorically"],
        &["categorize"],
        &["category", "categories"],
        &["categorized"],
        &["categorize"],
        &["categorized"],
        &["category"],
        &["categorized"],
        &["categorical"],
        &["categorically"],
        &["categories"],
        &["categorized"],
        &["category"],
        &["caterpillar"],
        &["caterpillars"],
        &["categorize"],
        &["categorized"],
        &["categorized"],
        &["caterpillar"],
        &["caterpillars"],
        &["caterpillar"],
        &["caterpillars"],
        &["catastrophic"],
    ],
    range: 3..=9,
};

static WORD_CATC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CATC_CHILDREN),
    value: None,
};

pub static WORD_CATC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("he"),
        dictgen::InsensitiveStr::Ascii("hed"),
        dictgen::InsensitiveStr::Ascii("hi"),
        dictgen::InsensitiveStr::Ascii("hip"),
        dictgen::InsensitiveStr::Ascii("hs"),
    ],
    values: &[
        &["catch"],
        &["caught"],
        &["catch"],
        &["catchup"],
        &["catches"],
    ],
    range: 2..=3,
};

static WORD_CATA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CATA_CHILDREN),
    value: None,
};

pub static WORD_CATA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("alogue"),
        dictgen::InsensitiveStr::Ascii("clism"),
        dictgen::InsensitiveStr::Ascii("clismic"),
        dictgen::InsensitiveStr::Ascii("clismical"),
        dictgen::InsensitiveStr::Ascii("clsym"),
        dictgen::InsensitiveStr::Ascii("clym"),
        dictgen::InsensitiveStr::Ascii("clyms"),
        dictgen::InsensitiveStr::Ascii("clysim"),
        dictgen::InsensitiveStr::Ascii("clysym"),
        dictgen::InsensitiveStr::Ascii("cylsm"),
        dictgen::InsensitiveStr::Ascii("cyslm"),
        dictgen::InsensitiveStr::Ascii("gori"),
        dictgen::InsensitiveStr::Ascii("gorically"),
        dictgen::InsensitiveStr::Ascii("gorie"),
        dictgen::InsensitiveStr::Ascii("gories"),
        dictgen::InsensitiveStr::Ascii("gorization"),
        dictgen::InsensitiveStr::Ascii("gorizations"),
        dictgen::InsensitiveStr::Ascii("gorized"),
        dictgen::InsensitiveStr::Ascii("gory"),
        dictgen::InsensitiveStr::Ascii("lcysm"),
        dictgen::InsensitiveStr::Ascii("lgoue"),
        dictgen::InsensitiveStr::Ascii("line"),
        dictgen::InsensitiveStr::Ascii("loge"),
        dictgen::InsensitiveStr::Ascii("lsyt"),
        dictgen::InsensitiveStr::Ascii("pillar"),
        dictgen::InsensitiveStr::Ascii("pillars"),
        dictgen::InsensitiveStr::Ascii("piller"),
        dictgen::InsensitiveStr::Ascii("pillers"),
        dictgen::InsensitiveStr::Ascii("sthrope"),
        dictgen::InsensitiveStr::Ascii("straphe"),
        dictgen::InsensitiveStr::Ascii("straphic"),
        dictgen::InsensitiveStr::Ascii("strofies"),
        dictgen::InsensitiveStr::Ascii("strofy"),
        dictgen::InsensitiveStr::Ascii("strohpe"),
        dictgen::InsensitiveStr::Ascii("strohpic"),
        dictgen::InsensitiveStr::Ascii("stronphic"),
        dictgen::InsensitiveStr::Ascii("strope"),
        dictgen::InsensitiveStr::Ascii("strophie"),
        dictgen::InsensitiveStr::Ascii("strophies"),
        dictgen::InsensitiveStr::Ascii("strophize"),
        dictgen::InsensitiveStr::Ascii("stropic"),
        dictgen::InsensitiveStr::Ascii("stropically"),
        dictgen::InsensitiveStr::Ascii("strphe"),
        dictgen::InsensitiveStr::Ascii("strphic"),
        dictgen::InsensitiveStr::Ascii("ylst"),
    ],
    values: &[
        &["catalogue"],
        &["cataclysm"],
        &["cataclysmic"],
        &["cataclysmic"],
        &["cataclysm"],
        &["cataclysm"],
        &["cataclysm"],
        &["cataclysm"],
        &["cataclysm"],
        &["cataclysm"],
        &["cataclysm"],
        &["category"],
        &["categorically"],
        &["category", "categories"],
        &["categories"],
        &["categorization"],
        &["categorizations"],
        &["categorized"],
        &["category"],
        &["cataclysm"],
        &["catalogue"],
        &["catiline", "catalina"],
        &["catalogue"],
        &["catalyst"],
        &["caterpillar"],
        &["caterpillars"],
        &["caterpillar"],
        &["caterpillars"],
        &["catastrophe"],
        &["catastrophe"],
        &["catastrophic"],
        &["catastrophes"],
        &["catastrophe"],
        &["catastrophe"],
        &["catastrophic"],
        &["catastrophic"],
        &["catastrophe"],
        &["catastrophe"],
        &["catastrophe"],
        &["catastrophe"],
        &["catastrophic"],
        &["catastrophically"],
        &["catastrophe"],
        &["catastrophic"],
        &["catalyst"],
    ],
    range: 4..=11,
};

static WORD_CAS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CAS_CHILDREN),
    value: None,
};

pub static WORD_CAS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("arole"),
        dictgen::InsensitiveStr::Ascii("aroles"),
        dictgen::InsensitiveStr::Ascii("aulity"),
        dictgen::InsensitiveStr::Ascii("aulties"),
        dictgen::InsensitiveStr::Ascii("aulty"),
        dictgen::InsensitiveStr::Ascii("cace"),
        dictgen::InsensitiveStr::Ascii("elessely"),
        dictgen::InsensitiveStr::Ascii("esensetive"),
        dictgen::InsensitiveStr::Ascii("ette"),
        dictgen::InsensitiveStr::Ascii("he"),
        dictgen::InsensitiveStr::Ascii("heir"),
        dictgen::InsensitiveStr::Ascii("heirs"),
        dictgen::InsensitiveStr::Ascii("hieer"),
        dictgen::InsensitiveStr::Ascii("hieres"),
        dictgen::InsensitiveStr::Ascii("hies"),
        dictgen::InsensitiveStr::Ascii("hire"),
        dictgen::InsensitiveStr::Ascii("hires"),
        dictgen::InsensitiveStr::Ascii("im"),
        dictgen::InsensitiveStr::Ascii("ims"),
        dictgen::InsensitiveStr::Ascii("ion"),
        dictgen::InsensitiveStr::Ascii("ltes"),
        dictgen::InsensitiveStr::Ascii("pule"),
        dictgen::InsensitiveStr::Ascii("pules"),
        dictgen::InsensitiveStr::Ascii("sarole"),
        dictgen::InsensitiveStr::Ascii("saroles"),
        dictgen::InsensitiveStr::Ascii("sawory"),
        dictgen::InsensitiveStr::Ascii("sete"),
        dictgen::InsensitiveStr::Ascii("settte"),
        dictgen::InsensitiveStr::Ascii("sim"),
        dictgen::InsensitiveStr::Ascii("sims"),
        dictgen::InsensitiveStr::Ascii("sm"),
        dictgen::InsensitiveStr::Ascii("sms"),
        dictgen::InsensitiveStr::Ascii("sowarry"),
        dictgen::InsensitiveStr::Ascii("tatrophe"),
        dictgen::InsensitiveStr::Ascii("tels"),
        dictgen::InsensitiveStr::Ascii("tleos"),
        dictgen::InsensitiveStr::Ascii("tlers"),
        dictgen::InsensitiveStr::Ascii("ualites"),
        dictgen::InsensitiveStr::Ascii("ualries"),
        dictgen::InsensitiveStr::Ascii("uation"),
        dictgen::InsensitiveStr::Ascii("ue"),
        dictgen::InsensitiveStr::Ascii("ued"),
        dictgen::InsensitiveStr::Ascii("ues"),
        dictgen::InsensitiveStr::Ascii("uing"),
        dictgen::InsensitiveStr::Ascii("ulaties"),
        dictgen::InsensitiveStr::Ascii("ulaty"),
    ],
    values: &[
        &["casserole"],
        &["casseroles"],
        &["causality"],
        &["casualties"],
        &["casualty"],
        &["cascade"],
        &["caselessly"],
        &["casesensitive"],
        &["cassette"],
        &["cache"],
        &["cashier"],
        &["cashiers"],
        &["cashier"],
        &["cashiers"],
        &["cashiers"],
        &["cashier"],
        &["cashiers"],
        &["chasm"],
        &["chasms"],
        &["caisson"],
        &["castles"],
        &["capsule"],
        &["capsules"],
        &["casserole"],
        &["casseroles"],
        &["cassowary"],
        &["cassette"],
        &["cassette"],
        &["chasm"],
        &["chasms"],
        &["chasm"],
        &["chasms"],
        &["cassowary"],
        &["catastrophe"],
        &["castles"],
        &["castles"],
        &["castles"],
        &["casualties"],
        &["casualties"],
        &["causation"],
        &["cause"],
        &["caused"],
        &["causes"],
        &["causing"],
        &["casualties"],
        &["casualty"],
    ],
    range: 2..=10,
};

static WORD_CAR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_CAR_CHILDREN),
    value: None,
};

static WORD_CAR_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_CARA_NODE),
    Some(&WORD_CARB_NODE),
    Some(&WORD_CARC_NODE),
    Some(&WORD_CARD_NODE),
    Some(&WORD_CARE_NODE),
    Some(&WORD_CARF_NODE),
    None,
    None,
    Some(&WORD_CARI_NODE),
    None,
    None,
    Some(&WORD_CARL_NODE),
    Some(&WORD_CARM_NODE),
    Some(&WORD_CARN_NODE),
    Some(&WORD_CARO_NODE),
    Some(&WORD_CARP_NODE),
    None,
    Some(&WORD_CARR_NODE),
    None,
    Some(&WORD_CART_NODE),
    None,
    Some(&WORD_CARV_NODE),
    None,
    None,
    Some(&WORD_CARY_NODE),
    None,
];

static WORD_CARY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CARY_CHILDREN),
    value: None,
};

pub static WORD_CARY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ons"),
        dictgen::InsensitiveStr::Ascii("y"),
    ],
    values: &[&["crayons"], &["carry"]],
    range: 1..=3,
};

static WORD_CARV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CARV_CHILDREN),
    value: None,
};

pub static WORD_CARV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("inal")],
    values: &[&["carnival"]],
    range: 4..=4,
};

static WORD_CART_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CART_CHILDREN),
    value: None,
};

pub static WORD_CART_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ain"),
        dictgen::InsensitiveStr::Ascii("dridge"),
        dictgen::InsensitiveStr::Ascii("drige"),
        dictgen::InsensitiveStr::Ascii("driges"),
        dictgen::InsensitiveStr::Ascii("ells"),
        dictgen::InsensitiveStr::Ascii("ensian"),
        dictgen::InsensitiveStr::Ascii("hagian"),
        dictgen::InsensitiveStr::Ascii("hesian"),
        dictgen::InsensitiveStr::Ascii("hographer"),
        dictgen::InsensitiveStr::Ascii("iesian"),
        dictgen::InsensitiveStr::Ascii("iladge"),
        dictgen::InsensitiveStr::Ascii("iledge"),
        dictgen::InsensitiveStr::Ascii("ilege"),
        dictgen::InsensitiveStr::Ascii("ilidge"),
        dictgen::InsensitiveStr::Ascii("irdge"),
        dictgen::InsensitiveStr::Ascii("irdges"),
        dictgen::InsensitiveStr::Ascii("ladge"),
        dictgen::InsensitiveStr::Ascii("lage"),
        dictgen::InsensitiveStr::Ascii("ledge"),
        dictgen::InsensitiveStr::Ascii("lege"),
        dictgen::InsensitiveStr::Ascii("les"),
        dictgen::InsensitiveStr::Ascii("maan"),
        dictgen::InsensitiveStr::Ascii("rdige"),
        dictgen::InsensitiveStr::Ascii("rdiges"),
        dictgen::InsensitiveStr::Ascii("riages"),
        dictgen::InsensitiveStr::Ascii("ride"),
        dictgen::InsensitiveStr::Ascii("rigde"),
        dictgen::InsensitiveStr::Ascii("rigdes"),
        dictgen::InsensitiveStr::Ascii("rige"),
    ],
    values: &[
        &["certain"],
        &["cartridge"],
        &["cartridge"],
        &["cartridges"],
        &["cartels"],
        &["cartesian"],
        &["carthaginian"],
        &["cartesian"],
        &["cartographer"],
        &["cartesian"],
        &["cartilage"],
        &["cartilage"],
        &["cartilage"],
        &["cartilage"],
        &["cartridge"],
        &["cartridges"],
        &["cartilage"],
        &["cartilage"],
        &["cartilage"],
        &["cartilage"],
        &["cartels"],
        &["cartman"],
        &["cartridge"],
        &["cartridges"],
        &["cartridges"],
        &["cartridge"],
        &["cartridge"],
        &["cartridges"],
        &["cartridge"],
    ],
    range: 3..=9,
};

static WORD_CARR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CARR_CHILDREN),
    value: None,
};

pub static WORD_CARR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("age"),
        dictgen::InsensitiveStr::Ascii("ages"),
        dictgen::InsensitiveStr::Ascii("ear"),
        dictgen::InsensitiveStr::Ascii("ears"),
        dictgen::InsensitiveStr::Ascii("eer"),
        dictgen::InsensitiveStr::Ascii("eid"),
        dictgen::InsensitiveStr::Ascii("ers"),
        dictgen::InsensitiveStr::Ascii("et"),
        dictgen::InsensitiveStr::Ascii("iadge"),
        dictgen::InsensitiveStr::Ascii("ibbean"),
        dictgen::InsensitiveStr::Ascii("ibean"),
        dictgen::InsensitiveStr::Ascii("idge"),
        dictgen::InsensitiveStr::Ascii("ien"),
        dictgen::InsensitiveStr::Ascii("ige"),
        dictgen::InsensitiveStr::Ascii("otts"),
        dictgen::InsensitiveStr::Ascii("otus"),
        dictgen::InsensitiveStr::Ascii("rier"),
        dictgen::InsensitiveStr::Ascii("yintg"),
        dictgen::InsensitiveStr::Ascii("yng"),
    ],
    values: &[
        &["carriage"],
        &["carriages"],
        &["career"],
        &["careers"],
        &["career"],
        &["carried"],
        &["careers"],
        &["caret"],
        &["carriage"],
        &["caribbean"],
        &["caribbean"],
        &["carriage", "cartridge"],
        &["carrier"],
        &["carriage"],
        &["carrots"],
        &["carrots"],
        &["carrier"],
        &["carrying"],
        &["carrying"],
    ],
    range: 2..=6,
};

static WORD_CARP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CARP_CHILDREN),
    value: None,
};

pub static WORD_CARP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("etner"),
        dictgen::InsensitiveStr::Ascii("tener"),
    ],
    values: &[&["carpenter"], &["carpenter"]],
    range: 5..=5,
};

static WORD_CARO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CARO_CHILDREN),
    value: None,
};

pub static WORD_CARO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("lan"),
        dictgen::InsensitiveStr::Ascii("linia"),
        dictgen::InsensitiveStr::Ascii("navirus"),
        dictgen::InsensitiveStr::Ascii("naviruses"),
        dictgen::InsensitiveStr::Ascii("sel"),
        dictgen::InsensitiveStr::Ascii("seles"),
        dictgen::InsensitiveStr::Ascii("sels"),
    ],
    values: &[
        &["carolina"],
        &["carolina"],
        &["coronavirus"],
        &["coronaviruses"],
        &["carousel"],
        &["carousels"],
        &["carousels"],
    ],
    range: 3..=9,
};

static WORD_CARN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CARN_CHILDREN),
    value: None,
};

pub static WORD_CARN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("agie"),
        dictgen::InsensitiveStr::Ascii("avor"),
        dictgen::InsensitiveStr::Ascii("avores"),
        dictgen::InsensitiveStr::Ascii("avors"),
        dictgen::InsensitiveStr::Ascii("berry"),
        dictgen::InsensitiveStr::Ascii("ege"),
        dictgen::InsensitiveStr::Ascii("ige"),
        dictgen::InsensitiveStr::Ascii("igie"),
        dictgen::InsensitiveStr::Ascii("iverous"),
        dictgen::InsensitiveStr::Ascii("omial"),
        dictgen::InsensitiveStr::Ascii("omially"),
        dictgen::InsensitiveStr::Ascii("omies"),
        dictgen::InsensitiveStr::Ascii("omy"),
        dictgen::InsensitiveStr::Ascii("vial"),
    ],
    values: &[
        &["carnegie"],
        &["carnivore"],
        &["carnivores"],
        &["carnivores"],
        &["cranberry"],
        &["carnage", "carnegie"],
        &["carnage", "carnegie"],
        &["carnegie"],
        &["carnivorous"],
        &["ceremonial"],
        &["ceremonially"],
        &["ceremonies"],
        &["ceremony"],
        &["carnival"],
    ],
    range: 3..=7,
};

static WORD_CARM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CARM_CHILDREN),
    value: None,
};

pub static WORD_CARM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("alite"),
        dictgen::InsensitiveStr::Ascii("onial"),
        dictgen::InsensitiveStr::Ascii("onially"),
        dictgen::InsensitiveStr::Ascii("onies"),
        dictgen::InsensitiveStr::Ascii("ony"),
        dictgen::InsensitiveStr::Ascii("tan"),
    ],
    values: &[
        &["carmelite"],
        &["ceremonial"],
        &["ceremonially"],
        &["ceremonies"],
        &["ceremony"],
        &["cartman"],
    ],
    range: 3..=7,
};

static WORD_CARL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CARL_CHILDREN),
    value: None,
};

pub static WORD_CARL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("oina")],
    values: &[&["carolina"]],
    range: 4..=4,
};

static WORD_CARI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CARI_CHILDREN),
    value: None,
};

pub static WORD_CARI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("acture"),
        dictgen::InsensitiveStr::Ascii("actures"),
        dictgen::InsensitiveStr::Ascii("age"),
        dictgen::InsensitiveStr::Ascii("bles"),
        dictgen::InsensitiveStr::Ascii("cate"),
        dictgen::InsensitiveStr::Ascii("catore"),
        dictgen::InsensitiveStr::Ascii("caturale"),
        dictgen::InsensitiveStr::Ascii("caturile"),
        dictgen::InsensitiveStr::Ascii("caturise"),
        dictgen::InsensitiveStr::Ascii("caturize"),
        dictgen::InsensitiveStr::Ascii("citure"),
        dictgen::InsensitiveStr::Ascii("cuture"),
        dictgen::InsensitiveStr::Ascii("dac"),
        dictgen::InsensitiveStr::Ascii("dgan"),
        dictgen::InsensitiveStr::Ascii("dge"),
        dictgen::InsensitiveStr::Ascii("dnal"),
        dictgen::InsensitiveStr::Ascii("dnals"),
        dictgen::InsensitiveStr::Ascii("dovascular"),
        dictgen::InsensitiveStr::Ascii("ier"),
        dictgen::InsensitiveStr::Ascii("monial"),
        dictgen::InsensitiveStr::Ascii("monially"),
        dictgen::InsensitiveStr::Ascii("monies"),
        dictgen::InsensitiveStr::Ascii("mony"),
        dictgen::InsensitiveStr::Ascii("nomial"),
        dictgen::InsensitiveStr::Ascii("nomially"),
        dictgen::InsensitiveStr::Ascii("nomies"),
        dictgen::InsensitiveStr::Ascii("nomy"),
        dictgen::InsensitiveStr::Ascii("nval"),
        dictgen::InsensitiveStr::Ascii("smatic"),
    ],
    values: &[
        &["caricature"],
        &["caricature"],
        &["carriage"],
        &["variables"],
        &["caricature"],
        &["caricature"],
        &["caricature"],
        &["caricature"],
        &["caricature"],
        &["caricature"],
        &["caricature"],
        &["caricature"],
        &["cardiac"],
        &["cardigan"],
        &["carriage"],
        &["cardinal"],
        &["cardinals"],
        &["cardiovascular"],
        &["carrier"],
        &["ceremonial"],
        &["ceremonially"],
        &["ceremonies"],
        &["ceremony"],
        &["ceremonial"],
        &["ceremonially"],
        &["ceremonies"],
        &["ceremony"],
        &["carnival"],
        &["charismatic"],
    ],
    range: 3..=10,
};

static WORD_CARF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CARF_CHILDREN),
    value: None,
};

pub static WORD_CARF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ull")],
    values: &[&["careful"]],
    range: 3..=3,
};

static WORD_CARE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CARE_CHILDREN),
    value: None,
};

pub static WORD_CARE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("flly"),
        dictgen::InsensitiveStr::Ascii("full"),
        dictgen::InsensitiveStr::Ascii("fullly"),
        dictgen::InsensitiveStr::Ascii("fuly"),
        dictgen::InsensitiveStr::Ascii("ing"),
    ],
    values: &[
        &["carefully"],
        &["careful", "carefully"],
        &["carefully"],
        &["carefully"],
        &["caring"],
    ],
    range: 3..=6,
};

static WORD_CARD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CARD_CHILDREN),
    value: None,
};

pub static WORD_CARD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aic"),
        dictgen::InsensitiveStr::Ascii("baord"),
        dictgen::InsensitiveStr::Ascii("boad"),
        dictgen::InsensitiveStr::Ascii("borad"),
        dictgen::InsensitiveStr::Ascii("ianl"),
        dictgen::InsensitiveStr::Ascii("ianls"),
        dictgen::InsensitiveStr::Ascii("ina"),
        dictgen::InsensitiveStr::Ascii("inales"),
        dictgen::InsensitiveStr::Ascii("inalis"),
        dictgen::InsensitiveStr::Ascii("iocascular"),
        dictgen::InsensitiveStr::Ascii("iovascualar"),
        dictgen::InsensitiveStr::Ascii("iovascualr"),
        dictgen::InsensitiveStr::Ascii("iovasculaire"),
        dictgen::InsensitiveStr::Ascii("iovasculaires"),
        dictgen::InsensitiveStr::Ascii("iovasuclar"),
        dictgen::InsensitiveStr::Ascii("nial"),
        dictgen::InsensitiveStr::Ascii("nials"),
    ],
    values: &[
        &["cardiac"],
        &["cardboard"],
        &["cardboard"],
        &["cardboard"],
        &["cardinal"],
        &["cardinals"],
        &["cardigan"],
        &["cardinals"],
        &["cardinals"],
        &["cardiovascular"],
        &["cardiovascular"],
        &["cardiovascular"],
        &["cardiovascular"],
        &["cardiovascular"],
        &["cardiovascular"],
        &["cardinal"],
        &["cardinals"],
    ],
    range: 3..=13,
};

static WORD_CARC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CARC_CHILDREN),
    value: None,
};

pub static WORD_CARC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("as"),
        dictgen::InsensitiveStr::Ascii("iature"),
        dictgen::InsensitiveStr::Ascii("us"),
        dictgen::InsensitiveStr::Ascii("uses"),
    ],
    values: &[
        &["carcass", "caracas"],
        &["caricature"],
        &["carcass"],
        &["carcasses"],
    ],
    range: 2..=6,
};

static WORD_CARB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CARB_CHILDREN),
    value: None,
};

pub static WORD_CARB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ien"),
        dictgen::InsensitiveStr::Ascii("ohdyrates"),
        dictgen::InsensitiveStr::Ascii("ohidrates"),
        dictgen::InsensitiveStr::Ascii("ohydrats"),
        dictgen::InsensitiveStr::Ascii("ohyrdate"),
        dictgen::InsensitiveStr::Ascii("ohyrdates"),
        dictgen::InsensitiveStr::Ascii("oyhdrates"),
        dictgen::InsensitiveStr::Ascii("us"),
    ],
    values: &[
        &["carbine"],
        &["carbohydrates"],
        &["carbohydrates"],
        &["carbohydrates"],
        &["carbohydrates"],
        &["carbohydrates"],
        &["carbohydrates"],
        &["cardbus"],
    ],
    range: 2..=9,
};

static WORD_CARA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CARA_CHILDREN),
    value: None,
};

pub static WORD_CARA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("boo"),
        dictgen::InsensitiveStr::Ascii("boos"),
        dictgen::InsensitiveStr::Ascii("chter"),
        dictgen::InsensitiveStr::Ascii("citure"),
        dictgen::InsensitiveStr::Ascii("cter"),
        dictgen::InsensitiveStr::Ascii("ctere"),
        dictgen::InsensitiveStr::Ascii("cteristic"),
        dictgen::InsensitiveStr::Ascii("cteristics"),
        dictgen::InsensitiveStr::Ascii("cterized"),
        dictgen::InsensitiveStr::Ascii("cters"),
        dictgen::InsensitiveStr::Ascii("ff"),
        dictgen::InsensitiveStr::Ascii("nge"),
    ],
    values: &[
        &["caribou"],
        &["caribous"],
        &["character"],
        &["caricature"],
        &["character"],
        &["character"],
        &["characteristic"],
        &["characteristics"],
        &["characterized"],
        &["characters"],
        &["carafe"],
        &["carnage"],
    ],
    range: 2..=10,
};

static WORD_CAP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_CAP_CHILDREN),
    value: None,
};

static WORD_CAP_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_CAPA_NODE),
    Some(&WORD_CAPB_NODE),
    None,
    None,
    Some(&WORD_CAPE_NODE),
    None,
    None,
    None,
    Some(&WORD_CAPI_NODE),
    None,
    None,
    None,
    Some(&WORD_CAPM_NODE),
    None,
    None,
    Some(&WORD_CAPP_NODE),
    None,
    Some(&WORD_CAPR_NODE),
    Some(&WORD_CAPS_NODE),
    Some(&WORD_CAPT_NODE),
    Some(&WORD_CAPU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_CAPU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CAPU_CHILDREN),
    value: None,
};

pub static WORD_CAPU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("sle"),
        dictgen::InsensitiveStr::Ascii("sles"),
        dictgen::InsensitiveStr::Ascii("tre"),
        dictgen::InsensitiveStr::Ascii("tred"),
        dictgen::InsensitiveStr::Ascii("tres"),
        dictgen::InsensitiveStr::Ascii("ture"),
    ],
    values: &[
        &["capsule"],
        &["capsules"],
        &["capture"],
        &["captured"],
        &["captures"],
        &["capture"],
    ],
    range: 3..=4,
};

static WORD_CAPT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CAPT_CHILDREN),
    value: None,
};

pub static WORD_CAPT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("able"),
        dictgen::InsensitiveStr::Ascii("ainers"),
        dictgen::InsensitiveStr::Ascii("ais"),
        dictgen::InsensitiveStr::Ascii("er"),
        dictgen::InsensitiveStr::Ascii("ers"),
        dictgen::InsensitiveStr::Ascii("eurs"),
        dictgen::InsensitiveStr::Ascii("ial"),
        dictgen::InsensitiveStr::Ascii("ialism"),
        dictgen::InsensitiveStr::Ascii("ialist"),
        dictgen::InsensitiveStr::Ascii("ialists"),
        dictgen::InsensitiveStr::Ascii("ialization"),
        dictgen::InsensitiveStr::Ascii("ialize"),
        dictgen::InsensitiveStr::Ascii("ialized"),
        dictgen::InsensitiveStr::Ascii("ials"),
        dictgen::InsensitiveStr::Ascii("ian"),
        dictgen::InsensitiveStr::Ascii("ians"),
        dictgen::InsensitiveStr::Ascii("in"),
        dictgen::InsensitiveStr::Ascii("ins"),
        dictgen::InsensitiveStr::Ascii("iol"),
        dictgen::InsensitiveStr::Ascii("ivitiy"),
        dictgen::InsensitiveStr::Ascii("rure"),
        dictgen::InsensitiveStr::Ascii("ued"),
        dictgen::InsensitiveStr::Ascii("urd"),
    ],
    values: &[
        &["capable"],
        &["captains"],
        &["captains"],
        &["captor"],
        &["captors"],
        &["captures"],
        &["capital"],
        &["capitalism"],
        &["capitalist"],
        &["capitalists"],
        &["capitalization"],
        &["capitalize"],
        &["capitalized"],
        &["capitals"],
        &["captain"],
        &["captains"],
        &["captain"],
        &["captains"],
        &["capitol"],
        &["captivity"],
        &["capture"],
        &["captured"],
        &["captured"],
    ],
    range: 2..=10,
};

static WORD_CAPS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CAPS_CHILDREN),
    value: None,
};

pub static WORD_CAPS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("uels"),
        dictgen::InsensitiveStr::Ascii("ulers"),
        dictgen::InsensitiveStr::Ascii("ulets"),
        dictgen::InsensitiveStr::Ascii("uls"),
        dictgen::InsensitiveStr::Ascii("ulse"),
        dictgen::InsensitiveStr::Ascii("umel"),
    ],
    values: &[
        &["capsules"],
        &["capsules"],
        &["capsules"],
        &["capsules"],
        &["capsules"],
        &["capsule"],
    ],
    range: 3..=5,
};

static WORD_CAPR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CAPR_CHILDREN),
    value: None,
};

pub static WORD_CAPR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("enter")],
    values: &[&["carpenter"]],
    range: 5..=5,
};

static WORD_CAPP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CAPP_CHILDREN),
    value: None,
};

pub static WORD_CAPP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("able")],
    values: &[&["capable"]],
    range: 4..=4,
};

static WORD_CAPM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CAPM_CHILDREN),
    value: None,
};

pub static WORD_CAPM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("bell")],
    values: &[&["campbell"]],
    range: 4..=4,
};

static WORD_CAPI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CAPI_CHILDREN),
    value: None,
};

pub static WORD_CAPI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("alized"),
        dictgen::InsensitiveStr::Ascii("bilities"),
        dictgen::InsensitiveStr::Ascii("bility"),
        dictgen::InsensitiveStr::Ascii("ble"),
        dictgen::InsensitiveStr::Ascii("cator"),
        dictgen::InsensitiveStr::Ascii("cators"),
        dictgen::InsensitiveStr::Ascii("talis"),
        dictgen::InsensitiveStr::Ascii("talisim"),
        dictgen::InsensitiveStr::Ascii("talisn"),
        dictgen::InsensitiveStr::Ascii("talistes"),
        dictgen::InsensitiveStr::Ascii("talits"),
        dictgen::InsensitiveStr::Ascii("talizacion"),
        dictgen::InsensitiveStr::Ascii("talizaiton"),
        dictgen::InsensitiveStr::Ascii("talizating"),
        dictgen::InsensitiveStr::Ascii("talizaton"),
        dictgen::InsensitiveStr::Ascii("talsim"),
        dictgen::InsensitiveStr::Ascii("talsit"),
        dictgen::InsensitiveStr::Ascii("tans"),
        dictgen::InsensitiveStr::Ascii("tarist"),
        dictgen::InsensitiveStr::Ascii("tas"),
        dictgen::InsensitiveStr::Ascii("tilazation"),
        dictgen::InsensitiveStr::Ascii("tilism"),
        dictgen::InsensitiveStr::Ascii("tilist"),
        dictgen::InsensitiveStr::Ascii("tilists"),
        dictgen::InsensitiveStr::Ascii("tilize"),
        dictgen::InsensitiveStr::Ascii("tilized"),
        dictgen::InsensitiveStr::Ascii("tlaism"),
        dictgen::InsensitiveStr::Ascii("tlaist"),
        dictgen::InsensitiveStr::Ascii("tlaize"),
        dictgen::InsensitiveStr::Ascii("tola"),
        dictgen::InsensitiveStr::Ascii("tolism"),
        dictgen::InsensitiveStr::Ascii("tolist"),
        dictgen::InsensitiveStr::Ascii("tolists"),
        dictgen::InsensitiveStr::Ascii("tolization"),
        dictgen::InsensitiveStr::Ascii("tolize"),
        dictgen::InsensitiveStr::Ascii("tolized"),
        dictgen::InsensitiveStr::Ascii("tulo"),
    ],
    values: &[
        &["capitalized"],
        &["capabilities"],
        &["capability"],
        &["capable"],
        &["capacitor"],
        &["capacitors"],
        &["capitals"],
        &["capitalism"],
        &["capitals"],
        &["capitalists"],
        &["capitalists"],
        &["capitalization"],
        &["capitalization"],
        &["capitalization"],
        &["capitalization"],
        &["capitalism"],
        &["capitalists"],
        &["captains"],
        &["capitalist"],
        &["capitals"],
        &["capitalization"],
        &["capitalism"],
        &["capitalist"],
        &["capitalists"],
        &["capitalize"],
        &["capitalized"],
        &["capitalism"],
        &["capitalist"],
        &["capitalized"],
        &["capital"],
        &["capitalism"],
        &["capitalist"],
        &["capitalists"],
        &["capitalization"],
        &["capitalize"],
        &["capitalized"],
        &["capitol"],
    ],
    range: 3..=10,
};

static WORD_CAPE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CAPE_CHILDREN),
    value: None,
};

pub static WORD_CAPE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("la"),
        dictgen::InsensitiveStr::Ascii("rbility"),
    ],
    values: &[&["capella"], &["capability"]],
    range: 2..=7,
};

static WORD_CAPB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CAPB_CHILDREN),
    value: None,
};

pub static WORD_CAPB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ability"),
        dictgen::InsensitiveStr::Ascii("ale"),
    ],
    values: &[&["capability"], &["capable"]],
    range: 3..=7,
};

static WORD_CAPA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CAPA_CHILDREN),
    value: None,
};

pub static WORD_CAPA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("bable"),
        dictgen::InsensitiveStr::Ascii("bality"),
        dictgen::InsensitiveStr::Ascii("bicity"),
        dictgen::InsensitiveStr::Ascii("biities"),
        dictgen::InsensitiveStr::Ascii("biity"),
        dictgen::InsensitiveStr::Ascii("bilies"),
        dictgen::InsensitiveStr::Ascii("biliites"),
        dictgen::InsensitiveStr::Ascii("bilites"),
        dictgen::InsensitiveStr::Ascii("bilitieis"),
        dictgen::InsensitiveStr::Ascii("bilitiies"),
        dictgen::InsensitiveStr::Ascii("bilitires"),
        dictgen::InsensitiveStr::Ascii("bilitiy"),
        dictgen::InsensitiveStr::Ascii("billity"),
        dictgen::InsensitiveStr::Ascii("bilties"),
        dictgen::InsensitiveStr::Ascii("biltity"),
        dictgen::InsensitiveStr::Ascii("biltiy"),
        dictgen::InsensitiveStr::Ascii("bilty"),
        dictgen::InsensitiveStr::Ascii("bitilies"),
        dictgen::InsensitiveStr::Ascii("blilities"),
        dictgen::InsensitiveStr::Ascii("blities"),
        dictgen::InsensitiveStr::Ascii("blity"),
        dictgen::InsensitiveStr::Ascii("cators"),
        dictgen::InsensitiveStr::Ascii("citaron"),
        dictgen::InsensitiveStr::Ascii("citers"),
        dictgen::InsensitiveStr::Ascii("citores"),
        dictgen::InsensitiveStr::Ascii("ciy"),
        dictgen::InsensitiveStr::Ascii("ctior"),
        dictgen::InsensitiveStr::Ascii("ctiors"),
        dictgen::InsensitiveStr::Ascii("lize"),
        dictgen::InsensitiveStr::Ascii("lized"),
        dictgen::InsensitiveStr::Ascii("pbilities"),
        dictgen::InsensitiveStr::Ascii("sitors"),
        dictgen::InsensitiveStr::Ascii("tibilities"),
        dictgen::InsensitiveStr::Ascii("tilism"),
        dictgen::InsensitiveStr::Ascii("tilist"),
        dictgen::InsensitiveStr::Ascii("tilists"),
        dictgen::InsensitiveStr::Ascii("tilization"),
        dictgen::InsensitiveStr::Ascii("tilize"),
        dictgen::InsensitiveStr::Ascii("tilized"),
    ],
    values: &[
        &["capable"],
        &["capability"],
        &["capability"],
        &["capabilities"],
        &["capability"],
        &["capabilities"],
        &["capabilities"],
        &["capabilities"],
        &["capabilities"],
        &["capabilities"],
        &["capabilities"],
        &["capability"],
        &["capability"],
        &["capabilities"],
        &["capability"],
        &["capability"],
        &["capability"],
        &["capabilities"],
        &["capabilities"],
        &["capabilities"],
        &["capability"],
        &["capacitors"],
        &["capacitor"],
        &["capacitors"],
        &["capacitors"],
        &["capacity"],
        &["capacitor"],
        &["capacitors"],
        &["capitalize"],
        &["capitalized"],
        &["capabilities"],
        &["capacitors"],
        &["capabilities"],
        &["capitalism"],
        &["capitalist"],
        &["capitalists"],
        &["capitalization"],
        &["capitalize"],
        &["capitalized"],
    ],
    range: 3..=10,
};

static WORD_CAO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CAO_CHILDREN),
    value: None,
};

pub static WORD_CAO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("st")],
    values: &[&["coast"]],
    range: 2..=2,
};

static WORD_CAN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_CAN_CHILDREN),
    value: None,
};

static WORD_CAN_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_CANA_NODE),
    None,
    Some(&WORD_CANC_NODE),
    Some(&WORD_CAND_NODE),
    Some(&WORD_CANE_NODE),
    None,
    Some(&WORD_CANG_NODE),
    None,
    Some(&WORD_CANI_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_CANN_NODE),
    Some(&WORD_CANO_NODE),
    None,
    None,
    Some(&WORD_CANR_NODE),
    Some(&WORD_CANS_NODE),
    Some(&WORD_CANT_NODE),
    None,
    Some(&WORD_CANV_NODE),
    None,
    None,
    Some(&WORD_CANY_NODE),
    None,
];

static WORD_CANY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CANY_CHILDREN),
    value: None,
};

pub static WORD_CANY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("e")],
    values: &[&["canaille"]],
    range: 1..=1,
};

static WORD_CANV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CANV_CHILDREN),
    value: None,
};

pub static WORD_CANV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ase")],
    values: &[&["canvas"]],
    range: 3..=3,
};

static WORD_CANT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CANT_CHILDREN),
    value: None,
};

pub static WORD_CANT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("act"),
        dictgen::InsensitiveStr::Ascii("acted"),
        dictgen::InsensitiveStr::Ascii("acting"),
        dictgen::InsensitiveStr::Ascii("acts"),
        dictgen::InsensitiveStr::Ascii("ain"),
        dictgen::InsensitiveStr::Ascii("ained"),
        dictgen::InsensitiveStr::Ascii("aining"),
        dictgen::InsensitiveStr::Ascii("ains"),
        dictgen::InsensitiveStr::Ascii("alope"),
        dictgen::InsensitiveStr::Ascii("alopes"),
    ],
    values: &[
        &["contact"],
        &["contacted"],
        &["contacting"],
        &["contacts"],
        &["contain"],
        &["contained"],
        &["containing"],
        &["contains"],
        &["cantaloupe"],
        &["cantaloupes"],
    ],
    range: 3..=6,
};

static WORD_CANS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CANS_CHILDREN),
    value: None,
};

pub static WORD_CANS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("iter")],
    values: &[&["canister"]],
    range: 4..=4,
};

static WORD_CANR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CANR_CHILDREN),
    value: None,
};

pub static WORD_CANR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("age")],
    values: &[&["carnage"]],
    range: 3..=3,
};

static WORD_CANO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CANO_CHILDREN),
    value: None,
};

pub static WORD_CANO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cical"),
        dictgen::InsensitiveStr::Ascii("ical"),
        dictgen::InsensitiveStr::Ascii("nalize"),
        dictgen::InsensitiveStr::Ascii("nalized"),
        dictgen::InsensitiveStr::Ascii("nalizes"),
        dictgen::InsensitiveStr::Ascii("nalizing"),
        dictgen::InsensitiveStr::Ascii("ncal"),
        dictgen::InsensitiveStr::Ascii("ncial"),
        dictgen::InsensitiveStr::Ascii("ncical"),
        dictgen::InsensitiveStr::Ascii("nicalizations"),
        dictgen::InsensitiveStr::Ascii("nival"),
        dictgen::InsensitiveStr::Ascii("t"),
    ],
    values: &[
        &["canonical"],
        &["canonical"],
        &["canonicalize"],
        &["canonicalized"],
        &["canonicalizes"],
        &["canonicalizing"],
        &["canonical"],
        &["canonical"],
        &["canonical"],
        &["canonicalization"],
        &["canonical"],
        &["cannot"],
    ],
    range: 1..=13,
};

static WORD_CANN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CANN_CHILDREN),
    value: Some(&["can"]),
};

pub static WORD_CANN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("abil"),
        dictgen::InsensitiveStr::Ascii("abile"),
        dictgen::InsensitiveStr::Ascii("abiles"),
        dictgen::InsensitiveStr::Ascii("abilism"),
        dictgen::InsensitiveStr::Ascii("abilyse"),
        dictgen::InsensitiveStr::Ascii("abilysed"),
        dictgen::InsensitiveStr::Ascii("abilyses"),
        dictgen::InsensitiveStr::Ascii("abilysing"),
        dictgen::InsensitiveStr::Ascii("abilyze"),
        dictgen::InsensitiveStr::Ascii("abilyzed"),
        dictgen::InsensitiveStr::Ascii("abilyzes"),
        dictgen::InsensitiveStr::Ascii("abilyzing"),
        dictgen::InsensitiveStr::Ascii("abolism"),
        dictgen::InsensitiveStr::Ascii("bial"),
        dictgen::InsensitiveStr::Ascii("iablism"),
        dictgen::InsensitiveStr::Ascii("ibalisim"),
        dictgen::InsensitiveStr::Ascii("ibalizm"),
        dictgen::InsensitiveStr::Ascii("ibaljim"),
        dictgen::InsensitiveStr::Ascii("iballism"),
        dictgen::InsensitiveStr::Ascii("ibalsim"),
        dictgen::InsensitiveStr::Ascii("ibalsm"),
        dictgen::InsensitiveStr::Ascii("ibas"),
        dictgen::InsensitiveStr::Ascii("ibilism"),
        dictgen::InsensitiveStr::Ascii("ister"),
        dictgen::InsensitiveStr::Ascii("isters"),
        dictgen::InsensitiveStr::Ascii("not"),
        dictgen::InsensitiveStr::Ascii("obalism"),
        dictgen::InsensitiveStr::Ascii("obt"),
        dictgen::InsensitiveStr::Ascii("oical"),
        dictgen::InsensitiveStr::Ascii("onical"),
        dictgen::InsensitiveStr::Ascii("onicalization"),
        dictgen::InsensitiveStr::Ascii("onicalize"),
        dictgen::InsensitiveStr::Ascii("ont"),
        dictgen::InsensitiveStr::Ascii("otation"),
        dictgen::InsensitiveStr::Ascii("otations"),
        dictgen::InsensitiveStr::Ascii("ote"),
        dictgen::InsensitiveStr::Ascii("otes"),
        dictgen::InsensitiveStr::Ascii("ott"),
        dictgen::InsensitiveStr::Ascii("t"),
    ],
    values: &[
        &["cannibal"],
        &["cannibal"],
        &["cannibals"],
        &["cannibalism"],
        &["cannibalise"],
        &["cannibalised"],
        &["cannibalises"],
        &["cannibalising"],
        &["cannibalize"],
        &["cannibalized"],
        &["cannibalizes"],
        &["cannibalizing"],
        &["cannibalism"],
        &["cannibal"],
        &["cannibalism"],
        &["cannibalism"],
        &["cannibalism"],
        &["cannibalism"],
        &["cannibalism"],
        &["cannibalism"],
        &["cannibalism"],
        &["cannabis"],
        &["cannibalism"],
        &["canister"],
        &["canisters"],
        &["cannot"],
        &["cannibalism"],
        &["cannot"],
        &["canonical"],
        &["canonical"],
        &["canonicalization"],
        &["canonicalize"],
        &["cannot"],
        &["connotation"],
        &["connotations"],
        &["cannot", "connote"],
        &["cannot", "connotes"],
        &["cannot"],
        &["cannot"],
    ],
    range: 1..=13,
};

static WORD_CANI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CANI_CHILDREN),
    value: None,
};

pub static WORD_CANI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("date"),
        dictgen::InsensitiveStr::Ascii("dates"),
        dictgen::InsensitiveStr::Ascii("des"),
        dictgen::InsensitiveStr::Ascii("stre"),
    ],
    values: &[&["candidate"], &["candidates"], &["candies"], &["canister"]],
    range: 3..=5,
};

static WORD_CANG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CANG_CHILDREN),
    value: None,
};

pub static WORD_CANG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("ing"),
    ],
    values: &[&["change"], &["changed"], &["changes"], &["changing"]],
    range: 1..=3,
};

static WORD_CANE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CANE_CHILDREN),
    value: None,
};

pub static WORD_CANE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("w"),
        dictgen::InsensitiveStr::Ascii("ws"),
    ],
    values: &[&["canoe"], &["canoes"]],
    range: 1..=2,
};

static WORD_CAND_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CAND_CHILDREN),
    value: None,
};

pub static WORD_CAND_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("adate"),
        dictgen::InsensitiveStr::Ascii("adates"),
        dictgen::InsensitiveStr::Ascii("iate"),
        dictgen::InsensitiveStr::Ascii("iates"),
        dictgen::InsensitiveStr::Ascii("idat"),
        dictgen::InsensitiveStr::Ascii("idatas"),
        dictgen::InsensitiveStr::Ascii("idats"),
        dictgen::InsensitiveStr::Ascii("idatxs"),
        dictgen::InsensitiveStr::Ascii("idiate"),
        dictgen::InsensitiveStr::Ascii("idiates"),
        dictgen::InsensitiveStr::Ascii("iens"),
        dictgen::InsensitiveStr::Ascii("inate"),
        dictgen::InsensitiveStr::Ascii("inates"),
        dictgen::InsensitiveStr::Ascii("itate"),
        dictgen::InsensitiveStr::Ascii("itates"),
    ],
    values: &[
        &["candidate"],
        &["candidates"],
        &["candidate"],
        &["candidates"],
        &["candidate"],
        &["candidates"],
        &["candidates"],
        &["candidates"],
        &["candidate"],
        &["candidates"],
        &["candies"],
        &["candidate"],
        &["candidates"],
        &["candidate"],
        &["candidates"],
    ],
    range: 4..=7,
};

static WORD_CANC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CANC_CHILDREN),
    value: None,
};

pub static WORD_CANC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("elability"),
        dictgen::InsensitiveStr::Ascii("elaltion"),
        dictgen::InsensitiveStr::Ascii("elas"),
        dictgen::InsensitiveStr::Ascii("elations"),
        dictgen::InsensitiveStr::Ascii("ele"),
        dictgen::InsensitiveStr::Ascii("eles"),
        dictgen::InsensitiveStr::Ascii("ell"),
        dictgen::InsensitiveStr::Ascii("ellato"),
        dictgen::InsensitiveStr::Ascii("elles"),
        dictgen::InsensitiveStr::Ascii("ells"),
        dictgen::InsensitiveStr::Ascii("eltation"),
        dictgen::InsensitiveStr::Ascii("eres"),
        dictgen::InsensitiveStr::Ascii("erns"),
        dictgen::InsensitiveStr::Ascii("erus"),
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("l"),
        dictgen::InsensitiveStr::Ascii("le"),
        dictgen::InsensitiveStr::Ascii("led"),
        dictgen::InsensitiveStr::Ascii("les"),
        dictgen::InsensitiveStr::Ascii("res"),
        dictgen::InsensitiveStr::Ascii("uks"),
    ],
    values: &[
        &["cancellability"],
        &["cancelation"],
        &["cancels"],
        &["cancellations"],
        &["cancel", "cancels"],
        &["cancels"],
        &["cancel"],
        &["cancellation"],
        &["cancels"],
        &["cancels"],
        &["cancellation"],
        &["cancers"],
        &["cancers"],
        &["cancers"],
        &["cancel"],
        &["cancel"],
        &["cancel"],
        &["canceled"],
        &["cancels"],
        &["cancers"],
        &["canucks"],
    ],
    range: 1..=9,
};

static WORD_CANA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CANA_CHILDREN),
    value: None,
};

pub static WORD_CANA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("bel"),
        dictgen::InsensitiveStr::Ascii("bels"),
        dictgen::InsensitiveStr::Ascii("belyse"),
        dictgen::InsensitiveStr::Ascii("belysed"),
        dictgen::InsensitiveStr::Ascii("belyses"),
        dictgen::InsensitiveStr::Ascii("belysing"),
        dictgen::InsensitiveStr::Ascii("belyze"),
        dictgen::InsensitiveStr::Ascii("belyzed"),
        dictgen::InsensitiveStr::Ascii("belyzes"),
        dictgen::InsensitiveStr::Ascii("belyzing"),
        dictgen::InsensitiveStr::Ascii("dains"),
        dictgen::InsensitiveStr::Ascii("dan"),
        dictgen::InsensitiveStr::Ascii("dianese"),
        dictgen::InsensitiveStr::Ascii("dias"),
        dictgen::InsensitiveStr::Ascii("nbis"),
    ],
    values: &[
        &["cannibal"],
        &["cannibals"],
        &["cannibalise"],
        &["cannibalised"],
        &["cannibalises"],
        &["cannibalising"],
        &["cannibalize"],
        &["cannibalized"],
        &["cannibalizes"],
        &["cannibalizing"],
        &["canadians"],
        &["canadian"],
        &["canadians"],
        &["canadians"],
        &["cannabis"],
    ],
    range: 3..=8,
};

static WORD_CAM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CAM_CHILDREN),
    value: None,
};

pub static WORD_CAM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("apign"),
        dictgen::InsensitiveStr::Ascii("birdge"),
        dictgen::InsensitiveStr::Ascii("boda"),
        dictgen::InsensitiveStr::Ascii("bodai"),
        dictgen::InsensitiveStr::Ascii("bodican"),
        dictgen::InsensitiveStr::Ascii("boida"),
        dictgen::InsensitiveStr::Ascii("bpell"),
        dictgen::InsensitiveStr::Ascii("brdige"),
        dictgen::InsensitiveStr::Ascii("bride"),
        dictgen::InsensitiveStr::Ascii("brigde"),
        dictgen::InsensitiveStr::Ascii("brige"),
        dictgen::InsensitiveStr::Ascii("eleon"),
        dictgen::InsensitiveStr::Ascii("eleons"),
        dictgen::InsensitiveStr::Ascii("elion"),
        dictgen::InsensitiveStr::Ascii("elions"),
        dictgen::InsensitiveStr::Ascii("oflage"),
        dictgen::InsensitiveStr::Ascii("oflaged"),
        dictgen::InsensitiveStr::Ascii("oflages"),
        dictgen::InsensitiveStr::Ascii("oflaging"),
        dictgen::InsensitiveStr::Ascii("oflague"),
        dictgen::InsensitiveStr::Ascii("oflagued"),
        dictgen::InsensitiveStr::Ascii("oflagues"),
        dictgen::InsensitiveStr::Ascii("oflaguing"),
        dictgen::InsensitiveStr::Ascii("ofluage"),
        dictgen::InsensitiveStr::Ascii("oufalge"),
        dictgen::InsensitiveStr::Ascii("ouflague"),
        dictgen::InsensitiveStr::Ascii("ouflagued"),
        dictgen::InsensitiveStr::Ascii("ouflauge"),
        dictgen::InsensitiveStr::Ascii("oufle"),
        dictgen::InsensitiveStr::Ascii("ouglage"),
        dictgen::InsensitiveStr::Ascii("pagin"),
        dictgen::InsensitiveStr::Ascii("pagining"),
        dictgen::InsensitiveStr::Ascii("pagins"),
        dictgen::InsensitiveStr::Ascii("paiging"),
        dictgen::InsensitiveStr::Ascii("paignes"),
        dictgen::InsensitiveStr::Ascii("pain"),
        dictgen::InsensitiveStr::Ascii("paing"),
        dictgen::InsensitiveStr::Ascii("painging"),
        dictgen::InsensitiveStr::Ascii("paings"),
        dictgen::InsensitiveStr::Ascii("pains"),
        dictgen::InsensitiveStr::Ascii("paring"),
        dictgen::InsensitiveStr::Ascii("peras"),
        dictgen::InsensitiveStr::Ascii("peros"),
        dictgen::InsensitiveStr::Ascii("piagns"),
        dictgen::InsensitiveStr::Ascii("pusers"),
        dictgen::InsensitiveStr::Ascii("puss"),
        dictgen::InsensitiveStr::Ascii("rbidge"),
    ],
    values: &[
        &["campaign"],
        &["cambridge"],
        &["cambodia"],
        &["cambodia"],
        &["cambodia"],
        &["cambodia"],
        &["campbell"],
        &["cambridge"],
        &["cambridge"],
        &["cambridge"],
        &["cambridge"],
        &["chameleon"],
        &["chameleons"],
        &["chameleon"],
        &["chameleons"],
        &["camouflage"],
        &["camouflaged"],
        &["camouflages"],
        &["camouflaging"],
        &["camouflage"],
        &["camouflaged"],
        &["camouflages"],
        &["camouflaging"],
        &["camouflage"],
        &["camouflage"],
        &["camouflage"],
        &["camouflage"],
        &["camouflage"],
        &["camouflage"],
        &["camouflage"],
        &["campaign"],
        &["campaigning"],
        &["campaigns"],
        &["campaigning"],
        &["campaigns"],
        &["campaign"],
        &["campaign"],
        &["campaigning"],
        &["campaigns"],
        &["campaigns"],
        &["comparing"],
        &["campers"],
        &["campers"],
        &["campaigns"],
        &["campuses"],
        &["campuses"],
        &["cambridge"],
    ],
    range: 4..=9,
};

static WORD_CAL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_CAL_CHILDREN),
    value: None,
};

static WORD_CAL_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_CALA_NODE),
    Some(&WORD_CALB_NODE),
    Some(&WORD_CALC_NODE),
    None,
    Some(&WORD_CALE_NODE),
    Some(&WORD_CALF_NODE),
    Some(&WORD_CALG_NODE),
    None,
    Some(&WORD_CALI_NODE),
    None,
    None,
    Some(&WORD_CALL_NODE),
    None,
    None,
    Some(&WORD_CALO_NODE),
    None,
    None,
    Some(&WORD_CALR_NODE),
    Some(&WORD_CALS_NODE),
    None,
    Some(&WORD_CALU_NODE),
    None,
    None,
    None,
    Some(&WORD_CALY_NODE),
    None,
];

static WORD_CALY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CALY_CHILDREN),
    value: None,
};

pub static WORD_CALY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("more")],
    values: &[&["claymore"]],
    range: 4..=4,
};

static WORD_CALU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CALU_CHILDREN),
    value: None,
};

pub static WORD_CALU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("calte"),
        dictgen::InsensitiveStr::Ascii("calted"),
        dictgen::InsensitiveStr::Ascii("caltes"),
        dictgen::InsensitiveStr::Ascii("calting"),
        dictgen::InsensitiveStr::Ascii("caltion"),
        dictgen::InsensitiveStr::Ascii("caltions"),
        dictgen::InsensitiveStr::Ascii("cate"),
        dictgen::InsensitiveStr::Ascii("clate"),
        dictgen::InsensitiveStr::Ascii("clated"),
        dictgen::InsensitiveStr::Ascii("clater"),
        dictgen::InsensitiveStr::Ascii("clates"),
        dictgen::InsensitiveStr::Ascii("clating"),
        dictgen::InsensitiveStr::Ascii("clation"),
        dictgen::InsensitiveStr::Ascii("clations"),
        dictgen::InsensitiveStr::Ascii("clator"),
        dictgen::InsensitiveStr::Ascii("clators"),
        dictgen::InsensitiveStr::Ascii("culate"),
        dictgen::InsensitiveStr::Ascii("culated"),
        dictgen::InsensitiveStr::Ascii("culates"),
        dictgen::InsensitiveStr::Ascii("culating"),
        dictgen::InsensitiveStr::Ascii("culation"),
        dictgen::InsensitiveStr::Ascii("culations"),
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("iflower"),
        dictgen::InsensitiveStr::Ascii("late"),
        dictgen::InsensitiveStr::Ascii("lated"),
        dictgen::InsensitiveStr::Ascii("later"),
        dictgen::InsensitiveStr::Ascii("lates"),
        dictgen::InsensitiveStr::Ascii("lating"),
        dictgen::InsensitiveStr::Ascii("lation"),
        dictgen::InsensitiveStr::Ascii("lations"),
        dictgen::InsensitiveStr::Ascii("se"),
        dictgen::InsensitiveStr::Ascii("ses"),
    ],
    values: &[
        &["calculate"],
        &["calculated"],
        &["calculates"],
        &["calculating"],
        &["calculation"],
        &["calculations"],
        &["calculate"],
        &["calculate"],
        &["calculated"],
        &["calculator"],
        &["calculates"],
        &["calculating"],
        &["calculation"],
        &["calculations"],
        &["calculator"],
        &["calculators"],
        &["calculate"],
        &["calculated"],
        &["calculates"],
        &["calculating"],
        &["calculation"],
        &["calculations"],
        &["value"],
        &["cauliflower"],
        &["calculate"],
        &["calculated"],
        &["calculator"],
        &["calculates"],
        &["calculating"],
        &["calculation"],
        &["calculations"],
        &["callous", "callus", "clause"],
        &["clauses"],
    ],
    range: 1..=9,
};

static WORD_CALS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CALS_CHILDREN),
    value: None,
};

pub static WORD_CALS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("s"),
        dictgen::InsensitiveStr::Ascii("ses"),
        dictgen::InsensitiveStr::Ascii("sification"),
        dictgen::InsensitiveStr::Ascii("sified"),
        dictgen::InsensitiveStr::Ascii("sify"),
    ],
    values: &[
        &["calls", "class"],
        &["classes"],
        &["classification"],
        &["classified"],
        &["classify"],
    ],
    range: 1..=10,
};

static WORD_CALR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CALR_CHILDREN),
    value: None,
};

pub static WORD_CALR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ification"),
        dictgen::InsensitiveStr::Ascii("ify"),
        dictgen::InsensitiveStr::Ascii("ifying"),
        dictgen::InsensitiveStr::Ascii("ity"),
        dictgen::InsensitiveStr::Ascii("kson"),
        dictgen::InsensitiveStr::Ascii("oies"),
    ],
    values: &[
        &["clarification"],
        &["clarify"],
        &["clarifying"],
        &["clarity"],
        &["clarkson"],
        &["calories"],
    ],
    range: 3..=9,
};

static WORD_CALO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CALO_CHILDREN),
    value: None,
};

pub static WORD_CALO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ires")],
    values: &[&["calories"]],
    range: 4..=4,
};

static WORD_CALL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CALL_CHILDREN),
    value: None,
};

pub static WORD_CALL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("abck"),
        dictgen::InsensitiveStr::Ascii("abcks"),
        dictgen::InsensitiveStr::Ascii("ack"),
        dictgen::InsensitiveStr::Ascii("bacl"),
        dictgen::InsensitiveStr::Ascii("bacsk"),
        dictgen::InsensitiveStr::Ascii("bak"),
        dictgen::InsensitiveStr::Ascii("bakc"),
        dictgen::InsensitiveStr::Ascii("bakcs"),
        dictgen::InsensitiveStr::Ascii("bck"),
        dictgen::InsensitiveStr::Ascii("cack"),
        dictgen::InsensitiveStr::Ascii("cain"),
        dictgen::InsensitiveStr::Ascii("d"),
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("ef"),
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("ibrate"),
        dictgen::InsensitiveStr::Ascii("ibrated"),
        dictgen::InsensitiveStr::Ascii("ibrates"),
        dictgen::InsensitiveStr::Ascii("ibrating"),
        dictgen::InsensitiveStr::Ascii("ibration"),
        dictgen::InsensitiveStr::Ascii("ibrations"),
        dictgen::InsensitiveStr::Ascii("ibri"),
        dictgen::InsensitiveStr::Ascii("iflower"),
        dictgen::InsensitiveStr::Ascii("iflowers"),
        dictgen::InsensitiveStr::Ascii("ig"),
        dictgen::InsensitiveStr::Ascii("int"),
        dictgen::InsensitiveStr::Ascii("is"),
        dictgen::InsensitiveStr::Ascii("l"),
        dictgen::InsensitiveStr::Ascii("led"),
        dictgen::InsensitiveStr::Ascii("lee"),
        dictgen::InsensitiveStr::Ascii("lers"),
        dictgen::InsensitiveStr::Ascii("oed"),
        dictgen::InsensitiveStr::Ascii("ser"),
        dictgen::InsensitiveStr::Ascii("sr"),
    ],
    values: &[
        &["callback"],
        &["callbacks"],
        &["callback"],
        &["callback"],
        &["callback"],
        &["callback"],
        &["callback"],
        &["callbacks"],
        &["callback"],
        &["callback"],
        &["callchain"],
        &["called"],
        &["called", "caller"],
        &["called", "caller"],
        &["calls", "called", "caller", "callers"],
        &["calibrate"],
        &["calibrated"],
        &["calibrates"],
        &["calibrating"],
        &["calibration"],
        &["calibrations"],
        &["calibri"],
        &["cauliflower"],
        &["cauliflowers"],
        &["calling"],
        &["calling"],
        &["callus"],
        &["call"],
        &["called"],
        &["callee"],
        &["callers"],
        &["called"],
        &["caller"],
        &["calls"],
    ],
    range: 1..=9,
};

static WORD_CALI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CALI_CHILDREN),
    value: None,
};

pub static WORD_CALI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ased"),
        dictgen::InsensitiveStr::Ascii("bartion"),
        dictgen::InsensitiveStr::Ascii("bler"),
        dictgen::InsensitiveStr::Ascii("braiton"),
        dictgen::InsensitiveStr::Ascii("braitons"),
        dictgen::InsensitiveStr::Ascii("bratin"),
        dictgen::InsensitiveStr::Ascii("braton"),
        dictgen::InsensitiveStr::Ascii("brte"),
        dictgen::InsensitiveStr::Ascii("brtion"),
        dictgen::InsensitiveStr::Ascii("cum"),
        dictgen::InsensitiveStr::Ascii("fnoria"),
        dictgen::InsensitiveStr::Ascii("fonria"),
        dictgen::InsensitiveStr::Ascii("forian"),
        dictgen::InsensitiveStr::Ascii("forina"),
        dictgen::InsensitiveStr::Ascii("forinan"),
        dictgen::InsensitiveStr::Ascii("forna"),
        dictgen::InsensitiveStr::Ascii("fornai"),
        dictgen::InsensitiveStr::Ascii("fornain"),
        dictgen::InsensitiveStr::Ascii("fornains"),
        dictgen::InsensitiveStr::Ascii("forniaman"),
        dictgen::InsensitiveStr::Ascii("fornica"),
        dictgen::InsensitiveStr::Ascii("fornican"),
        dictgen::InsensitiveStr::Ascii("fornien"),
        dictgen::InsensitiveStr::Ascii("forniia"),
        dictgen::InsensitiveStr::Ascii("fornina"),
        dictgen::InsensitiveStr::Ascii("forninan"),
        dictgen::InsensitiveStr::Ascii("fornnia"),
        dictgen::InsensitiveStr::Ascii("fronia"),
        dictgen::InsensitiveStr::Ascii("fronian"),
        dictgen::InsensitiveStr::Ascii("graphy"),
        dictgen::InsensitiveStr::Ascii("lng"),
        dictgen::InsensitiveStr::Ascii("ming"),
        dictgen::InsensitiveStr::Ascii("ng"),
        dictgen::InsensitiveStr::Ascii("ofrnia"),
    ],
    values: &[
        &["aliased"],
        &["calibration"],
        &["caliber"],
        &["calibration"],
        &["calibrations"],
        &["calibration"],
        &["calibration"],
        &["calibrate"],
        &["calibration"],
        &["calcium"],
        &["californian"],
        &["californian"],
        &["californian"],
        &["california"],
        &["californian"],
        &["california"],
        &["californian"],
        &["californian"],
        &["californian"],
        &["californian"],
        &["california"],
        &["californian"],
        &["californian"],
        &["californian"],
        &["californian"],
        &["californian"],
        &["californian"],
        &["california"],
        &["californian"],
        &["calligraphy"],
        &["calling"],
        &["claiming"],
        &["calling", "scaling", "culling"],
        &["californian"],
    ],
    range: 2..=9,
};

static WORD_CALG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CALG_CHILDREN),
    value: None,
};

pub static WORD_CALG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("arry")],
    values: &[&["calgary"]],
    range: 4..=4,
};

static WORD_CALF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CALF_CHILDREN),
    value: None,
};

pub static WORD_CALF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("s"),
    ],
    values: &[&["calves"], &["calves"]],
    range: 1..=2,
};

static WORD_CALE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CALE_CHILDREN),
    value: None,
};

pub static WORD_CALE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("d"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("ee"),
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("nday"),
        dictgen::InsensitiveStr::Ascii("r"),
        dictgen::InsensitiveStr::Ascii("scing"),
    ],
    values: &[
        &["called"],
        &["called"],
        &["callee"],
        &["callees"],
        &["calendar"],
        &["caller"],
        &["coalescing"],
    ],
    range: 1..=5,
};

static WORD_CALC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_CALC_CHILDREN),
    value: None,
};

static WORD_CALC_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_CALCA_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_CALCI_NODE),
    None,
    None,
    Some(&WORD_CALCL_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_CALCU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_CALCU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CALCU_CHILDREN),
    value: None,
};

pub static WORD_CALCU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("alate"),
        dictgen::InsensitiveStr::Ascii("alated"),
        dictgen::InsensitiveStr::Ascii("alates"),
        dictgen::InsensitiveStr::Ascii("alating"),
        dictgen::InsensitiveStr::Ascii("alation"),
        dictgen::InsensitiveStr::Ascii("alations"),
        dictgen::InsensitiveStr::Ascii("alion"),
        dictgen::InsensitiveStr::Ascii("alions"),
        dictgen::InsensitiveStr::Ascii("alte"),
        dictgen::InsensitiveStr::Ascii("alted"),
        dictgen::InsensitiveStr::Ascii("alter"),
        dictgen::InsensitiveStr::Ascii("altes"),
        dictgen::InsensitiveStr::Ascii("alting"),
        dictgen::InsensitiveStr::Ascii("altion"),
        dictgen::InsensitiveStr::Ascii("altions"),
        dictgen::InsensitiveStr::Ascii("altor"),
        dictgen::InsensitiveStr::Ascii("altors"),
        dictgen::InsensitiveStr::Ascii("ate"),
        dictgen::InsensitiveStr::Ascii("ated"),
        dictgen::InsensitiveStr::Ascii("ates"),
        dictgen::InsensitiveStr::Ascii("ation"),
        dictgen::InsensitiveStr::Ascii("ations"),
        dictgen::InsensitiveStr::Ascii("im"),
        dictgen::InsensitiveStr::Ascii("lador"),
        dictgen::InsensitiveStr::Ascii("laion"),
        dictgen::InsensitiveStr::Ascii("lar"),
        dictgen::InsensitiveStr::Ascii("laron"),
        dictgen::InsensitiveStr::Ascii("lataed"),
        dictgen::InsensitiveStr::Ascii("latble"),
        dictgen::InsensitiveStr::Ascii("later"),
        dictgen::InsensitiveStr::Ascii("laters"),
        dictgen::InsensitiveStr::Ascii("latess"),
        dictgen::InsensitiveStr::Ascii("latin"),
        dictgen::InsensitiveStr::Ascii("lationg"),
        dictgen::InsensitiveStr::Ascii("latios"),
        dictgen::InsensitiveStr::Ascii("latoare"),
        dictgen::InsensitiveStr::Ascii("latons"),
        dictgen::InsensitiveStr::Ascii("latted"),
        dictgen::InsensitiveStr::Ascii("latter"),
        dictgen::InsensitiveStr::Ascii("lattion"),
        dictgen::InsensitiveStr::Ascii("lattions"),
        dictgen::InsensitiveStr::Ascii("laution"),
        dictgen::InsensitiveStr::Ascii("lautions"),
        dictgen::InsensitiveStr::Ascii("lcate"),
        dictgen::InsensitiveStr::Ascii("lcation"),
        dictgen::InsensitiveStr::Ascii("led"),
        dictgen::InsensitiveStr::Ascii("ls"),
        dictgen::InsensitiveStr::Ascii("ltate"),
        dictgen::InsensitiveStr::Ascii("ltated"),
        dictgen::InsensitiveStr::Ascii("ltater"),
        dictgen::InsensitiveStr::Ascii("ltating"),
        dictgen::InsensitiveStr::Ascii("ltator"),
        dictgen::InsensitiveStr::Ascii("lting"),
        dictgen::InsensitiveStr::Ascii("luations"),
        dictgen::InsensitiveStr::Ascii("rate"),
        dictgen::InsensitiveStr::Ascii("rated"),
        dictgen::InsensitiveStr::Ascii("rates"),
        dictgen::InsensitiveStr::Ascii("rating"),
        dictgen::InsensitiveStr::Ascii("tate"),
        dictgen::InsensitiveStr::Ascii("tated"),
        dictgen::InsensitiveStr::Ascii("tates"),
        dictgen::InsensitiveStr::Ascii("tating"),
    ],
    values: &[
        &["calculate"],
        &["calculated"],
        &["calculates"],
        &["calculating"],
        &["calculation"],
        &["calculations"],
        &["calculation"],
        &["calculations"],
        &["calculate"],
        &["calculated"],
        &["calculator"],
        &["calculates"],
        &["calculating"],
        &["calculations", "calculation"],
        &["calculations"],
        &["calculator"],
        &["calculators"],
        &["calculate"],
        &["calculated"],
        &["calculates"],
        &["calculation"],
        &["calculations"],
        &["calcium"],
        &["calculator"],
        &["calculation"],
        &["calculator"],
        &["calculator"],
        &["calculated"],
        &["calculatable", "calculable"],
        &["calculator"],
        &["calculators"],
        &["calculated", "calculates"],
        &["calculations", "calculating", "calculation"],
        &["calculating"],
        &["calculators"],
        &["calculator"],
        &["calculations"],
        &["calculated"],
        &["calculator"],
        &["calculation"],
        &["calculations"],
        &["calculation"],
        &["calculations"],
        &["calculate"],
        &["calculation"],
        &["calculated"],
        &["calculus"],
        &["calculate"],
        &["calculated"],
        &["calculator"],
        &["calculating"],
        &["calculator"],
        &["calculating"],
        &["calculations"],
        &["calculate"],
        &["calculated"],
        &["calculates"],
        &["calculating"],
        &["calculate"],
        &["calculated"],
        &["calculates"],
        &["calculating"],
    ],
    range: 2..=8,
};

static WORD_CALCL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CALCL_CHILDREN),
    value: None,
};

pub static WORD_CALCL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ation"),
        dictgen::InsensitiveStr::Ascii("uate"),
        dictgen::InsensitiveStr::Ascii("uated"),
        dictgen::InsensitiveStr::Ascii("uates"),
        dictgen::InsensitiveStr::Ascii("uations"),
        dictgen::InsensitiveStr::Ascii("uator"),
        dictgen::InsensitiveStr::Ascii("ulate"),
        dictgen::InsensitiveStr::Ascii("ulated"),
        dictgen::InsensitiveStr::Ascii("ulates"),
        dictgen::InsensitiveStr::Ascii("ulating"),
        dictgen::InsensitiveStr::Ascii("ulation"),
        dictgen::InsensitiveStr::Ascii("ulations"),
    ],
    values: &[
        &["calculation"],
        &["calculate"],
        &["calculated"],
        &["calculates"],
        &["calculation"],
        &["calculators"],
        &["calculate"],
        &["calculated"],
        &["calculates"],
        &["calculating"],
        &["calculation"],
        &["calculations"],
    ],
    range: 4..=8,
};

static WORD_CALCI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CALCI_CHILDREN),
    value: None,
};

pub static WORD_CALCI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ulate"),
        dictgen::InsensitiveStr::Ascii("ulating"),
    ],
    values: &[&["calculate"], &["calculating"]],
    range: 5..=7,
};

static WORD_CALCA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CALCA_CHILDREN),
    value: None,
};

pub static WORD_CALCA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ble"),
        dictgen::InsensitiveStr::Ascii("late"),
    ],
    values: &[&["calculable"], &["calculate"]],
    range: 3..=4,
};

static WORD_CALB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CALB_CHILDREN),
    value: None,
};

pub static WORD_CALB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ack"),
        dictgen::InsensitiveStr::Ascii("irate"),
        dictgen::InsensitiveStr::Ascii("irated"),
        dictgen::InsensitiveStr::Ascii("irates"),
        dictgen::InsensitiveStr::Ascii("irating"),
        dictgen::InsensitiveStr::Ascii("iration"),
        dictgen::InsensitiveStr::Ascii("irations"),
        dictgen::InsensitiveStr::Ascii("irator"),
        dictgen::InsensitiveStr::Ascii("irators"),
        dictgen::InsensitiveStr::Ascii("ire"),
    ],
    values: &[
        &["callback"],
        &["calibrate"],
        &["calibrated"],
        &["calibrates"],
        &["calibrating"],
        &["calibration"],
        &["calibrations"],
        &["calibrator"],
        &["calibrators"],
        &["calibre"],
    ],
    range: 3..=8,
};

static WORD_CALA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CALA_CHILDREN),
    value: None,
};

pub static WORD_CALA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ber"),
        dictgen::InsensitiveStr::Ascii("gry"),
        dictgen::InsensitiveStr::Ascii("log"),
    ],
    values: &[&["caliber"], &["calgary"], &["catalog"]],
    range: 3..=3,
};

static WORD_CAI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CAI_CHILDREN),
    value: None,
};

pub static WORD_CAI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("lbration"),
        dictgen::InsensitiveStr::Ascii("lbre"),
        dictgen::InsensitiveStr::Ascii("nster"),
    ],
    values: &[&["calibration"], &["calibre"], &["canister"]],
    range: 4..=8,
};

static WORD_CAH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CAH_CHILDREN),
    value: None,
};

pub static WORD_CAH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("acter"),
        dictgen::InsensitiveStr::Ascii("acters"),
        dictgen::InsensitiveStr::Ascii("ange"),
        dictgen::InsensitiveStr::Ascii("anged"),
        dictgen::InsensitiveStr::Ascii("anges"),
        dictgen::InsensitiveStr::Ascii("anging"),
        dictgen::InsensitiveStr::Ascii("annel"),
        dictgen::InsensitiveStr::Ascii("aracter"),
        dictgen::InsensitiveStr::Ascii("aracters"),
        dictgen::InsensitiveStr::Ascii("arcter"),
        dictgen::InsensitiveStr::Ascii("arcters"),
        dictgen::InsensitiveStr::Ascii("c"),
        dictgen::InsensitiveStr::Ascii("ce"),
        dictgen::InsensitiveStr::Ascii("ced"),
        dictgen::InsensitiveStr::Ascii("ces"),
        dictgen::InsensitiveStr::Ascii("che"),
        dictgen::InsensitiveStr::Ascii("ched"),
        dictgen::InsensitiveStr::Ascii("chedb"),
        dictgen::InsensitiveStr::Ascii("ches"),
        dictgen::InsensitiveStr::Ascii("cing"),
        dictgen::InsensitiveStr::Ascii("cs"),
        dictgen::InsensitiveStr::Ascii("didate"),
        dictgen::InsensitiveStr::Ascii("didates"),
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("gne"),
        dictgen::InsensitiveStr::Ascii("gned"),
        dictgen::InsensitiveStr::Ascii("gner"),
        dictgen::InsensitiveStr::Ascii("gners"),
        dictgen::InsensitiveStr::Ascii("gnes"),
        dictgen::InsensitiveStr::Ascii("gning"),
        dictgen::InsensitiveStr::Ascii("hel"),
        dictgen::InsensitiveStr::Ascii("hels"),
        dictgen::InsensitiveStr::Ascii("ined"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("ining"),
        dictgen::InsensitiveStr::Ascii("nge"),
        dictgen::InsensitiveStr::Ascii("nged"),
        dictgen::InsensitiveStr::Ascii("nges"),
        dictgen::InsensitiveStr::Ascii("nging"),
        dictgen::InsensitiveStr::Ascii("nnel"),
        dictgen::InsensitiveStr::Ascii("nnels"),
        dictgen::InsensitiveStr::Ascii("otic"),
        dictgen::InsensitiveStr::Ascii("r"),
        dictgen::InsensitiveStr::Ascii("racter"),
        dictgen::InsensitiveStr::Ascii("racters"),
        dictgen::InsensitiveStr::Ascii("rging"),
        dictgen::InsensitiveStr::Ascii("rs"),
        dictgen::InsensitiveStr::Ascii("sier"),
        dictgen::InsensitiveStr::Ascii("siers"),
    ],
    values: &[
        &["character"],
        &["characters"],
        &["change"],
        &["changed"],
        &["changes"],
        &["changing"],
        &["channel"],
        &["character"],
        &["characters"],
        &["character"],
        &["characters"],
        &["cache"],
        &["cache"],
        &["cached"],
        &["caches"],
        &["cache"],
        &["cached"],
        &["cachedb"],
        &["caches"],
        &["caching"],
        &["caches"],
        &["candidate"],
        &["candidates"],
        &["cache"],
        &["caches"],
        &["change"],
        &["changed"],
        &["changer"],
        &["changers"],
        &["changes"],
        &["changing"],
        &["channel"],
        &["channels"],
        &["chained"],
        &["caching"],
        &["chaining"],
        &["change"],
        &["changed"],
        &["changes"],
        &["changing"],
        &["channel"],
        &["channels"],
        &["chaotic"],
        &["char"],
        &["character"],
        &["characters"],
        &["charging"],
        &["chars"],
        &["cashier"],
        &["cashiers"],
    ],
    range: 1..=8,
};

static WORD_CAF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CAF_CHILDREN),
    value: Some(&["calf"]),
};

pub static WORD_CAF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ay"),
        dictgen::InsensitiveStr::Ascii("ays"),
        dictgen::InsensitiveStr::Ascii("eteira"),
        dictgen::InsensitiveStr::Ascii("etera"),
        dictgen::InsensitiveStr::Ascii("etiera"),
        dictgen::InsensitiveStr::Ascii("feen"),
        dictgen::InsensitiveStr::Ascii("feinne"),
        dictgen::InsensitiveStr::Ascii("finee"),
        dictgen::InsensitiveStr::Ascii("ine"),
        dictgen::InsensitiveStr::Ascii("s"),
    ],
    values: &[
        &["cafe"],
        &["cafes"],
        &["cafeteria"],
        &["cafeteria"],
        &["cafeteria"],
        &["caffeine"],
        &["caffeine"],
        &["caffeine"],
        &["caffeine"],
        &["calves"],
    ],
    range: 1..=6,
};

static WORD_CAE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CAE_CHILDREN),
    value: None,
};

pub static WORD_CAE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("fully"),
        dictgen::InsensitiveStr::Ascii("se"),
        dictgen::InsensitiveStr::Ascii("sed"),
        dictgen::InsensitiveStr::Ascii("seing"),
        dictgen::InsensitiveStr::Ascii("ses"),
    ],
    values: &[
        &["carefully"],
        &["cease"],
        &["ceased"],
        &["ceasing"],
        &["ceases"],
    ],
    range: 2..=5,
};

static WORD_CAD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CAD_CHILDREN),
    value: None,
};

pub static WORD_CAD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("idate")],
    values: &[&["candidate"]],
    range: 5..=5,
};

static WORD_CAC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CAC_CHILDREN),
    value: None,
};

pub static WORD_CAC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ahe"),
        dictgen::InsensitiveStr::Ascii("ahes"),
        dictgen::InsensitiveStr::Ascii("ausian"),
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("h"),
        dictgen::InsensitiveStr::Ascii("hable"),
        dictgen::InsensitiveStr::Ascii("heed"),
        dictgen::InsensitiveStr::Ascii("heing"),
        dictgen::InsensitiveStr::Ascii("hline"),
        dictgen::InsensitiveStr::Ascii("hse"),
        dictgen::InsensitiveStr::Ascii("hup"),
        dictgen::InsensitiveStr::Ascii("l"),
        dictgen::InsensitiveStr::Ascii("late"),
        dictgen::InsensitiveStr::Ascii("lium"),
        dictgen::InsensitiveStr::Ascii("lualted"),
        dictgen::InsensitiveStr::Ascii("luate"),
        dictgen::InsensitiveStr::Ascii("luated"),
        dictgen::InsensitiveStr::Ascii("luater"),
        dictgen::InsensitiveStr::Ascii("luates"),
        dictgen::InsensitiveStr::Ascii("luating"),
        dictgen::InsensitiveStr::Ascii("luation"),
        dictgen::InsensitiveStr::Ascii("luations"),
        dictgen::InsensitiveStr::Ascii("luator"),
        dictgen::InsensitiveStr::Ascii("lucate"),
        dictgen::InsensitiveStr::Ascii("lucation"),
        dictgen::InsensitiveStr::Ascii("lucations"),
        dictgen::InsensitiveStr::Ascii("lucator"),
        dictgen::InsensitiveStr::Ascii("lulate"),
        dictgen::InsensitiveStr::Ascii("lulated"),
        dictgen::InsensitiveStr::Ascii("lulates"),
        dictgen::InsensitiveStr::Ascii("lulating"),
        dictgen::InsensitiveStr::Ascii("lulation"),
        dictgen::InsensitiveStr::Ascii("lulations"),
        dictgen::InsensitiveStr::Ascii("lulator"),
        dictgen::InsensitiveStr::Ascii("lulators"),
        dictgen::InsensitiveStr::Ascii("lulus"),
        dictgen::InsensitiveStr::Ascii("oon"),
        dictgen::InsensitiveStr::Ascii("oons"),
        dictgen::InsensitiveStr::Ascii("uasian"),
        dictgen::InsensitiveStr::Ascii("ulate"),
        dictgen::InsensitiveStr::Ascii("ulated"),
        dictgen::InsensitiveStr::Ascii("ulater"),
        dictgen::InsensitiveStr::Ascii("ulates"),
        dictgen::InsensitiveStr::Ascii("ulating"),
        dictgen::InsensitiveStr::Ascii("ulation"),
        dictgen::InsensitiveStr::Ascii("ulations"),
        dictgen::InsensitiveStr::Ascii("ulator"),
        dictgen::InsensitiveStr::Ascii("uses"),
    ],
    values: &[
        &["cache"],
        &["caches"],
        &["caucasian"],
        &["cache"],
        &["catch", "cache"],
        &["cacheable"],
        &["cached"],
        &["caching"],
        &["cacheline"],
        &["cache", "caches"],
        &["catchup"],
        &["calc"],
        &["calculate"],
        &["calcium"],
        &["calculated"],
        &["calculate"],
        &["calculated"],
        &["calculator"],
        &["calculates"],
        &["calculating"],
        &["calculation"],
        &["calculations"],
        &["calculator"],
        &["calculate"],
        &["calculation"],
        &["calculations"],
        &["calculator"],
        &["calculate"],
        &["calculated"],
        &["calculates"],
        &["calculating"],
        &["calculation"],
        &["calculations"],
        &["calculator"],
        &["calculators"],
        &["calculus"],
        &["cocoon"],
        &["cocoons"],
        &["caucasian"],
        &["calculate"],
        &["calculated"],
        &["calculator"],
        &["calculates"],
        &["calculating"],
        &["calculation"],
        &["calculations"],
        &["calculator"],
        &["caucuses"],
    ],
    range: 1..=9,
};

static WORD_CAB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_CAB_CHILDREN),
    value: None,
};

pub static WORD_CAB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("abge"),
        dictgen::InsensitiveStr::Ascii("abilities"),
        dictgen::InsensitiveStr::Ascii("bagge"),
        dictgen::InsensitiveStr::Ascii("ients"),
        dictgen::InsensitiveStr::Ascii("inate"),
        dictgen::InsensitiveStr::Ascii("inent"),
        dictgen::InsensitiveStr::Ascii("ines"),
        dictgen::InsensitiveStr::Ascii("inettas"),
        dictgen::InsensitiveStr::Ascii("int"),
        dictgen::InsensitiveStr::Ascii("ints"),
        dictgen::InsensitiveStr::Ascii("net"),
        dictgen::InsensitiveStr::Ascii("nets"),
        dictgen::InsensitiveStr::Ascii("niet"),
        dictgen::InsensitiveStr::Ascii("niets"),
    ],
    values: &[
        &["cabbage"],
        &["capabilities"],
        &["cabbage"],
        &["cabinets"],
        &["cabinet"],
        &["cabinet"],
        &["cabinets"],
        &["cabinets"],
        &["cabinet"],
        &["cabinets"],
        &["cabinet"],
        &["cabinets"],
        &["cabinet"],
        &["cabinets"],
    ],
    range: 3..=9,
};

static WORD_B_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_B_CHILDREN),
    value: None,
};

static WORD_B_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_BA_NODE),
    Some(&WORD_BB_NODE),
    Some(&WORD_BC_NODE),
    None,
    Some(&WORD_BE_NODE),
    Some(&WORD_BF_NODE),
    Some(&WORD_BG_NODE),
    None,
    Some(&WORD_BI_NODE),
    Some(&WORD_BJ_NODE),
    None,
    Some(&WORD_BL_NODE),
    None,
    Some(&WORD_BN_NODE),
    Some(&WORD_BO_NODE),
    None,
    None,
    Some(&WORD_BR_NODE),
    None,
    Some(&WORD_BT_NODE),
    Some(&WORD_BU_NODE),
    Some(&WORD_BV_NODE),
    Some(&WORD_BW_NODE),
    None,
    Some(&WORD_BY_NODE),
    None,
];

static WORD_BY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BY_CHILDREN),
    value: None,
};

pub static WORD_BY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ast"),
        dictgen::InsensitiveStr::Ascii("cicle"),
        dictgen::InsensitiveStr::Ascii("cicled"),
        dictgen::InsensitiveStr::Ascii("cicles"),
        dictgen::InsensitiveStr::Ascii("cicling"),
        dictgen::InsensitiveStr::Ascii("ciclist"),
        dictgen::InsensitiveStr::Ascii("pas"),
        dictgen::InsensitiveStr::Ascii("pased"),
        dictgen::InsensitiveStr::Ascii("pasing"),
        dictgen::InsensitiveStr::Ascii("teoder"),
        dictgen::InsensitiveStr::Ascii("tetream"),
        dictgen::InsensitiveStr::Ascii("tetreams"),
    ],
    values: &[
        &["biased"],
        &["bicycle"],
        &["bicycled"],
        &["bicycles"],
        &["bicycling"],
        &["bicyclist"],
        &["bypass"],
        &["bypassed"],
        &["bypassing"],
        &["byteorder"],
        &["bytestream"],
        &["bytestreams"],
    ],
    range: 3..=8,
};

static WORD_BW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BW_CHILDREN),
    value: None,
};

pub static WORD_BW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("tween")],
    values: &[&["between"]],
    range: 5..=5,
};

static WORD_BV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BV_CHILDREN),
    value: None,
};

pub static WORD_BV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("e")],
    values: &[&["be"]],
    range: 1..=1,
};

static WORD_BU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_BU_CHILDREN),
    value: None,
};

static WORD_BU_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_BUA_NODE),
    Some(&WORD_BUB_NODE),
    None,
    Some(&WORD_BUD_NODE),
    Some(&WORD_BUE_NODE),
    Some(&WORD_BUF_NODE),
    Some(&WORD_BUG_NODE),
    Some(&WORD_BUH_NODE),
    Some(&WORD_BUI_NODE),
    None,
    None,
    Some(&WORD_BUL_NODE),
    Some(&WORD_BUM_NODE),
    Some(&WORD_BUN_NODE),
    Some(&WORD_BUO_NODE),
    None,
    None,
    Some(&WORD_BUR_NODE),
    Some(&WORD_BUS_NODE),
    Some(&WORD_BUT_NODE),
    Some(&WORD_BUU_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_BUZ_NODE),
];

static WORD_BUZ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BUZ_CHILDREN),
    value: None,
};

pub static WORD_BUZ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("illa")],
    values: &[&["bugzilla"]],
    range: 4..=4,
};

static WORD_BUU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BUU_CHILDREN),
    value: None,
};

pub static WORD_BUU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("fers"),
        dictgen::InsensitiveStr::Ascii("ild"),
        dictgen::InsensitiveStr::Ascii("ilds"),
    ],
    values: &[&["buffers"], &["build"], &["builds"]],
    range: 3..=4,
};

static WORD_BUT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BUT_CHILDREN),
    value: None,
};

pub static WORD_BUT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cherd"),
        dictgen::InsensitiveStr::Ascii("hcered"),
        dictgen::InsensitiveStr::Ascii("iful"),
        dictgen::InsensitiveStr::Ascii("ifully"),
        dictgen::InsensitiveStr::Ascii("ifuly"),
        dictgen::InsensitiveStr::Ascii("on"),
        dictgen::InsensitiveStr::Ascii("ons"),
        dictgen::InsensitiveStr::Ascii("terey"),
        dictgen::InsensitiveStr::Ascii("terfies"),
        dictgen::InsensitiveStr::Ascii("terfiles"),
        dictgen::InsensitiveStr::Ascii("terfleye"),
        dictgen::InsensitiveStr::Ascii("terflyes"),
        dictgen::InsensitiveStr::Ascii("terfries"),
        dictgen::InsensitiveStr::Ascii("terfy"),
        dictgen::InsensitiveStr::Ascii("terlfies"),
        dictgen::InsensitiveStr::Ascii("terlfy"),
        dictgen::InsensitiveStr::Ascii("terly"),
        dictgen::InsensitiveStr::Ascii("terry"),
        dictgen::InsensitiveStr::Ascii("thoe"),
        dictgen::InsensitiveStr::Ascii("thoel"),
        dictgen::InsensitiveStr::Ascii("tin"),
        dictgen::InsensitiveStr::Ascii("tins"),
        dictgen::InsensitiveStr::Ascii("tom"),
        dictgen::InsensitiveStr::Ascii("toms"),
        dictgen::InsensitiveStr::Ascii("tong"),
        dictgen::InsensitiveStr::Ascii("tonn"),
        dictgen::InsensitiveStr::Ascii("tonns"),
        dictgen::InsensitiveStr::Ascii("tosn"),
        dictgen::InsensitiveStr::Ascii("trey"),
        dictgen::InsensitiveStr::Ascii("tton"),
        dictgen::InsensitiveStr::Ascii("ttons"),
    ],
    values: &[
        &["butchered"],
        &["butchered"],
        &["beautiful"],
        &["beautifully"],
        &["beautifully"],
        &["button"],
        &["buttons"],
        &["buttery"],
        &["butterflies"],
        &["butterflies"],
        &["butterfly"],
        &["butterflies"],
        &["butterflies"],
        &["butterfly"],
        &["butterflies"],
        &["butterfly"],
        &["butterfly"],
        &["buttery"],
        &["butthole"],
        &["butthole"],
        &["button"],
        &["buttons"],
        &["button", "bottom"],
        &["buttons", "bottom"],
        &["button"],
        &["button"],
        &["buttons"],
        &["buttons"],
        &["buttery"],
        &["button"],
        &["buttons"],
    ],
    range: 2..=8,
};

static WORD_BUS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BUS_CHILDREN),
    value: None,
};

pub static WORD_BUS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ines"),
        dictgen::InsensitiveStr::Ascii("ineses"),
        dictgen::InsensitiveStr::Ascii("inesman"),
        dictgen::InsensitiveStr::Ascii("inesmen"),
        dictgen::InsensitiveStr::Ascii("inessa"),
        dictgen::InsensitiveStr::Ascii("inesse"),
        dictgen::InsensitiveStr::Ascii("inessemen"),
        dictgen::InsensitiveStr::Ascii("inessen"),
        dictgen::InsensitiveStr::Ascii("inessnes"),
        dictgen::InsensitiveStr::Ascii("inesss"),
        dictgen::InsensitiveStr::Ascii("ness"),
        dictgen::InsensitiveStr::Ascii("niessmen"),
        dictgen::InsensitiveStr::Ascii("rting"),
        dictgen::InsensitiveStr::Ascii("siness"),
        dictgen::InsensitiveStr::Ascii("sy"),
    ],
    values: &[
        &["business"],
        &["business", "businesses"],
        &["businessman"],
        &["businessmen"],
        &["businessman"],
        &["businessmen"],
        &["businessmen"],
        &["businessmen"],
        &["businessmen"],
        &["businesses"],
        &["business"],
        &["businessmen"],
        &["bursting"],
        &["business"],
        &["busy"],
    ],
    range: 2..=9,
};

static WORD_BUR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BUR_CHILDREN),
    value: None,
};

pub static WORD_BUR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("bon"),
        dictgen::InsensitiveStr::Ascii("eacuracy"),
        dictgen::InsensitiveStr::Ascii("eaocracy"),
        dictgen::InsensitiveStr::Ascii("eaocratic"),
        dictgen::InsensitiveStr::Ascii("eaocrats"),
        dictgen::InsensitiveStr::Ascii("eaucats"),
        dictgen::InsensitiveStr::Ascii("eaucracie"),
        dictgen::InsensitiveStr::Ascii("eaucractic"),
        dictgen::InsensitiveStr::Ascii("eaucracts"),
        dictgen::InsensitiveStr::Ascii("eaucraps"),
        dictgen::InsensitiveStr::Ascii("eaucrash"),
        dictgen::InsensitiveStr::Ascii("eaucrasy"),
        dictgen::InsensitiveStr::Ascii("eaucrates"),
        dictgen::InsensitiveStr::Ascii("eaucratics"),
        dictgen::InsensitiveStr::Ascii("eaucratisch"),
        dictgen::InsensitiveStr::Ascii("eaucratische"),
        dictgen::InsensitiveStr::Ascii("eaucratius"),
        dictgen::InsensitiveStr::Ascii("eaucrazy"),
        dictgen::InsensitiveStr::Ascii("eauracy"),
        dictgen::InsensitiveStr::Ascii("euacracy"),
        dictgen::InsensitiveStr::Ascii("euacratic"),
        dictgen::InsensitiveStr::Ascii("euacrats"),
        dictgen::InsensitiveStr::Ascii("gunday"),
        dictgen::InsensitiveStr::Ascii("gundry"),
        dictgen::InsensitiveStr::Ascii("guny"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("iser"),
        dictgen::InsensitiveStr::Ascii("isers"),
        dictgen::InsensitiveStr::Ascii("jun"),
        dictgen::InsensitiveStr::Ascii("juns"),
        dictgen::InsensitiveStr::Ascii("lgar"),
        dictgen::InsensitiveStr::Ascii("nign"),
        dictgen::InsensitiveStr::Ascii("o"),
        dictgen::InsensitiveStr::Ascii("ocratic"),
        dictgen::InsensitiveStr::Ascii("os"),
        dictgen::InsensitiveStr::Ascii("ried"),
        dictgen::InsensitiveStr::Ascii("riots"),
        dictgen::InsensitiveStr::Ascii("ritio"),
        dictgen::InsensitiveStr::Ascii("ritoes"),
        dictgen::InsensitiveStr::Ascii("ritto"),
        dictgen::InsensitiveStr::Ascii("rtio"),
        dictgen::InsensitiveStr::Ascii("rtios"),
        dictgen::InsensitiveStr::Ascii("ssels"),
        dictgen::InsensitiveStr::Ascii("tality"),
        dictgen::InsensitiveStr::Ascii("tally"),
        dictgen::InsensitiveStr::Ascii("tsing"),
        dictgen::InsensitiveStr::Ascii("tst"),
        dictgen::InsensitiveStr::Ascii("ueacrats"),
        dictgen::InsensitiveStr::Ascii("zwah"),
    ],
    values: &[
        &["bourbon"],
        &["bureaucracy"],
        &["bureaucracy"],
        &["bureaucratic"],
        &["bureaucrats"],
        &["bureaucrats"],
        &["bureaucratic"],
        &["bureaucratic"],
        &["bureaucrats"],
        &["bureaucrats"],
        &["bureaucrats"],
        &["bureaucrats"],
        &["bureaucrats"],
        &["bureaucrats"],
        &["bureaucratic"],
        &["bureaucratic"],
        &["bureaucrats"],
        &["bureaucracy"],
        &["bureaucracy"],
        &["bureaucracy"],
        &["bureaucratic"],
        &["bureaucrats"],
        &["burgundy"],
        &["burgundy"],
        &["burgundy"],
        &["burying", "burning", "burin", "during"],
        &["bruiser"],
        &["bruisers"],
        &["burgeon"],
        &["burgeons"],
        &["burglar"],
        &["burning"],
        &["bureau", "burro"],
        &["bureaucratic"],
        &["bureaus", "burros"],
        &["buried"],
        &["burritos"],
        &["burrito"],
        &["burritos"],
        &["burrito"],
        &["burrito"],
        &["burritos"],
        &["brussels"],
        &["brutality"],
        &["brutally"],
        &["bursting"],
        &["burst"],
        &["bureaucrats"],
        &["bourgeois"],
    ],
    range: 1..=12,
};

static WORD_BUO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BUO_CHILDREN),
    value: None,
};

pub static WORD_BUO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ancy")],
    values: &[&["buoyancy"]],
    range: 4..=4,
};

static WORD_BUN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BUN_CHILDREN),
    value: None,
};

pub static WORD_BUN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ble"),
        dictgen::InsensitiveStr::Ascii("bled"),
        dictgen::InsensitiveStr::Ascii("bler"),
        dictgen::InsensitiveStr::Ascii("bling"),
        dictgen::InsensitiveStr::Ascii("d"),
        dictgen::InsensitiveStr::Ascii("ded"),
        dictgen::InsensitiveStr::Ascii("del"),
        dictgen::InsensitiveStr::Ascii("deled"),
        dictgen::InsensitiveStr::Ascii("dels"),
        dictgen::InsensitiveStr::Ascii("ding"),
        dictgen::InsensitiveStr::Ascii("ds"),
        dictgen::InsensitiveStr::Ascii("ji"),
        dictgen::InsensitiveStr::Ascii("lde"),
        dictgen::InsensitiveStr::Ascii("lder"),
        dictgen::InsensitiveStr::Ascii("ldes"),
        dictgen::InsensitiveStr::Ascii("lding"),
    ],
    values: &[
        &["bundle"],
        &["bundled"],
        &["bundler"],
        &["bundling"],
        &["bind", "bound"],
        &["binded", "bounded", "bundled"],
        &["bundle"],
        &["bundled"],
        &["bundles"],
        &["binding", "bounding", "bundling"],
        &["binds", "bounds"],
        &["bungee"],
        &["bundle"],
        &["bundler"],
        &["bundles"],
        &["bundling"],
    ],
    range: 1..=5,
};

static WORD_BUM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BUM_CHILDREN),
    value: None,
};

pub static WORD_BUM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("b"),
        dictgen::InsensitiveStr::Ascii("bed"),
        dictgen::InsensitiveStr::Ascii("ber"),
        dictgen::InsensitiveStr::Ascii("bing"),
        dictgen::InsensitiveStr::Ascii("by"),
        dictgen::InsensitiveStr::Ascii("pded"),
        dictgen::InsensitiveStr::Ascii("pt"),
        dictgen::InsensitiveStr::Ascii("pted"),
        dictgen::InsensitiveStr::Ascii("pter"),
        dictgen::InsensitiveStr::Ascii("pting"),
    ],
    values: &[
        &["bump", "bomb", "bum"],
        &["bombed", "bumped"],
        &["bomber", "bummer", "bumper", "number"],
        &["bombing", "bumping"],
        &["bumpy"],
        &["bumped"],
        &["bump"],
        &["bumped"],
        &["bumper"],
        &["bumping"],
    ],
    range: 1..=5,
};

static WORD_BUL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BUL_CHILDREN),
    value: None,
};

pub static WORD_BUL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("agria"),
        dictgen::InsensitiveStr::Ascii("d"),
        dictgen::InsensitiveStr::Ascii("ding"),
        dictgen::InsensitiveStr::Ascii("dning"),
        dictgen::InsensitiveStr::Ascii("ds"),
        dictgen::InsensitiveStr::Ascii("gaia"),
        dictgen::InsensitiveStr::Ascii("gaira"),
        dictgen::InsensitiveStr::Ascii("gara"),
        dictgen::InsensitiveStr::Ascii("gariska"),
        dictgen::InsensitiveStr::Ascii("grian"),
        dictgen::InsensitiveStr::Ascii("id"),
        dictgen::InsensitiveStr::Ascii("iders"),
        dictgen::InsensitiveStr::Ascii("iding"),
        dictgen::InsensitiveStr::Ascii("idings"),
        dictgen::InsensitiveStr::Ascii("ids"),
        dictgen::InsensitiveStr::Ascii("it"),
        dictgen::InsensitiveStr::Ascii("le"),
        dictgen::InsensitiveStr::Ascii("lerproof"),
        dictgen::InsensitiveStr::Ascii("lest"),
        dictgen::InsensitiveStr::Ascii("letbroof"),
        dictgen::InsensitiveStr::Ascii("letpoof"),
        dictgen::InsensitiveStr::Ascii("letprof"),
        dictgen::InsensitiveStr::Ascii("letproff"),
        dictgen::InsensitiveStr::Ascii("letprooof"),
        dictgen::InsensitiveStr::Ascii("letprrof"),
        dictgen::InsensitiveStr::Ascii("letted"),
        dictgen::InsensitiveStr::Ascii("letts"),
        dictgen::InsensitiveStr::Ascii("levard"),
        dictgen::InsensitiveStr::Ascii("levards"),
        dictgen::InsensitiveStr::Ascii("litproof"),
        dictgen::InsensitiveStr::Ascii("lyan"),
        dictgen::InsensitiveStr::Ascii("nerabilities"),
        dictgen::InsensitiveStr::Ascii("nerability"),
        dictgen::InsensitiveStr::Ascii("nerable"),
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("tin"),
    ],
    values: &[
        &["bulgaria"],
        &["build"],
        &["building"],
        &["building"],
        &["builds"],
        &["bulgaria"],
        &["bulgaria"],
        &["bulgaria"],
        &["bulgaria"],
        &["bulgarian"],
        &["build"],
        &["builders"],
        &["building"],
        &["buildings"],
        &["builds"],
        &["built"],
        &["bullet"],
        &["bulletproof"],
        &["bullets"],
        &["bulletproof"],
        &["bulletproof"],
        &["bulletproof"],
        &["bulletproof"],
        &["bulletproof"],
        &["bulletproof"],
        &["bulleted"],
        &["bullets"],
        &["boulevard"],
        &["boulevards"],
        &["bulletproof"],
        &["bouillon"],
        &["vulnerabilities"],
        &["vulnerability"],
        &["vulnerable"],
        &["built"],
        &["builtin"],
    ],
    range: 1..=12,
};

static WORD_BUI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BUI_CHILDREN),
    value: Some(&["buoy", "buy"]),
};

pub static WORD_BUI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("d"),
        dictgen::InsensitiveStr::Ascii("der"),
        dictgen::InsensitiveStr::Ascii("ders"),
        dictgen::InsensitiveStr::Ascii("ding"),
        dictgen::InsensitiveStr::Ascii("dl"),
        dictgen::InsensitiveStr::Ascii("dlers"),
        dictgen::InsensitiveStr::Ascii("dling"),
        dictgen::InsensitiveStr::Ascii("dlings"),
        dictgen::InsensitiveStr::Ascii("dls"),
        dictgen::InsensitiveStr::Ascii("ild"),
        dictgen::InsensitiveStr::Ascii("k"),
        dictgen::InsensitiveStr::Ascii("l"),
        dictgen::InsensitiveStr::Ascii("ldd"),
        dictgen::InsensitiveStr::Ascii("lded"),
        dictgen::InsensitiveStr::Ascii("ldes"),
        dictgen::InsensitiveStr::Ascii("ldins"),
        dictgen::InsensitiveStr::Ascii("ldning"),
        dictgen::InsensitiveStr::Ascii("ldnings"),
        dictgen::InsensitiveStr::Ascii("ldpackge"),
        dictgen::InsensitiveStr::Ascii("ldpackges"),
        dictgen::InsensitiveStr::Ascii("ling"),
        dictgen::InsensitiveStr::Ascii("lings"),
        dictgen::InsensitiveStr::Ascii("llt"),
        dictgen::InsensitiveStr::Ascii("lr"),
        dictgen::InsensitiveStr::Ascii("ls"),
        dictgen::InsensitiveStr::Ascii("lter"),
        dictgen::InsensitiveStr::Ascii("lters"),
        dictgen::InsensitiveStr::Ascii("nseses"),
        dictgen::InsensitiveStr::Ascii("nsess"),
        dictgen::InsensitiveStr::Ascii("nsesses"),
        dictgen::InsensitiveStr::Ascii("pd"),
        dictgen::InsensitiveStr::Ascii("s"),
        dictgen::InsensitiveStr::Ascii("sness"),
        dictgen::InsensitiveStr::Ascii("snesses"),
        dictgen::InsensitiveStr::Ascii("snessman"),
        dictgen::InsensitiveStr::Ascii("snessmen"),
        dictgen::InsensitiveStr::Ascii("ssiness"),
        dictgen::InsensitiveStr::Ascii("ssinesses"),
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("tin"),
        dictgen::InsensitiveStr::Ascii("tins"),
        dictgen::InsensitiveStr::Ascii("tlin"),
        dictgen::InsensitiveStr::Ascii("tlins"),
        dictgen::InsensitiveStr::Ascii("tton"),
        dictgen::InsensitiveStr::Ascii("ttons"),
    ],
    values: &[
        &["build"],
        &["builder"],
        &["builders"],
        &["building"],
        &["build"],
        &["builders"],
        &["building"],
        &["buildings"],
        &["builds"],
        &["build"],
        &["bulk"],
        &["build", "built"],
        &["build", "builds"],
        &["built"],
        &["builders"],
        &["buildings"],
        &["building"],
        &["buildings"],
        &["buildpackage"],
        &["buildpackages"],
        &["building"],
        &["buildings"],
        &["built"],
        &["build"],
        &["builds"],
        &["builder"],
        &["builders"],
        &["businesses"],
        &["business"],
        &["businesses"],
        &["build"],
        &["buoy", "buoys", "buys"],
        &["business"],
        &["businesses"],
        &["businessman"],
        &["businessmen"],
        &["business"],
        &["businesses"],
        &["built"],
        &["builtin"],
        &["builtins"],
        &["builtin"],
        &["builtins"],
        &["button"],
        &["buttons"],
    ],
    range: 1..=9,
};

static WORD_BUH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BUH_CHILDREN),
    value: None,
};

pub static WORD_BUH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ddism"),
        dictgen::InsensitiveStr::Ascii("ddist"),
        dictgen::InsensitiveStr::Ascii("ddists"),
    ],
    values: &[&["buddhism"], &["buddhist"], &["buddhists"]],
    range: 5..=6,
};

static WORD_BUG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BUG_CHILDREN),
    value: None,
};

pub static WORD_BUG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("dets"),
        dictgen::InsensitiveStr::Ascii("gest"),
        dictgen::InsensitiveStr::Ascii("ix"),
        dictgen::InsensitiveStr::Ascii("laria"),
        dictgen::InsensitiveStr::Ascii("ous"),
        dictgen::InsensitiveStr::Ascii("uous"),
        dictgen::InsensitiveStr::Ascii("us"),
    ],
    values: &[
        &["budgets"],
        &["biggest"],
        &["bugfix"],
        &["bulgaria"],
        &["bogus"],
        &["bogus"],
        &["bogus"],
    ],
    range: 2..=5,
};

static WORD_BUF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BUF_CHILDREN),
    value: None,
};

pub static WORD_BUF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("efr"),
        dictgen::InsensitiveStr::Ascii("er"),
        dictgen::InsensitiveStr::Ascii("ers"),
        dictgen::InsensitiveStr::Ascii("fereed"),
        dictgen::InsensitiveStr::Ascii("ferent"),
        dictgen::InsensitiveStr::Ascii("feres"),
        dictgen::InsensitiveStr::Ascii("ferred"),
        dictgen::InsensitiveStr::Ascii("feur"),
        dictgen::InsensitiveStr::Ascii("ffer"),
        dictgen::InsensitiveStr::Ascii("ffers"),
        dictgen::InsensitiveStr::Ascii("for"),
        dictgen::InsensitiveStr::Ascii("fors"),
        dictgen::InsensitiveStr::Ascii("fr"),
        dictgen::InsensitiveStr::Ascii("fred"),
        dictgen::InsensitiveStr::Ascii("fring"),
        dictgen::InsensitiveStr::Ascii("ufer"),
    ],
    values: &[
        &["buffer"],
        &["buffer"],
        &["buffers"],
        &["buffered"],
        &["buffered"],
        &["buffered", "buffers"],
        &["buffered"],
        &["buffer"],
        &["buffer"],
        &["buffers"],
        &["buffer"],
        &["buffers"],
        &["buffer"],
        &["buffered"],
        &["buffering"],
        &["buffer"],
    ],
    range: 2..=6,
};

static WORD_BUE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BUE_CHILDREN),
    value: None,
};

pub static WORD_BUE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("arucratic"),
        dictgen::InsensitiveStr::Ascii("arucrats"),
        dictgen::InsensitiveStr::Ascii("raucracy"),
        dictgen::InsensitiveStr::Ascii("raucratic"),
        dictgen::InsensitiveStr::Ascii("raucrats"),
    ],
    values: &[
        &["bureaucratic"],
        &["bureaucrats"],
        &["bureaucracy"],
        &["bureaucratic"],
        &["bureaucrats"],
    ],
    range: 8..=9,
};

static WORD_BUD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BUD_CHILDREN),
    value: None,
};

pub static WORD_BUD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("a"),
        dictgen::InsensitiveStr::Ascii("dah"),
        dictgen::InsensitiveStr::Ascii("dhim"),
        dictgen::InsensitiveStr::Ascii("dhisim"),
        dictgen::InsensitiveStr::Ascii("dhistisk"),
        dictgen::InsensitiveStr::Ascii("dhit"),
        dictgen::InsensitiveStr::Ascii("dhits"),
        dictgen::InsensitiveStr::Ascii("dhsim"),
        dictgen::InsensitiveStr::Ascii("dihsts"),
        dictgen::InsensitiveStr::Ascii("dishm"),
        dictgen::InsensitiveStr::Ascii("disht"),
        dictgen::InsensitiveStr::Ascii("dishts"),
        dictgen::InsensitiveStr::Ascii("dist"),
        dictgen::InsensitiveStr::Ascii("gest"),
        dictgen::InsensitiveStr::Ascii("led"),
    ],
    values: &[
        &["buddha"],
        &["buddha"],
        &["buddhism"],
        &["buddhism"],
        &["buddhists"],
        &["buddhist"],
        &["buddhist"],
        &["buddhism"],
        &["buddhists"],
        &["buddhism"],
        &["buddhist"],
        &["buddhists"],
        &["buddhist"],
        &["budgets"],
        &["bundled"],
    ],
    range: 1..=8,
};

static WORD_BUB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BUB_CHILDREN),
    value: None,
};

pub static WORD_BUB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("bels"),
        dictgen::InsensitiveStr::Ascii("bless"),
        dictgen::InsensitiveStr::Ascii("blews"),
    ],
    values: &[&["bubbles"], &["bubbles"], &["bubbles"]],
    range: 4..=5,
};

static WORD_BUA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BUA_CHILDREN),
    value: None,
};

pub static WORD_BUA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("d")],
    values: &[&["baud"]],
    range: 1..=1,
};

static WORD_BT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BT_CHILDREN),
    value: None,
};

pub static WORD_BT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("iched"),
        dictgen::InsensitiveStr::Ascii("iches"),
        dictgen::InsensitiveStr::Ascii("ye"),
        dictgen::InsensitiveStr::Ascii("yes"),
    ],
    values: &[&["bitched"], &["bitches"], &["byte"], &["bytes"]],
    range: 2..=5,
};

static WORD_BR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_BR_CHILDREN),
    value: None,
};

static WORD_BR_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_BRA_NODE),
    None,
    None,
    None,
    Some(&WORD_BRE_NODE),
    Some(&WORD_BRF_NODE),
    None,
    None,
    Some(&WORD_BRI_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_BRN_NODE),
    Some(&WORD_BRO_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_BRT_NODE),
    Some(&WORD_BRU_NODE),
    None,
    Some(&WORD_BRW_NODE),
    None,
    None,
    None,
];

static WORD_BRW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BRW_CHILDREN),
    value: None,
};

pub static WORD_BRW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("osable"),
        dictgen::InsensitiveStr::Ascii("ose"),
        dictgen::InsensitiveStr::Ascii("osed"),
        dictgen::InsensitiveStr::Ascii("oser"),
        dictgen::InsensitiveStr::Ascii("osers"),
        dictgen::InsensitiveStr::Ascii("osing"),
    ],
    values: &[
        &["browsable"],
        &["browse"],
        &["browsed"],
        &["browser"],
        &["browsers"],
        &["browsing"],
    ],
    range: 3..=6,
};

static WORD_BRU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BRU_CHILDREN),
    value: None,
};

pub static WORD_BRU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("glar"),
        dictgen::InsensitiveStr::Ascii("gundy"),
        dictgen::InsensitiveStr::Ascii("isend"),
        dictgen::InsensitiveStr::Ascii("iseres"),
        dictgen::InsensitiveStr::Ascii("nete"),
        dictgen::InsensitiveStr::Ascii("nettte"),
        dictgen::InsensitiveStr::Ascii("ning"),
        dictgen::InsensitiveStr::Ascii("se"),
        dictgen::InsensitiveStr::Ascii("ses"),
        dictgen::InsensitiveStr::Ascii("sied"),
        dictgen::InsensitiveStr::Ascii("sies"),
        dictgen::InsensitiveStr::Ascii("sselers"),
        dictgen::InsensitiveStr::Ascii("sseles"),
        dictgen::InsensitiveStr::Ascii("ssells"),
        dictgen::InsensitiveStr::Ascii("sses"),
        dictgen::InsensitiveStr::Ascii("ssles"),
        dictgen::InsensitiveStr::Ascii("sting"),
        dictgen::InsensitiveStr::Ascii("tailty"),
        dictgen::InsensitiveStr::Ascii("tallity"),
        dictgen::InsensitiveStr::Ascii("tallly"),
        dictgen::InsensitiveStr::Ascii("taly"),
    ],
    values: &[
        &["burglar"],
        &["burgundy"],
        &["bruised"],
        &["bruisers"],
        &["brunette"],
        &["brunette"],
        &["burning"],
        &["bruise"],
        &["bruises"],
        &["bruised"],
        &["bruises"],
        &["brussels"],
        &["brussels"],
        &["brussels"],
        &["brussels"],
        &["brussels"],
        &["bursting"],
        &["brutality"],
        &["brutally"],
        &["brutally"],
        &["brutally"],
    ],
    range: 2..=7,
};

static WORD_BRT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BRT_CHILDREN),
    value: None,
};

pub static WORD_BRT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ually")],
    values: &[&["brutally"]],
    range: 5..=5,
};

static WORD_BRO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_BRO_CHILDREN),
    value: None,
};

static WORD_BRO_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_BROA_NODE),
    Some(&WORD_BROB_NODE),
    Some(&WORD_BROC_NODE),
    Some(&WORD_BROD_NODE),
    None,
    None,
    Some(&WORD_BROG_NODE),
    None,
    None,
    None,
    Some(&WORD_BROK_NODE),
    None,
    None,
    Some(&WORD_BRON_NODE),
    Some(&WORD_BROO_NODE),
    None,
    None,
    None,
    Some(&WORD_BROS_NODE),
    Some(&WORD_BROT_NODE),
    Some(&WORD_BROU_NODE),
    None,
    Some(&WORD_BROW_NODE),
    None,
    None,
    None,
];

static WORD_BROW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BROW_CHILDREN),
    value: None,
};

pub static WORD_BROW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("er"),
        dictgen::InsensitiveStr::Ascii("ers"),
        dictgen::InsensitiveStr::Ascii("ine"),
        dictgen::InsensitiveStr::Ascii("ines"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("isng"),
        dictgen::InsensitiveStr::Ascii("nei"),
        dictgen::InsensitiveStr::Ascii("nis"),
        dictgen::InsensitiveStr::Ascii("seable"),
        dictgen::InsensitiveStr::Ascii("swable"),
        dictgen::InsensitiveStr::Ascii("swe"),
        dictgen::InsensitiveStr::Ascii("swed"),
        dictgen::InsensitiveStr::Ascii("swer"),
        dictgen::InsensitiveStr::Ascii("swers"),
        dictgen::InsensitiveStr::Ascii("swing"),
    ],
    values: &[
        &["browser"],
        &["browsers"],
        &["brownie"],
        &["brownies"],
        &["browsing"],
        &["browsing"],
        &["brownie"],
        &["brownies"],
        &["browsable"],
        &["browsable"],
        &["browse"],
        &["browsed"],
        &["browser"],
        &["browsers"],
        &["browsing"],
    ],
    range: 2..=6,
};

static WORD_BROU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BROU_CHILDREN),
    value: None,
};

pub static WORD_BROU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ter")],
    values: &[&["router"]],
    range: 3..=3,
};

static WORD_BROT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BROT_CHILDREN),
    value: None,
};

pub static WORD_BROT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("herhod"),
        dictgen::InsensitiveStr::Ascii("herhoood"),
        dictgen::InsensitiveStr::Ascii("herood"),
        dictgen::InsensitiveStr::Ascii("herwood"),
    ],
    values: &[
        &["brotherhood"],
        &["brotherhood"],
        &["brotherhood"],
        &["brotherhood"],
    ],
    range: 6..=8,
};

static WORD_BROS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BROS_CHILDREN),
    value: None,
};

pub static WORD_BROS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("able"),
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("er"),
        dictgen::InsensitiveStr::Ascii("ers"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("wable"),
        dictgen::InsensitiveStr::Ascii("we"),
        dictgen::InsensitiveStr::Ascii("wed"),
        dictgen::InsensitiveStr::Ascii("wer"),
        dictgen::InsensitiveStr::Ascii("wers"),
        dictgen::InsensitiveStr::Ascii("wing"),
    ],
    values: &[
        &["browsable"],
        &["browse", "rose"],
        &["browsed", "rosed"],
        &["browser"],
        &["browsers"],
        &["browsing"],
        &["browsable"],
        &["browse"],
        &["browsed"],
        &["browser"],
        &["browsers"],
        &["browsing"],
    ],
    range: 1..=5,
};

static WORD_BROO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BROO_CHILDREN),
    value: None,
};

pub static WORD_BROO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("z"),
        dictgen::InsensitiveStr::Ascii("zes"),
    ],
    values: &[&["bruise"], &["bruises"]],
    range: 1..=3,
};

static WORD_BRON_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BRON_CHILDREN),
    value: None,
};

pub static WORD_BRON_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("coes"),
        dictgen::InsensitiveStr::Ascii("ken"),
        dictgen::InsensitiveStr::Ascii("ocs"),
    ],
    values: &[&["broncos"], &["broken"], &["broncos"]],
    range: 3..=4,
};

static WORD_BROK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BROK_CHILDREN),
    value: None,
};

pub static WORD_BROK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("em"),
        dictgen::InsensitiveStr::Ascii("end"),
        dictgen::InsensitiveStr::Ascii("ened"),
        dictgen::InsensitiveStr::Ascii("eness"),
    ],
    values: &[
        &["broken"],
        &["broken"],
        &["broken"],
        &["broken"],
        &["brokenness"],
    ],
    range: 2..=5,
};

static WORD_BROG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BROG_CHILDREN),
    value: None,
};

pub static WORD_BROG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("es"),
    ],
    values: &[&["brogue"], &["brogues"]],
    range: 1..=2,
};

static WORD_BROD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BROD_CHILDREN),
    value: None,
};

pub static WORD_BROD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("away"),
        dictgen::InsensitiveStr::Ascii("cast"),
        dictgen::InsensitiveStr::Ascii("erlands"),
    ],
    values: &[&["broadway"], &["broadcast"], &["borderlands"]],
    range: 4..=7,
};

static WORD_BROC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BROC_CHILDREN),
    value: None,
};

pub static WORD_BROC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("her"),
        dictgen::InsensitiveStr::Ascii("ken"),
        dictgen::InsensitiveStr::Ascii("kend"),
        dictgen::InsensitiveStr::Ascii("kened"),
        dictgen::InsensitiveStr::Ascii("olee"),
        dictgen::InsensitiveStr::Ascii("oli"),
        dictgen::InsensitiveStr::Ascii("olli"),
    ],
    values: &[
        &["brochure"],
        &["broken"],
        &["broken"],
        &["broken"],
        &["broccoli"],
        &["broccoli"],
        &["broccoli"],
    ],
    range: 3..=5,
};

static WORD_BROB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BROB_CHILDREN),
    value: None,
};

pub static WORD_BROB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("lematic")],
    values: &[&["problematic"]],
    range: 7..=7,
};

static WORD_BROA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BROA_CHILDREN),
    value: None,
};

pub static WORD_BROA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cast"),
        dictgen::InsensitiveStr::Ascii("casted"),
        dictgen::InsensitiveStr::Ascii("casting"),
        dictgen::InsensitiveStr::Ascii("casts"),
        dictgen::InsensitiveStr::Ascii("dacasting"),
        dictgen::InsensitiveStr::Ascii("dbad"),
        dictgen::InsensitiveStr::Ascii("dcas"),
        dictgen::InsensitiveStr::Ascii("dcase"),
        dictgen::InsensitiveStr::Ascii("dcasing"),
        dictgen::InsensitiveStr::Ascii("dcastes"),
        dictgen::InsensitiveStr::Ascii("dcasti"),
        dictgen::InsensitiveStr::Ascii("dcastors"),
        dictgen::InsensitiveStr::Ascii("dcat"),
        dictgen::InsensitiveStr::Ascii("dley"),
        dictgen::InsensitiveStr::Ascii("dwalk"),
        dictgen::InsensitiveStr::Ascii("dy"),
        dictgen::InsensitiveStr::Ascii("rdcast"),
    ],
    values: &[
        &["broadcast"],
        &["broadcast"],
        &["broadcasting"],
        &["broadcasts"],
        &["broadcasting"],
        &["broadband"],
        &["broadcast"],
        &["broadcast"],
        &["broadcasting"],
        &["broadcasts"],
        &["broadcast"],
        &["broadcasts"],
        &["broadcasts", "broadcast"],
        &["broadly"],
        &["boardwalk"],
        &["broadly"],
        &["broadcast"],
    ],
    range: 2..=9,
};

static WORD_BRN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BRN_CHILDREN),
    value: None,
};

pub static WORD_BRN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ach"),
        dictgen::InsensitiveStr::Ascii("aches"),
    ],
    values: &[&["branch"], &["branches"]],
    range: 3..=5,
};

static WORD_BRI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BRI_CHILDREN),
    value: None,
};

pub static WORD_BRI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("agde"),
        dictgen::InsensitiveStr::Ascii("aner"),
        dictgen::InsensitiveStr::Ascii("anwashed"),
        dictgen::InsensitiveStr::Ascii("anwashing"),
        dictgen::InsensitiveStr::Ascii("daging"),
        dictgen::InsensitiveStr::Ascii("dg"),
        dictgen::InsensitiveStr::Ascii("dman"),
        dictgen::InsensitiveStr::Ascii("elfy"),
        dictgen::InsensitiveStr::Ascii("evely"),
        dictgen::InsensitiveStr::Ascii("evety"),
        dictgen::InsensitiveStr::Ascii("gaged"),
        dictgen::InsensitiveStr::Ascii("gated"),
        dictgen::InsensitiveStr::Ascii("gde"),
        dictgen::InsensitiveStr::Ascii("gdes"),
        dictgen::InsensitiveStr::Ascii("ge"),
        dictgen::InsensitiveStr::Ascii("ges"),
        dictgen::InsensitiveStr::Ascii("ghness"),
        dictgen::InsensitiveStr::Ascii("ghtern"),
        dictgen::InsensitiveStr::Ascii("ghtn"),
        dictgen::InsensitiveStr::Ascii("ghtnesss"),
        dictgen::InsensitiveStr::Ascii("ghtoner"),
        dictgen::InsensitiveStr::Ascii("gth"),
        dictgen::InsensitiveStr::Ascii("gthen"),
        dictgen::InsensitiveStr::Ascii("gthest"),
        dictgen::InsensitiveStr::Ascii("gthnes"),
        dictgen::InsensitiveStr::Ascii("gthness"),
        dictgen::InsensitiveStr::Ascii("liant"),
        dictgen::InsensitiveStr::Ascii("linear"),
        dictgen::InsensitiveStr::Ascii("llaince"),
        dictgen::InsensitiveStr::Ascii("llaintly"),
        dictgen::InsensitiveStr::Ascii("llant"),
        dictgen::InsensitiveStr::Ascii("lliante"),
        dictgen::InsensitiveStr::Ascii("llianty"),
        dictgen::InsensitiveStr::Ascii("lliany"),
        dictgen::InsensitiveStr::Ascii("mestone"),
        dictgen::InsensitiveStr::Ascii("mingham"),
        dictgen::InsensitiveStr::Ascii("ngin"),
        dictgen::InsensitiveStr::Ascii("ngtofont"),
        dictgen::InsensitiveStr::Ascii("sben"),
        dictgen::InsensitiveStr::Ascii("stool"),
        dictgen::InsensitiveStr::Ascii("te"),
        dictgen::InsensitiveStr::Ascii("ten"),
        dictgen::InsensitiveStr::Ascii("tened"),
        dictgen::InsensitiveStr::Ascii("tener"),
        dictgen::InsensitiveStr::Ascii("teners"),
        dictgen::InsensitiveStr::Ascii("tenes"),
        dictgen::InsensitiveStr::Ascii("tening"),
        dictgen::InsensitiveStr::Ascii("ter"),
        dictgen::InsensitiveStr::Ascii("thday"),
        dictgen::InsensitiveStr::Ascii("thdays"),
        dictgen::InsensitiveStr::Ascii("tian"),
        dictgen::InsensitiveStr::Ascii("tsol"),
        dictgen::InsensitiveStr::Ascii("ttish"),
        dictgen::InsensitiveStr::Ascii("used"),
        dictgen::InsensitiveStr::Ascii("user"),
        dictgen::InsensitiveStr::Ascii("users"),
        dictgen::InsensitiveStr::Ascii("uses"),
    ],
    values: &[
        &["brigade"],
        &["brainer"],
        &["brainwashed"],
        &["brainwashing"],
        &["brigading"],
        &["bridge"],
        &["birdman"],
        &["briefly"],
        &["briefly"],
        &["brevity"],
        &["brigade"],
        &["brigade"],
        &["bridge"],
        &["bridges"],
        &["bridge"],
        &["bridges"],
        &["brightness"],
        &["brighten"],
        &["brighten"],
        &["brightness"],
        &["brighten"],
        &["bright"],
        &["brighten"],
        &["brightest"],
        &["brightness"],
        &["brightness"],
        &["brilliant"],
        &["bilinear"],
        &["brilliance"],
        &["brilliantly"],
        &["brilliant"],
        &["brilliance"],
        &["brilliantly"],
        &["brilliantly"],
        &["brimstone"],
        &["birmingham"],
        &["bringing"],
        &["bringtofront"],
        &["brisbane"],
        &["bristol"],
        &["bright"],
        &["brighten"],
        &["brightened"],
        &["brightener"],
        &["brighteners"],
        &["brightenes"],
        &["brightening"],
        &["brighter"],
        &["birthday"],
        &["birthdays"],
        &["britain"],
        &["bristol"],
        &["british"],
        &["bruised"],
        &["bruiser"],
        &["bruisers"],
        &["bruises"],
    ],
    range: 2..=9,
};

static WORD_BRF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BRF_CHILDREN),
    value: None,
};

pub static WORD_BRF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ore")],
    values: &[&["before"]],
    range: 3..=3,
};

static WORD_BRE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BRE_CHILDREN),
    value: Some(&["be", "brie"]),
};

pub static WORD_BRE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ack"),
        dictgen::InsensitiveStr::Ascii("adtfeeding"),
        dictgen::InsensitiveStr::Ascii("akdows"),
        dictgen::InsensitiveStr::Ascii("akes"),
        dictgen::InsensitiveStr::Ascii("akthorugh"),
        dictgen::InsensitiveStr::Ascii("akthough"),
        dictgen::InsensitiveStr::Ascii("akthroughts"),
        dictgen::InsensitiveStr::Ascii("akthrouh"),
        dictgen::InsensitiveStr::Ascii("akthruogh"),
        dictgen::InsensitiveStr::Ascii("akthruoghs"),
        dictgen::InsensitiveStr::Ascii("aktrhough"),
        dictgen::InsensitiveStr::Ascii("al"),
        dictgen::InsensitiveStr::Ascii("anches"),
        dictgen::InsensitiveStr::Ascii("astfeading"),
        dictgen::InsensitiveStr::Ascii("astfeedig"),
        dictgen::InsensitiveStr::Ascii("astfeeing"),
        dictgen::InsensitiveStr::Ascii("asttaking"),
        dictgen::InsensitiveStr::Ascii("athis"),
        dictgen::InsensitiveStr::Ascii("athos"),
        dictgen::InsensitiveStr::Ascii("athtakng"),
        dictgen::InsensitiveStr::Ascii("ating"),
        dictgen::InsensitiveStr::Ascii("atsfeeding"),
        dictgen::InsensitiveStr::Ascii("dnan"),
        dictgen::InsensitiveStr::Ascii("ef"),
        dictgen::InsensitiveStr::Ascii("efly"),
        dictgen::InsensitiveStr::Ascii("fore"),
        dictgen::InsensitiveStr::Ascii("if"),
        dictgen::InsensitiveStr::Ascii("ifly"),
        dictgen::InsensitiveStr::Ascii("kaout"),
        dictgen::InsensitiveStr::Ascii("kpoint"),
        dictgen::InsensitiveStr::Ascii("kpoints"),
        dictgen::InsensitiveStr::Ascii("ndamn"),
        dictgen::InsensitiveStr::Ascii("serk"),
        dictgen::InsensitiveStr::Ascii("serker"),
        dictgen::InsensitiveStr::Ascii("sh"),
        dictgen::InsensitiveStr::Ascii("shed"),
        dictgen::InsensitiveStr::Ascii("shes"),
        dictgen::InsensitiveStr::Ascii("shing"),
        dictgen::InsensitiveStr::Ascii("then"),
        dictgen::InsensitiveStr::Ascii("theren"),
        dictgen::InsensitiveStr::Ascii("weres"),
        dictgen::InsensitiveStr::Ascii("werey"),
        dictgen::InsensitiveStr::Ascii("werks"),
        dictgen::InsensitiveStr::Ascii("werys"),
        dictgen::InsensitiveStr::Ascii("wrey"),
    ],
    values: &[
        &["brake", "break"],
        &["breastfeeding"],
        &["breakdowns"],
        &["breaks"],
        &["breakthrough"],
        &["breakthrough"],
        &["breakthroughs"],
        &["breakthrough"],
        &["breakthrough"],
        &["breakthroughs"],
        &["breakthrough"],
        &["break"],
        &["branches"],
        &["breastfeeding"],
        &["breastfeeding"],
        &["breastfeeding"],
        &["breathtaking"],
        &["breaths"],
        &["breaths"],
        &["breathtaking"],
        &["beating", "breathing"],
        &["breastfeeding"],
        &["brendan"],
        &["brief", "beef"],
        &["briefly"],
        &["before"],
        &["brief"],
        &["briefly"],
        &["breakout"],
        &["breakpoint"],
        &["breakpoints"],
        &["brendan"],
        &["berserk"],
        &["berserker"],
        &["brush", "fresh"],
        &["brushed"],
        &["brushes"],
        &["brushing"],
        &["brethren"],
        &["brethren"],
        &["brewers"],
        &["brewery"],
        &["brewers"],
        &["brewers"],
        &["brewery"],
    ],
    range: 2..=11,
};

static WORD_BRA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_BRA_CHILDREN),
    value: None,
};

static WORD_BRA_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    Some(&WORD_BRAB_NODE),
    Some(&WORD_BRAC_NODE),
    Some(&WORD_BRAD_NODE),
    Some(&WORD_BRAE_NODE),
    None,
    None,
    None,
    Some(&WORD_BRAI_NODE),
    None,
    Some(&WORD_BRAK_NODE),
    None,
    None,
    Some(&WORD_BRAN_NODE),
    Some(&WORD_BRAO_NODE),
    None,
    None,
    None,
    Some(&WORD_BRAS_NODE),
    Some(&WORD_BRAT_NODE),
    None,
    Some(&WORD_BRAV_NODE),
    None,
    None,
    None,
    Some(&WORD_BRAZ_NODE),
];

static WORD_BRAZ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BRAZ_CHILDREN),
    value: None,
};

pub static WORD_BRAZ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eer"),
        dictgen::InsensitiveStr::Ascii("ilains"),
        dictgen::InsensitiveStr::Ascii("ileans"),
        dictgen::InsensitiveStr::Ascii("iliaan"),
        dictgen::InsensitiveStr::Ascii("ilianese"),
        dictgen::InsensitiveStr::Ascii("ilianess"),
        dictgen::InsensitiveStr::Ascii("ilias"),
        dictgen::InsensitiveStr::Ascii("iliians"),
        dictgen::InsensitiveStr::Ascii("ilions"),
        dictgen::InsensitiveStr::Ascii("illans"),
        dictgen::InsensitiveStr::Ascii("illian"),
    ],
    values: &[
        &["brassiere"],
        &["brazilians"],
        &["brazilians"],
        &["brazilians"],
        &["brazilians"],
        &["brazilians"],
        &["brazilians"],
        &["brazilians"],
        &["brazilians"],
        &["brazilians"],
        &["brazilian"],
    ],
    range: 3..=8,
};

static WORD_BRAV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BRAV_CHILDREN),
    value: None,
};

pub static WORD_BRAV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("erly")],
    values: &[&["bravery"]],
    range: 4..=4,
};

static WORD_BRAT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BRAT_CHILDREN),
    value: None,
};

pub static WORD_BRAT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("enders")],
    values: &[&["bartenders"]],
    range: 6..=6,
};

static WORD_BRAS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BRAS_CHILDREN),
    value: None,
};

pub static WORD_BRAS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("illian")],
    values: &[&["brazilian"]],
    range: 6..=6,
};

static WORD_BRAO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BRAO_CHILDREN),
    value: None,
};

pub static WORD_BRAO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("dband"),
        dictgen::InsensitiveStr::Ascii("dcast"),
        dictgen::InsensitiveStr::Ascii("dcasted"),
        dictgen::InsensitiveStr::Ascii("dcasting"),
        dictgen::InsensitiveStr::Ascii("dcasts"),
        dictgen::InsensitiveStr::Ascii("den"),
        dictgen::InsensitiveStr::Ascii("der"),
        dictgen::InsensitiveStr::Ascii("dly"),
        dictgen::InsensitiveStr::Ascii("dway"),
    ],
    values: &[
        &["broadband"],
        &["broadcast"],
        &["broadcasted"],
        &["broadcasting"],
        &["broadcasts"],
        &["broaden"],
        &["broader"],
        &["broadly"],
        &["broadway"],
    ],
    range: 3..=8,
};

static WORD_BRAN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BRAN_CHILDREN),
    value: None,
};

pub static WORD_BRAN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("c"),
        dictgen::InsensitiveStr::Ascii("ce"),
        dictgen::InsensitiveStr::Ascii("ced"),
        dictgen::InsensitiveStr::Ascii("ces"),
        dictgen::InsensitiveStr::Ascii("chces"),
        dictgen::InsensitiveStr::Ascii("che"),
        dictgen::InsensitiveStr::Ascii("chs"),
        dictgen::InsensitiveStr::Ascii("chsi"),
        dictgen::InsensitiveStr::Ascii("cing"),
        dictgen::InsensitiveStr::Ascii("ck"),
        dictgen::InsensitiveStr::Ascii("ckes"),
        dictgen::InsensitiveStr::Ascii("cket"),
        dictgen::InsensitiveStr::Ascii("ckets"),
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("ier"),
    ],
    values: &[
        &["branch"],
        &["branch", "brace", "branches"],
        &["branched"],
        &["branches"],
        &["branches"],
        &["branch", "branched", "branches"],
        &["branches"],
        &["branches"],
        &["branching"],
        &["branch"],
        &["branches"],
        &["bracket"],
        &["brackets"],
        &["brain"],
        &["brainer"],
    ],
    range: 1..=5,
};

static WORD_BRAK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BRAK_CHILDREN),
    value: None,
};

pub static WORD_BRAK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("edowns"),
        dictgen::InsensitiveStr::Ascii("eout"),
        dictgen::InsensitiveStr::Ascii("et"),
        dictgen::InsensitiveStr::Ascii("ethrough"),
        dictgen::InsensitiveStr::Ascii("ets"),
        dictgen::InsensitiveStr::Ascii("ley"),
        dictgen::InsensitiveStr::Ascii("point"),
        dictgen::InsensitiveStr::Ascii("points"),
    ],
    values: &[
        &["breakdowns"],
        &["breakout"],
        &["bracket", "brake"],
        &["breakthrough"],
        &["brackets", "brakes"],
        &["barkley"],
        &["breakpoint"],
        &["breakpoints"],
    ],
    range: 2..=8,
};

static WORD_BRAI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BRAI_CHILDREN),
    value: None,
};

pub static WORD_BRAI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("nwahsed"),
        dictgen::InsensitiveStr::Ascii("nwahsing"),
        dictgen::InsensitiveStr::Ascii("nwased"),
        dictgen::InsensitiveStr::Ascii("nwasing"),
        dictgen::InsensitiveStr::Ascii("sta"),
    ],
    values: &[
        &["brainwashed"],
        &["brainwashing"],
        &["brainwashed"],
        &["brainwashing"],
        &["barista"],
    ],
    range: 3..=8,
};

static WORD_BRAE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BRAE_CHILDREN),
    value: None,
};

pub static WORD_BRAE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("vry")],
    values: &[&["bravery"]],
    range: 3..=3,
};

static WORD_BRAD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BRAD_CHILDREN),
    value: None,
};

pub static WORD_BRAD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cast"),
        dictgen::InsensitiveStr::Ascii("frod"),
    ],
    values: &[&["broadcast"], &["bradford"]],
    range: 4..=4,
};

static WORD_BRAC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BRAC_CHILDREN),
    value: None,
};

pub static WORD_BRAC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eletes"),
        dictgen::InsensitiveStr::Ascii("elettes"),
        dictgen::InsensitiveStr::Ascii("eletts"),
        dictgen::InsensitiveStr::Ascii("elona"),
        dictgen::InsensitiveStr::Ascii("ese"),
        dictgen::InsensitiveStr::Ascii("h"),
        dictgen::InsensitiveStr::Ascii("hed"),
        dictgen::InsensitiveStr::Ascii("hes"),
        dictgen::InsensitiveStr::Ascii("hing"),
        dictgen::InsensitiveStr::Ascii("keds"),
        dictgen::InsensitiveStr::Ascii("kground"),
        dictgen::InsensitiveStr::Ascii("nh"),
        dictgen::InsensitiveStr::Ascii("nhed"),
        dictgen::InsensitiveStr::Ascii("nhes"),
        dictgen::InsensitiveStr::Ascii("nhing"),
    ],
    values: &[
        &["bracelets"],
        &["bracelets"],
        &["bracelets"],
        &["barcelona"],
        &["braces"],
        &["branch"],
        &["branched", "breached"],
        &["branches", "breaches"],
        &["branching", "breaching"],
        &["brackets"],
        &["background"],
        &["branch"],
        &["branched"],
        &["branches"],
        &["branching"],
    ],
    range: 1..=7,
};

static WORD_BRAB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BRAB_CHILDREN),
    value: None,
};

pub static WORD_BRAB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("arian")],
    values: &[&["barbarian"]],
    range: 5..=5,
};

static WORD_BO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_BO_CHILDREN),
    value: None,
};

static WORD_BO_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_BOA_NODE),
    Some(&WORD_BOB_NODE),
    Some(&WORD_BOC_NODE),
    Some(&WORD_BOD_NODE),
    Some(&WORD_BOE_NODE),
    Some(&WORD_BOF_NODE),
    Some(&WORD_BOG_NODE),
    None,
    Some(&WORD_BOI_NODE),
    None,
    None,
    Some(&WORD_BOL_NODE),
    Some(&WORD_BOM_NODE),
    Some(&WORD_BON_NODE),
    Some(&WORD_BOO_NODE),
    None,
    Some(&WORD_BOQ_NODE),
    Some(&WORD_BOR_NODE),
    Some(&WORD_BOS_NODE),
    Some(&WORD_BOT_NODE),
    Some(&WORD_BOU_NODE),
    None,
    Some(&WORD_BOW_NODE),
    Some(&WORD_BOX_NODE),
    Some(&WORD_BOY_NODE),
    None,
];

static WORD_BOY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BOY_CHILDREN),
    value: None,
};

pub static WORD_BOY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ant"),
        dictgen::InsensitiveStr::Ascii("cot"),
        dictgen::InsensitiveStr::Ascii("cottting"),
        dictgen::InsensitiveStr::Ascii("cutting"),
        dictgen::InsensitiveStr::Ascii("firend"),
        dictgen::InsensitiveStr::Ascii("firends"),
        dictgen::InsensitiveStr::Ascii("freind"),
        dictgen::InsensitiveStr::Ascii("freinds"),
        dictgen::InsensitiveStr::Ascii("fried"),
        dictgen::InsensitiveStr::Ascii("friens"),
        dictgen::InsensitiveStr::Ascii("frients"),
    ],
    values: &[
        &["buoyant"],
        &["boycott"],
        &["boycotting"],
        &["boycotting"],
        &["boyfriend"],
        &["boyfriends"],
        &["boyfriend"],
        &["boyfriends"],
        &["boyfriend"],
        &["boyfriends"],
        &["boyfriends"],
    ],
    range: 3..=8,
};

static WORD_BOX_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BOX_CHILDREN),
    value: None,
};

pub static WORD_BOX_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("s"),
    ],
    values: &[&["boxes", "box", "boxer"], &["box", "boxes"]],
    range: 1..=1,
};

static WORD_BOW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BOW_CHILDREN),
    value: None,
};

pub static WORD_BOW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("kay"),
        dictgen::InsensitiveStr::Ascii("kays"),
    ],
    values: &[&["bouquet"], &["bouquets"]],
    range: 3..=4,
};

static WORD_BOU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_BOU_CHILDREN),
    value: None,
};

static WORD_BOU_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    Some(&WORD_BOUC_NODE),
    Some(&WORD_BOUD_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_BOUI_NODE),
    None,
    None,
    Some(&WORD_BOUL_NODE),
    None,
    Some(&WORD_BOUN_NODE),
    None,
    None,
    Some(&WORD_BOUQ_NODE),
    Some(&WORD_BOUR_NODE),
    None,
    Some(&WORD_BOUT_NODE),
    Some(&WORD_BOUU_NODE),
    None,
    None,
    None,
    Some(&WORD_BOUY_NODE),
    None,
];

static WORD_BOUY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BOUY_CHILDREN),
    value: Some(&["buoy"]),
};

pub static WORD_BOUY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ancy"),
        dictgen::InsensitiveStr::Ascii("ant"),
    ],
    values: &[&["buoyancy"], &["buoyant"]],
    range: 3..=4,
};

static WORD_BOUU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BOUU_CHILDREN),
    value: None,
};

pub static WORD_BOUU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("nd"),
        dictgen::InsensitiveStr::Ascii("nded"),
        dictgen::InsensitiveStr::Ascii("nding"),
        dictgen::InsensitiveStr::Ascii("nds"),
    ],
    values: &[&["bound"], &["bounded"], &["bounding"], &["bounds"]],
    range: 2..=5,
};

static WORD_BOUT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BOUT_CHILDREN),
    value: None,
};

pub static WORD_BOUT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("iqe"),
        dictgen::InsensitiveStr::Ascii("nies"),
        dictgen::InsensitiveStr::Ascii("qiue"),
    ],
    values: &[&["boutique"], &["bounties"], &["boutique"]],
    range: 3..=4,
};

static WORD_BOUR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BOUR_CHILDREN),
    value: None,
};

pub static WORD_BOUR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("egois"),
        dictgen::InsensitiveStr::Ascii("geios"),
        dictgen::InsensitiveStr::Ascii("geoius"),
        dictgen::InsensitiveStr::Ascii("geousie"),
        dictgen::InsensitiveStr::Ascii("goeis"),
    ],
    values: &[
        &["bourgeois"],
        &["bourgeois"],
        &["bourgeois"],
        &["bourgeois"],
        &["bourgeois"],
    ],
    range: 5..=7,
};

static WORD_BOUQ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BOUQ_CHILDREN),
    value: None,
};

pub static WORD_BOUQ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("et")],
    values: &[&["bouquet"]],
    range: 2..=2,
};

static WORD_BOUN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_BOUN_CHILDREN),
    value: Some(&["bound"]),
};

static WORD_BOUN_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_BOUNA_NODE),
    Some(&WORD_BOUNB_NODE),
    None,
    Some(&WORD_BOUND_NODE),
    Some(&WORD_BOUNE_NODE),
    None,
    Some(&WORD_BOUNG_NODE),
    Some(&WORD_BOUNH_NODE),
    Some(&WORD_BOUNI_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_BOUNN_NODE),
    None,
    None,
    None,
    Some(&WORD_BOUNR_NODE),
    Some(&WORD_BOUNS_NODE),
    Some(&WORD_BOUNT_NODE),
    Some(&WORD_BOUNU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_BOUNU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BOUNU_CHILDREN),
    value: None,
};

pub static WORD_BOUNU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("daries"),
        dictgen::InsensitiveStr::Ascii("dary"),
        dictgen::InsensitiveStr::Ascii("s"),
    ],
    values: &[&["boundaries"], &["boundary"], &["bonus"]],
    range: 1..=6,
};

static WORD_BOUNT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BOUNT_CHILDREN),
    value: Some(&["bound"]),
};

pub static WORD_BOUNT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ries"),
        dictgen::InsensitiveStr::Ascii("ry"),
    ],
    values: &[&["boundaries"], &["boundary"]],
    range: 2..=4,
};

static WORD_BOUNS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BOUNS_CHILDREN),
    value: Some(&["bounds"]),
};

pub static WORD_BOUNS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aries"),
        dictgen::InsensitiveStr::Ascii("ary"),
        dictgen::InsensitiveStr::Ascii("d"),
        dictgen::InsensitiveStr::Ascii("es"),
    ],
    values: &[&["boundaries"], &["boundary"], &["bounds"], &["bonuses"]],
    range: 1..=5,
};

static WORD_BOUNR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BOUNR_CHILDREN),
    value: None,
};

pub static WORD_BOUNR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("adies"),
        dictgen::InsensitiveStr::Ascii("ady"),
        dictgen::InsensitiveStr::Ascii("aies"),
        dictgen::InsensitiveStr::Ascii("aries"),
        dictgen::InsensitiveStr::Ascii("ary"),
        dictgen::InsensitiveStr::Ascii("ay"),
    ],
    values: &[
        &["boundaries"],
        &["boundary"],
        &["boundaries"],
        &["boundaries"],
        &["boundary"],
        &["boundary"],
    ],
    range: 2..=5,
};

static WORD_BOUNN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BOUNN_CHILDREN),
    value: None,
};

pub static WORD_BOUNN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("d"),
        dictgen::InsensitiveStr::Ascii("daries"),
        dictgen::InsensitiveStr::Ascii("dary"),
        dictgen::InsensitiveStr::Ascii("ded"),
        dictgen::InsensitiveStr::Ascii("ding"),
        dictgen::InsensitiveStr::Ascii("ds"),
    ],
    values: &[
        &["bound"],
        &["boundaries"],
        &["boundary"],
        &["bounded"],
        &["bounding"],
        &["bounds"],
    ],
    range: 1..=6,
};

static WORD_BOUNI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BOUNI_CHILDREN),
    value: None,
};

pub static WORD_BOUNI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("dng"),
        dictgen::InsensitiveStr::Ascii("ng"),
        dictgen::InsensitiveStr::Ascii("tes"),
    ],
    values: &[&["bounding"], &["bounding"], &["bounties"]],
    range: 2..=3,
};

static WORD_BOUNH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BOUNH_CHILDREN),
    value: None,
};

pub static WORD_BOUNH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("daries"),
        dictgen::InsensitiveStr::Ascii("dary"),
    ],
    values: &[&["boundaries"], &["boundary"]],
    range: 4..=6,
};

static WORD_BOUNG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BOUNG_CHILDREN),
    value: None,
};

pub static WORD_BOUNG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aries"),
        dictgen::InsensitiveStr::Ascii("ary"),
        dictgen::InsensitiveStr::Ascii("in"),
        dictgen::InsensitiveStr::Ascii("ind"),
    ],
    values: &[&["boundaries"], &["boundary"], &["bounding"], &["bounding"]],
    range: 2..=5,
};

static WORD_BOUNE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BOUNE_CHILDREN),
    value: None,
};

pub static WORD_BOUNE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("d")],
    values: &[&["bounded"]],
    range: 1..=1,
};

static WORD_BOUND_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BOUND_CHILDREN),
    value: None,
};

pub static WORD_BOUND_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aires"),
        dictgen::InsensitiveStr::Ascii("ares"),
        dictgen::InsensitiveStr::Ascii("aryi"),
        dictgen::InsensitiveStr::Ascii("arys"),
        dictgen::InsensitiveStr::Ascii("ay"),
        dictgen::InsensitiveStr::Ascii("ays"),
        dictgen::InsensitiveStr::Ascii("eries"),
        dictgen::InsensitiveStr::Ascii("ery"),
        dictgen::InsensitiveStr::Ascii("ig"),
        dictgen::InsensitiveStr::Ascii("img"),
        dictgen::InsensitiveStr::Ascii("in"),
        dictgen::InsensitiveStr::Ascii("rary"),
        dictgen::InsensitiveStr::Ascii("ries"),
        dictgen::InsensitiveStr::Ascii("ry"),
        dictgen::InsensitiveStr::Ascii("uaries"),
    ],
    values: &[
        &["boundaries"],
        &["boundaries"],
        &["boundary"],
        &["boundaries"],
        &["boundary"],
        &["boundaries"],
        &["boundaries"],
        &["boundary"],
        &["bounding"],
        &["bounding"],
        &["bounding"],
        &["boundary"],
        &["boundaries"],
        &["boundary"],
        &["boundaries"],
    ],
    range: 2..=6,
};

static WORD_BOUNB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BOUNB_CHILDREN),
    value: None,
};

pub static WORD_BOUNB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("daries"),
        dictgen::InsensitiveStr::Ascii("dary"),
    ],
    values: &[&["boundaries"], &["boundary"]],
    range: 4..=6,
};

static WORD_BOUNA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BOUNA_CHILDREN),
    value: None,
};

pub static WORD_BOUNA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aries"),
        dictgen::InsensitiveStr::Ascii("ary"),
        dictgen::InsensitiveStr::Ascii("d"),
        dictgen::InsensitiveStr::Ascii("daries"),
        dictgen::InsensitiveStr::Ascii("dary"),
        dictgen::InsensitiveStr::Ascii("ded"),
        dictgen::InsensitiveStr::Ascii("ding"),
        dictgen::InsensitiveStr::Ascii("dries"),
        dictgen::InsensitiveStr::Ascii("dry"),
        dictgen::InsensitiveStr::Ascii("ds"),
        dictgen::InsensitiveStr::Ascii("rdies"),
        dictgen::InsensitiveStr::Ascii("rdy"),
        dictgen::InsensitiveStr::Ascii("ries"),
        dictgen::InsensitiveStr::Ascii("ry"),
    ],
    values: &[
        &["boundaries"],
        &["boundary"],
        &["bound"],
        &["boundaries"],
        &["boundary"],
        &["bounded"],
        &["bounding"],
        &["boundaries"],
        &["boundary"],
        &["bounds"],
        &["boundaries"],
        &["boundary"],
        &["boundaries"],
        &["boundary"],
    ],
    range: 1..=6,
};

static WORD_BOUL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BOUL_CHILDREN),
    value: None,
};

pub static WORD_BOUL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("dore")],
    values: &[&["boulder"]],
    range: 4..=4,
};

static WORD_BOUI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BOUI_CHILDREN),
    value: None,
};

pub static WORD_BOUI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("nd"),
        dictgen::InsensitiveStr::Ascii("nded"),
        dictgen::InsensitiveStr::Ascii("nding"),
        dictgen::InsensitiveStr::Ascii("nds"),
    ],
    values: &[&["bound"], &["bounded"], &["bounding"], &["bounds"]],
    range: 2..=5,
};

static WORD_BOUD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BOUD_CHILDREN),
    value: None,
};

pub static WORD_BOUD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aries"),
        dictgen::InsensitiveStr::Ascii("ary"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("ler"),
        dictgen::InsensitiveStr::Ascii("naries"),
        dictgen::InsensitiveStr::Ascii("nary"),
        dictgen::InsensitiveStr::Ascii("s"),
    ],
    values: &[
        &["boundaries"],
        &["boundary"],
        &["bounding"],
        &["boulder"],
        &["boundaries"],
        &["boundary"],
        &["bounds"],
    ],
    range: 1..=6,
};

static WORD_BOUC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BOUC_CHILDREN),
    value: None,
};

pub static WORD_BOUC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("ing"),
    ],
    values: &[&["bounce"], &["bounced"], &["bounces"], &["bouncing"]],
    range: 1..=3,
};

static WORD_BOT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BOT_CHILDREN),
    value: None,
};

pub static WORD_BOT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("he"),
        dictgen::InsensitiveStr::Ascii("hs"),
        dictgen::InsensitiveStr::Ascii("ifies"),
        dictgen::InsensitiveStr::Ascii("ivational"),
        dictgen::InsensitiveStr::Ascii("om"),
        dictgen::InsensitiveStr::Ascii("telneck"),
        dictgen::InsensitiveStr::Ascii("tem"),
        dictgen::InsensitiveStr::Ascii("tlebeck"),
        dictgen::InsensitiveStr::Ascii("tlenck"),
        dictgen::InsensitiveStr::Ascii("tlencks"),
        dictgen::InsensitiveStr::Ascii("tlenect"),
        dictgen::InsensitiveStr::Ascii("tlenects"),
        dictgen::InsensitiveStr::Ascii("tlneck"),
        dictgen::InsensitiveStr::Ascii("tlnecks"),
        dictgen::InsensitiveStr::Ascii("tm"),
        dictgen::InsensitiveStr::Ascii("tomborde"),
        dictgen::InsensitiveStr::Ascii("tome"),
        dictgen::InsensitiveStr::Ascii("tomn"),
        dictgen::InsensitiveStr::Ascii("ton"),
        dictgen::InsensitiveStr::Ascii("tonm"),
        dictgen::InsensitiveStr::Ascii("tons"),
        dictgen::InsensitiveStr::Ascii("ttom"),
    ],
    values: &[
        &["both"],
        &["both"],
        &["notifies"],
        &["motivational"],
        &["bottom"],
        &["bottleneck"],
        &["bottom"],
        &["bottleneck"],
        &["bottleneck"],
        &["bottlenecks"],
        &["bottleneck"],
        &["bottlenecks"],
        &["bottleneck"],
        &["bottlenecks"],
        &["bottom"],
        &["bottomborder"],
        &["bottom"],
        &["bottom"],
        &["bottom", "button"],
        &["bottom"],
        &["bottoms", "buttons"],
        &["bottom"],
    ],
    range: 2..=9,
};

static WORD_BOS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BOS_CHILDREN),
    value: None,
};

pub static WORD_BOS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("lter"),
        dictgen::InsensitiveStr::Ascii("tom"),
    ],
    values: &[&["bolster"], &["boston", "bottom"]],
    range: 3..=4,
};

static WORD_BOR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BOR_CHILDREN),
    value: None,
};

pub static WORD_BOR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aches"),
        dictgen::InsensitiveStr::Ascii("ad"),
        dictgen::InsensitiveStr::Ascii("adband"),
        dictgen::InsensitiveStr::Ascii("adcast"),
        dictgen::InsensitiveStr::Ascii("adcasting"),
        dictgen::InsensitiveStr::Ascii("adcasts"),
        dictgen::InsensitiveStr::Ascii("aden"),
        dictgen::InsensitiveStr::Ascii("ader"),
        dictgen::InsensitiveStr::Ascii("adly"),
        dictgen::InsensitiveStr::Ascii("adwalk"),
        dictgen::InsensitiveStr::Ascii("adway"),
        dictgen::InsensitiveStr::Ascii("ded"),
        dictgen::InsensitiveStr::Ascii("delrands"),
        dictgen::InsensitiveStr::Ascii("deom"),
        dictgen::InsensitiveStr::Ascii("derlads"),
        dictgen::InsensitiveStr::Ascii("derlanders"),
        dictgen::InsensitiveStr::Ascii("derlans"),
        dictgen::InsensitiveStr::Ascii("ding"),
        dictgen::InsensitiveStr::Ascii("dlerands"),
        dictgen::InsensitiveStr::Ascii("dreline"),
        dictgen::InsensitiveStr::Ascii("drelines"),
        dictgen::InsensitiveStr::Ascii("edoom"),
        dictgen::InsensitiveStr::Ascii("gwasy"),
        dictgen::InsensitiveStr::Ascii("ke"),
        dictgen::InsensitiveStr::Ascii("ken"),
        dictgen::InsensitiveStr::Ascii("ow"),
        dictgen::InsensitiveStr::Ascii("therhood"),
        dictgen::InsensitiveStr::Ascii("wser"),
        dictgen::InsensitiveStr::Ascii("wsers"),
    ],
    values: &[
        &["branches"],
        &["board"],
        &["broadband"],
        &["broadcast"],
        &["broadcasting"],
        &["broadcasts"],
        &["broaden"],
        &["broader"],
        &["broadly"],
        &["boardwalk"],
        &["broadway"],
        &["boarded", "border"],
        &["borderlands"],
        &["boredom"],
        &["borderlands"],
        &["borderlands"],
        &["borderlands"],
        &["boarding"],
        &["borderlands"],
        &["borderline"],
        &["borderlines"],
        &["boredom"],
        &["bourgeoisie"],
        &["broke"],
        &["broken"],
        &["borrow"],
        &["brotherhood"],
        &["browsers"],
        &["browsers"],
    ],
    range: 2..=10,
};

static WORD_BOQ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BOQ_CHILDREN),
    value: None,
};

pub static WORD_BOQ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("uet")],
    values: &[&["bouquet"]],
    range: 3..=3,
};

static WORD_BOO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BOO_CHILDREN),
    value: None,
};

pub static WORD_BOO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("d"),
        dictgen::InsensitiveStr::Ascii("da"),
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("ee"),
        dictgen::InsensitiveStr::Ascii("ees"),
        dictgen::InsensitiveStr::Ascii("elan"),
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("fay"),
        dictgen::InsensitiveStr::Ascii("fays"),
        dictgen::InsensitiveStr::Ascii("kamrks"),
        dictgen::InsensitiveStr::Ascii("keeping"),
        dictgen::InsensitiveStr::Ascii("kkeeing"),
        dictgen::InsensitiveStr::Ascii("kkeeiping"),
        dictgen::InsensitiveStr::Ascii("kkepp"),
        dictgen::InsensitiveStr::Ascii("kmakr"),
        dictgen::InsensitiveStr::Ascii("kmakred"),
        dictgen::InsensitiveStr::Ascii("kmakrs"),
        dictgen::InsensitiveStr::Ascii("kmar"),
        dictgen::InsensitiveStr::Ascii("kmarkd"),
        dictgen::InsensitiveStr::Ascii("kmars"),
        dictgen::InsensitiveStr::Ascii("lan"),
        dictgen::InsensitiveStr::Ascii("ld"),
        dictgen::InsensitiveStr::Ascii("leam"),
        dictgen::InsensitiveStr::Ascii("leamn"),
        dictgen::InsensitiveStr::Ascii("leamns"),
        dictgen::InsensitiveStr::Ascii("leams"),
        dictgen::InsensitiveStr::Ascii("leanss"),
        dictgen::InsensitiveStr::Ascii("leen"),
        dictgen::InsensitiveStr::Ascii("leens"),
        dictgen::InsensitiveStr::Ascii("len"),
        dictgen::InsensitiveStr::Ascii("lens"),
        dictgen::InsensitiveStr::Ascii("ltloader"),
        dictgen::InsensitiveStr::Ascii("ltloaders"),
        dictgen::InsensitiveStr::Ascii("mark"),
        dictgen::InsensitiveStr::Ascii("marks"),
        dictgen::InsensitiveStr::Ascii("ok"),
        dictgen::InsensitiveStr::Ascii("olean"),
        dictgen::InsensitiveStr::Ascii("oleans"),
        dictgen::InsensitiveStr::Ascii("rjwazee"),
        dictgen::InsensitiveStr::Ascii("shelf"),
        dictgen::InsensitiveStr::Ascii("shelves"),
        dictgen::InsensitiveStr::Ascii("strap"),
        dictgen::InsensitiveStr::Ascii("strapped"),
        dictgen::InsensitiveStr::Ascii("strapping"),
        dictgen::InsensitiveStr::Ascii("straps"),
        dictgen::InsensitiveStr::Ascii("teek"),
        dictgen::InsensitiveStr::Ascii("tlaoder"),
        dictgen::InsensitiveStr::Ascii("tlaoders"),
        dictgen::InsensitiveStr::Ascii("tleader"),
        dictgen::InsensitiveStr::Ascii("toloader"),
        dictgen::InsensitiveStr::Ascii("tom"),
        dictgen::InsensitiveStr::Ascii("traping"),
        dictgen::InsensitiveStr::Ascii("tsram"),
        dictgen::InsensitiveStr::Ascii("tsrap"),
        dictgen::InsensitiveStr::Ascii("tstap"),
        dictgen::InsensitiveStr::Ascii("tstapped"),
        dictgen::InsensitiveStr::Ascii("tstapping"),
        dictgen::InsensitiveStr::Ascii("tstaps"),
        dictgen::InsensitiveStr::Ascii("tstraping"),
        dictgen::InsensitiveStr::Ascii("und"),
        dictgen::InsensitiveStr::Ascii("undaries"),
        dictgen::InsensitiveStr::Ascii("undary"),
        dictgen::InsensitiveStr::Ascii("unds"),
    ],
    values: &[
        &["boot"],
        &["buddha"],
        &["buoy"],
        &["buoy"],
        &["buoys"],
        &["boolean"],
        &["boos", "booze", "buoys"],
        &["buffet"],
        &["buffets"],
        &["bookmarks"],
        &["bookkeeping"],
        &["bookkeeping"],
        &["bookkeeping"],
        &["bookkeep"],
        &["bookmark"],
        &["bookmarked"],
        &["bookmarks"],
        &["bookmark"],
        &["bookmarked"],
        &["bookmarks"],
        &["boolean"],
        &["bold", "bool"],
        &["boolean"],
        &["boolean"],
        &["booleans"],
        &["booleans"],
        &["booleans"],
        &["boolean"],
        &["booleans"],
        &["boolean"],
        &["booleans"],
        &["bootloader"],
        &["bootloaders"],
        &["bookmark"],
        &["bookmarks"],
        &["book"],
        &["boolean"],
        &["booleans"],
        &["bourgeoisie"],
        &["bookshelf"],
        &["bookshelves"],
        &["bootstrap"],
        &["bootstrapped"],
        &["bootstrapping"],
        &["bootstraps"],
        &["boutique"],
        &["bootloader"],
        &["bootloaders"],
        &["bootloader"],
        &["bootloader"],
        &["bottom"],
        &["bootstrapping"],
        &["bootram"],
        &["bootstrap"],
        &["bootstrap"],
        &["bootstrapped"],
        &["bootstrapping"],
        &["bootstraps"],
        &["bootstrapping"],
        &["bound"],
        &["boundaries"],
        &["boundary"],
        &["bounds"],
    ],
    range: 1..=9,
};

static WORD_BON_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BON_CHILDREN),
    value: None,
};

pub static WORD_BON_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("dary"),
        dictgen::InsensitiveStr::Ascii("nano"),
        dictgen::InsensitiveStr::Ascii("sues"),
    ],
    values: &[&["boundary"], &["bonanno"], &["bonuses"]],
    range: 4..=4,
};

static WORD_BOM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BOM_CHILDREN),
    value: None,
};

pub static WORD_BOM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("bardeada"),
        dictgen::InsensitiveStr::Ascii("bardeado"),
        dictgen::InsensitiveStr::Ascii("bardement"),
        dictgen::InsensitiveStr::Ascii("barderad"),
        dictgen::InsensitiveStr::Ascii("barment"),
        dictgen::InsensitiveStr::Ascii("beros"),
    ],
    values: &[
        &["bombarded"],
        &["bombarded"],
        &["bombardment"],
        &["bombarded"],
        &["bombardment"],
        &["bombers"],
    ],
    range: 5..=9,
};

static WORD_BOL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BOL_CHILDREN),
    value: None,
};

pub static WORD_BOL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ean"),
        dictgen::InsensitiveStr::Ascii("een"),
        dictgen::InsensitiveStr::Ascii("lcoks"),
        dictgen::InsensitiveStr::Ascii("locs"),
        dictgen::InsensitiveStr::Ascii("or"),
    ],
    values: &[
        &["boolean"],
        &["boolean"],
        &["bollocks"],
        &["bollocks"],
        &["color"],
    ],
    range: 2..=5,
};

static WORD_BOI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BOI_CHILDREN),
    value: None,
};

pub static WORD_BOI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("lerplatte"),
        dictgen::InsensitiveStr::Ascii("nter"),
    ],
    values: &[&["boilerplate"], &["pointer"]],
    range: 4..=9,
};

static WORD_BOG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BOG_CHILDREN),
    value: None,
};

pub static WORD_BOG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("anveelia"),
        dictgen::InsensitiveStr::Ascii("anveelias"),
        dictgen::InsensitiveStr::Ascii("gus"),
        dictgen::InsensitiveStr::Ascii("os"),
        dictgen::InsensitiveStr::Ascii("ous"),
    ],
    values: &[
        &["bougainvillea"],
        &["bougainvilleas"],
        &["bogus"],
        &["bogus"],
        &["bogus"],
    ],
    range: 2..=9,
};

static WORD_BOF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BOF_CHILDREN),
    value: None,
};

pub static WORD_BOF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("fer"),
        dictgen::InsensitiveStr::Ascii("ore"),
        dictgen::InsensitiveStr::Ascii("y"),
    ],
    values: &[&["buffer"], &["before"], &["body"]],
    range: 1..=3,
};

static WORD_BOE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BOE_CHILDREN),
    value: None,
};

pub static WORD_BOE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("lean"),
        dictgen::InsensitiveStr::Ascii("leans"),
    ],
    values: &[&["boolean"], &["booleans"]],
    range: 4..=5,
};

static WORD_BOD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BOD_CHILDREN),
    value: None,
};

pub static WORD_BOD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("dy"),
        dictgen::InsensitiveStr::Ascii("iese"),
        dictgen::InsensitiveStr::Ascii("ybuidling"),
        dictgen::InsensitiveStr::Ascii("ybuildig"),
        dictgen::InsensitiveStr::Ascii("ybuildng"),
        dictgen::InsensitiveStr::Ascii("ybuilidng"),
        dictgen::InsensitiveStr::Ascii("ybuiling"),
        dictgen::InsensitiveStr::Ascii("ybuliding"),
        dictgen::InsensitiveStr::Ascii("ydbuilder"),
        dictgen::InsensitiveStr::Ascii("yheight"),
        dictgen::InsensitiveStr::Ascii("yweigt"),
        dictgen::InsensitiveStr::Ascii("yweigth"),
        dictgen::InsensitiveStr::Ascii("ywieght"),
    ],
    values: &[
        &["body"],
        &["bodies"],
        &["bodybuilding"],
        &["bodybuilding"],
        &["bodybuilding"],
        &["bodybuilding"],
        &["bodybuilding"],
        &["bodybuilding"],
        &["bodybuilder"],
        &["bodyweight"],
        &["bodyweight"],
        &["bodyweight"],
        &["bodyweight"],
    ],
    range: 2..=9,
};

static WORD_BOC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BOC_CHILDREN),
    value: None,
};

pub static WORD_BOC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ome")],
    values: &[&["become"]],
    range: 3..=3,
};

static WORD_BOB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BOB_CHILDREN),
    value: None,
};

pub static WORD_BOB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ard"),
        dictgen::InsensitiveStr::Ascii("mers"),
        dictgen::InsensitiveStr::Ascii("ybuilding"),
    ],
    values: &[&["board", "bombard"], &["bombers"], &["bodybuilding"]],
    range: 3..=9,
};

static WORD_BOA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BOA_CHILDREN),
    value: None,
};

pub static WORD_BOA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ds"),
        dictgen::InsensitiveStr::Ascii("rdband"),
        dictgen::InsensitiveStr::Ascii("rdcast"),
        dictgen::InsensitiveStr::Ascii("rdcasting"),
        dictgen::InsensitiveStr::Ascii("rdcasts"),
        dictgen::InsensitiveStr::Ascii("rdway"),
        dictgen::InsensitiveStr::Ascii("ut"),
    ],
    values: &[
        &["boards"],
        &["broadband"],
        &["broadcast"],
        &["broadcasting"],
        &["broadcasts"],
        &["broadway"],
        &["bout", "boat", "about"],
    ],
    range: 2..=9,
};

static WORD_BN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BN_CHILDREN),
    value: None,
};

pub static WORD_BN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ecause"),
        dictgen::InsensitiveStr::Ascii("ndler"),
    ],
    values: &[&["because"], &["bundler"]],
    range: 5..=6,
};

static WORD_BL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_BL_CHILDREN),
    value: None,
};

static WORD_BL_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_BLA_NODE),
    Some(&WORD_BLB_NODE),
    Some(&WORD_BLC_NODE),
    None,
    Some(&WORD_BLE_NODE),
    None,
    None,
    None,
    Some(&WORD_BLI_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_BLO_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_BLU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_BLU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BLU_CHILDREN),
    value: None,
};

pub static WORD_BLU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ebarries"),
        dictgen::InsensitiveStr::Ascii("eberies"),
        dictgen::InsensitiveStr::Ascii("eberris"),
        dictgen::InsensitiveStr::Ascii("eberrries"),
        dictgen::InsensitiveStr::Ascii("eberrry"),
        dictgen::InsensitiveStr::Ascii("ebery"),
        dictgen::InsensitiveStr::Ascii("ebrints"),
        dictgen::InsensitiveStr::Ascii("eburries"),
        dictgen::InsensitiveStr::Ascii("eprients"),
        dictgen::InsensitiveStr::Ascii("eprintcss"),
        dictgen::InsensitiveStr::Ascii("estooth"),
        dictgen::InsensitiveStr::Ascii("etooh"),
        dictgen::InsensitiveStr::Ascii("etoot"),
        dictgen::InsensitiveStr::Ascii("etootn"),
        dictgen::InsensitiveStr::Ascii("garia"),
        dictgen::InsensitiveStr::Ascii("lets"),
        dictgen::InsensitiveStr::Ascii("red"),
        dictgen::InsensitiveStr::Ascii("rr"),
        dictgen::InsensitiveStr::Ascii("tooth"),
    ],
    values: &[
        &["blueberries"],
        &["blueberries"],
        &["blueberries"],
        &["blueberries"],
        &["blueberry"],
        &["blueberry"],
        &["blueprints"],
        &["blueberries"],
        &["blueprints"],
        &["blueprints"],
        &["bluetooth"],
        &["bluetooth"],
        &["bluetooth"],
        &["bluetooth"],
        &["bulgaria"],
        &["bullets"],
        &["blurred"],
        &["blur", "blurred"],
        &["bluetooth"],
    ],
    range: 2..=9,
};

static WORD_BLO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BLO_CHILDREN),
    value: None,
};

pub static WORD_BLO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ad"),
        dictgen::InsensitiveStr::Ascii("aded"),
        dictgen::InsensitiveStr::Ascii("cack"),
        dictgen::InsensitiveStr::Ascii("ccks"),
        dictgen::InsensitiveStr::Ascii("cekd"),
        dictgen::InsensitiveStr::Ascii("chchain"),
        dictgen::InsensitiveStr::Ascii("ckcahin"),
        dictgen::InsensitiveStr::Ascii("ckchan"),
        dictgen::InsensitiveStr::Ascii("ckchian"),
        dictgen::InsensitiveStr::Ascii("ckeras"),
        dictgen::InsensitiveStr::Ascii("ckes"),
        dictgen::InsensitiveStr::Ascii("ckhain"),
        dictgen::InsensitiveStr::Ascii("ckhains"),
        dictgen::InsensitiveStr::Ascii("ckin"),
        dictgen::InsensitiveStr::Ascii("ckse"),
        dictgen::InsensitiveStr::Ascii("ddy"),
        dictgen::InsensitiveStr::Ascii("dk"),
        dictgen::InsensitiveStr::Ascii("ek"),
        dictgen::InsensitiveStr::Ascii("ekes"),
        dictgen::InsensitiveStr::Ascii("eks"),
        dictgen::InsensitiveStr::Ascii("ekss"),
        dictgen::InsensitiveStr::Ascii("ggare"),
        dictgen::InsensitiveStr::Ascii("ggeur"),
        dictgen::InsensitiveStr::Ascii("hted"),
        dictgen::InsensitiveStr::Ascii("k"),
        dictgen::InsensitiveStr::Ascii("kc"),
        dictgen::InsensitiveStr::Ascii("kcer"),
        dictgen::InsensitiveStr::Ascii("kchain"),
        dictgen::InsensitiveStr::Ascii("kchains"),
        dictgen::InsensitiveStr::Ascii("kcing"),
        dictgen::InsensitiveStr::Ascii("kcs"),
        dictgen::InsensitiveStr::Ascii("kcss"),
        dictgen::InsensitiveStr::Ascii("ked"),
        dictgen::InsensitiveStr::Ascii("ker"),
        dictgen::InsensitiveStr::Ascii("king"),
        dictgen::InsensitiveStr::Ascii("ks"),
        dictgen::InsensitiveStr::Ascii("ng"),
        dictgen::InsensitiveStr::Ascii("nged"),
        dictgen::InsensitiveStr::Ascii("nging"),
        dictgen::InsensitiveStr::Ascii("ngs"),
        dictgen::InsensitiveStr::Ascii("ock"),
        dictgen::InsensitiveStr::Ascii("ocks"),
        dictgen::InsensitiveStr::Ascii("odboner"),
        dictgen::InsensitiveStr::Ascii("odbonre"),
        dictgen::InsensitiveStr::Ascii("odboorne"),
        dictgen::InsensitiveStr::Ascii("odborbe"),
        dictgen::InsensitiveStr::Ascii("odbore"),
        dictgen::InsensitiveStr::Ascii("odbrone"),
        dictgen::InsensitiveStr::Ascii("odporne"),
        dictgen::InsensitiveStr::Ascii("orborne"),
        dictgen::InsensitiveStr::Ascii("ster"),
        dictgen::InsensitiveStr::Ascii("sum"),
        dictgen::InsensitiveStr::Ascii("sums"),
        dictgen::InsensitiveStr::Ascii("ted"),
    ],
    values: &[
        &["bloat"],
        &["bloated"],
        &["blockack"],
        &["blocks"],
        &["blocked"],
        &["blockchain"],
        &["blockchain"],
        &["blockchain"],
        &["blockchain"],
        &["blockers"],
        &["blockers", "blocked", "blocks"],
        &["blockchain"],
        &["blockchains"],
        &["blocking"],
        &["blocks"],
        &["bloody"],
        &["block"],
        &["bloke"],
        &["blokes"],
        &["blokes"],
        &["blokes"],
        &["blogger"],
        &["blogger"],
        &["bloated"],
        &["block", "bloke"],
        &["block", "bloke"],
        &["blocker"],
        &["blockchain"],
        &["blockchains"],
        &["blocking"],
        &["blocks", "blokes"],
        &["blocks", "blokes"],
        &["blocked"],
        &["blocker"],
        &["blocking"],
        &["blocks", "blokes"],
        &["belong"],
        &["belonged"],
        &["belonging"],
        &["belongs"],
        &["block"],
        &["blocks"],
        &["bloodborne"],
        &["bloodborne"],
        &["bloodborne"],
        &["bloodborne"],
        &["bloodborne"],
        &["bloodborne"],
        &["bloodborne"],
        &["bloodborne"],
        &["bolster"],
        &["blossom"],
        &["blossoms"],
        &["bloated"],
    ],
    range: 1..=8,
};

static WORD_BLI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BLI_CHILDREN),
    value: None,
};

pub static WORD_BLI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ndy"),
        dictgen::InsensitiveStr::Ascii("steres"),
        dictgen::InsensitiveStr::Ascii("tzkreig"),
        dictgen::InsensitiveStr::Ascii("zzad"),
        dictgen::InsensitiveStr::Ascii("zzcoin"),
    ],
    values: &[
        &["blindly"],
        &["blisters"],
        &["blitzkrieg"],
        &["blizzard"],
        &["blizzcon"],
    ],
    range: 3..=7,
};

static WORD_BLE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BLE_CHILDREN),
    value: None,
};

pub static WORD_BLE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ading"),
        dictgen::InsensitiveStr::Ascii("gian"),
        dictgen::InsensitiveStr::Ascii("gium"),
        dictgen::InsensitiveStr::Ascii("ssd"),
        dictgen::InsensitiveStr::Ascii("ssins"),
        dictgen::InsensitiveStr::Ascii("ssure"),
        dictgen::InsensitiveStr::Ascii("tooth"),
        dictgen::InsensitiveStr::Ascii("uberry"),
        dictgen::InsensitiveStr::Ascii("utooth"),
    ],
    values: &[
        &["bleeding"],
        &["belgian"],
        &["belgium"],
        &["blessed"],
        &["blessings"],
        &["blessing"],
        &["bluetooth"],
        &["blueberry"],
        &["bluetooth"],
    ],
    range: 3..=6,
};

static WORD_BLC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BLC_CHILDREN),
    value: None,
};

pub static WORD_BLC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ok"),
        dictgen::InsensitiveStr::Ascii("oks"),
    ],
    values: &[&["block"], &["blocks"]],
    range: 2..=3,
};

static WORD_BLB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BLB_CHILDREN),
    value: None,
};

pub static WORD_BLB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("os")],
    values: &[&["blobs"]],
    range: 2..=2,
};

static WORD_BLA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BLA_CHILDREN),
    value: None,
};

pub static WORD_BLA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ckade"),
        dictgen::InsensitiveStr::Ascii("ckahwks"),
        dictgen::InsensitiveStr::Ascii("ckbarry"),
        dictgen::InsensitiveStr::Ascii("ckbeary"),
        dictgen::InsensitiveStr::Ascii("ckbeery"),
        dictgen::InsensitiveStr::Ascii("ckberrry"),
        dictgen::InsensitiveStr::Ascii("ckbery"),
        dictgen::InsensitiveStr::Ascii("ckcawks"),
        dictgen::InsensitiveStr::Ascii("ckend"),
        dictgen::InsensitiveStr::Ascii("ckhakws"),
        dictgen::InsensitiveStr::Ascii("ckhaws"),
        dictgen::InsensitiveStr::Ascii("ckhwaks"),
        dictgen::InsensitiveStr::Ascii("ckjak"),
        dictgen::InsensitiveStr::Ascii("cklit"),
        dictgen::InsensitiveStr::Ascii("ckmsith"),
        dictgen::InsensitiveStr::Ascii("ckshit"),
        dictgen::InsensitiveStr::Ascii("ckshits"),
        dictgen::InsensitiveStr::Ascii("ckslashes"),
        dictgen::InsensitiveStr::Ascii("cksmitch"),
        dictgen::InsensitiveStr::Ascii("clist"),
        dictgen::InsensitiveStr::Ascii("cony"),
        dictgen::InsensitiveStr::Ascii("im"),
        dictgen::InsensitiveStr::Ascii("imed"),
        dictgen::InsensitiveStr::Ascii("k"),
        dictgen::InsensitiveStr::Ascii("methrower"),
        dictgen::InsensitiveStr::Ascii("nace"),
        dictgen::InsensitiveStr::Ascii("nce"),
        dictgen::InsensitiveStr::Ascii("nced"),
        dictgen::InsensitiveStr::Ascii("nces"),
        dictgen::InsensitiveStr::Ascii("ncing"),
        dictgen::InsensitiveStr::Ascii("nck"),
        dictgen::InsensitiveStr::Ascii("ncked"),
        dictgen::InsensitiveStr::Ascii("nkes"),
        dictgen::InsensitiveStr::Ascii("nketts"),
        dictgen::InsensitiveStr::Ascii("pshemy"),
        dictgen::InsensitiveStr::Ascii("shpemy"),
        dictgen::InsensitiveStr::Ascii("spehmy"),
        dictgen::InsensitiveStr::Ascii("sphemey"),
        dictgen::InsensitiveStr::Ascii("sphmey"),
        dictgen::InsensitiveStr::Ascii("tanlty"),
        dictgen::InsensitiveStr::Ascii("tanty"),
        dictgen::InsensitiveStr::Ascii("tent"),
        dictgen::InsensitiveStr::Ascii("tently"),
        dictgen::InsensitiveStr::Ascii("timore"),
    ],
    values: &[
        &["blacked"],
        &["blackhawks"],
        &["blackberry"],
        &["blackberry"],
        &["blackberry"],
        &["blackberry"],
        &["blackberry"],
        &["blackhawks"],
        &["blacked"],
        &["blackhawks"],
        &["blackhawks"],
        &["blackhawks"],
        &["blackjack"],
        &["blacklist"],
        &["blacksmith"],
        &["blacksmith"],
        &["blacksmith"],
        &["backslashes"],
        &["blacksmith"],
        &["blacklist"],
        &["balcony"],
        &["blame"],
        &["blamed"],
        &["black", "blank"],
        &["flamethrower"],
        &["balance"],
        &["balance", "glance", "lance"],
        &["balanced", "glanced", "lanced"],
        &["balances", "glances", "lances"],
        &["balancing", "glancing", "lancing"],
        &["blank", "black"],
        &["blanked"],
        &["blankets"],
        &["blankets"],
        &["blasphemy"],
        &["blasphemy"],
        &["blasphemy"],
        &["blasphemy"],
        &["blasphemy"],
        &["blatantly"],
        &["blatantly"],
        &["blatant"],
        &["blatantly"],
        &["baltimore"],
    ],
    range: 1..=9,
};

static WORD_BJ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BJ_CHILDREN),
    value: None,
};

pub static WORD_BJ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ect"),
        dictgen::InsensitiveStr::Ascii("ects"),
    ],
    values: &[&["object"], &["objects"]],
    range: 3..=4,
};

static WORD_BI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_BI_CHILDREN),
    value: None,
};

static WORD_BI_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_BIA_NODE),
    Some(&WORD_BIB_NODE),
    Some(&WORD_BIC_NODE),
    Some(&WORD_BID_NODE),
    Some(&WORD_BIE_NODE),
    Some(&WORD_BIF_NODE),
    Some(&WORD_BIG_NODE),
    None,
    Some(&WORD_BII_NODE),
    None,
    None,
    Some(&WORD_BIL_NODE),
    Some(&WORD_BIM_NODE),
    Some(&WORD_BIN_NODE),
    Some(&WORD_BIO_NODE),
    Some(&WORD_BIP_NODE),
    None,
    Some(&WORD_BIR_NODE),
    Some(&WORD_BIS_NODE),
    Some(&WORD_BIT_NODE),
    Some(&WORD_BIU_NODE),
    Some(&WORD_BIV_NODE),
    None,
    None,
    Some(&WORD_BIY_NODE),
    Some(&WORD_BIZ_NODE),
];

static WORD_BIZ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BIZ_CHILDREN),
    value: None,
};

pub static WORD_BIZ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("are"),
        dictgen::InsensitiveStr::Ascii("arely"),
        dictgen::InsensitiveStr::Ascii("ness"),
        dictgen::InsensitiveStr::Ascii("nesses"),
        dictgen::InsensitiveStr::Ascii("zare"),
    ],
    values: &[
        &["bizarre"],
        &["bizarrely"],
        &["business"],
        &["businesses"],
        &["bizarre"],
    ],
    range: 3..=6,
};

static WORD_BIY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BIY_CHILDREN),
    value: None,
};

pub static WORD_BIY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ou"),
        dictgen::InsensitiveStr::Ascii("ous"),
    ],
    values: &[&["bayou"], &["bayous"]],
    range: 2..=3,
};

static WORD_BIV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BIV_CHILDREN),
    value: None,
};

pub static WORD_BIV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ouaced"),
        dictgen::InsensitiveStr::Ascii("ouacing"),
        dictgen::InsensitiveStr::Ascii("wack"),
    ],
    values: &[&["bivouacked"], &["bivouacking"], &["bivouac"]],
    range: 4..=7,
};

static WORD_BIU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BIU_CHILDREN),
    value: None,
};

pub static WORD_BIU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("lt")],
    values: &[&["built", "build"]],
    range: 2..=2,
};

static WORD_BIT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BIT_CHILDREN),
    value: None,
};

pub static WORD_BIT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("amps"),
        dictgen::InsensitiveStr::Ascii("ap"),
        dictgen::InsensitiveStr::Ascii("cion"),
        dictgen::InsensitiveStr::Ascii("cions"),
        dictgen::InsensitiveStr::Ascii("coints"),
        dictgen::InsensitiveStr::Ascii("con"),
        dictgen::InsensitiveStr::Ascii("fied"),
        dictgen::InsensitiveStr::Ascii("fileld"),
        dictgen::InsensitiveStr::Ascii("filelds"),
        dictgen::InsensitiveStr::Ascii("hced"),
        dictgen::InsensitiveStr::Ascii("hces"),
        dictgen::InsensitiveStr::Ascii("is"),
        dictgen::InsensitiveStr::Ascii("mast"),
        dictgen::InsensitiveStr::Ascii("naps"),
        dictgen::InsensitiveStr::Ascii("ocin"),
        dictgen::InsensitiveStr::Ascii("ocins"),
        dictgen::InsensitiveStr::Ascii("terseet"),
        dictgen::InsensitiveStr::Ascii("tersweat"),
        dictgen::InsensitiveStr::Ascii("tersweeet"),
        dictgen::InsensitiveStr::Ascii("terswet"),
        dictgen::InsensitiveStr::Ascii("terwseet"),
        dictgen::InsensitiveStr::Ascii("ween"),
        dictgen::InsensitiveStr::Ascii("wiedh"),
    ],
    values: &[
        &["bitmaps"],
        &["bitmap"],
        &["bitcoin"],
        &["bitcoins"],
        &["bitcoins"],
        &["bitcoin"],
        &["bitfield"],
        &["bitfield"],
        &["bitfields"],
        &["bitched"],
        &["bitches"],
        &["bits"],
        &["bitmask"],
        &["bitmaps"],
        &["bitcoin"],
        &["bitcoins"],
        &["bittersweet"],
        &["bittersweet"],
        &["bittersweet"],
        &["bittersweet"],
        &["bittersweet"],
        &["between"],
        &["bitwidth"],
    ],
    range: 2..=9,
};

static WORD_BIS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BIS_CHILDREN),
    value: None,
};

pub static WORD_BIS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ct"),
        dictgen::InsensitiveStr::Ascii("cut"),
        dictgen::InsensitiveStr::Ascii("cuts"),
        dictgen::InsensitiveStr::Ascii("euxal"),
        dictgen::InsensitiveStr::Ascii("exaul"),
        dictgen::InsensitiveStr::Ascii("exuella"),
        dictgen::InsensitiveStr::Ascii("ines"),
        dictgen::InsensitiveStr::Ascii("iness"),
        dictgen::InsensitiveStr::Ascii("nes"),
        dictgen::InsensitiveStr::Ascii("ness"),
        dictgen::InsensitiveStr::Ascii("tream"),
        dictgen::InsensitiveStr::Ascii("unes"),
        dictgen::InsensitiveStr::Ascii("uness"),
    ],
    values: &[
        &["bisect"],
        &["biscuit"],
        &["biscuits"],
        &["bisexual"],
        &["bisexual"],
        &["bisexual"],
        &["business"],
        &["business"],
        &["business"],
        &["business"],
        &["bitstream"],
        &["business"],
        &["business"],
    ],
    range: 2..=7,
};

static WORD_BIR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BIR_CHILDREN),
    value: None,
};

pub static WORD_BIR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("damn"),
        dictgen::InsensitiveStr::Ascii("dges"),
        dictgen::InsensitiveStr::Ascii("gade"),
        dictgen::InsensitiveStr::Ascii("gading"),
        dictgen::InsensitiveStr::Ascii("ght"),
        dictgen::InsensitiveStr::Ascii("ghten"),
        dictgen::InsensitiveStr::Ascii("ghter"),
        dictgen::InsensitiveStr::Ascii("ghtest"),
        dictgen::InsensitiveStr::Ascii("ghtness"),
        dictgen::InsensitiveStr::Ascii("htday"),
        dictgen::InsensitiveStr::Ascii("htdays"),
        dictgen::InsensitiveStr::Ascii("idectionality"),
        dictgen::InsensitiveStr::Ascii("mignham"),
        dictgen::InsensitiveStr::Ascii("mimgham"),
        dictgen::InsensitiveStr::Ascii("mingharam"),
        dictgen::InsensitiveStr::Ascii("sbane"),
        dictgen::InsensitiveStr::Ascii("thdayers"),
        dictgen::InsensitiveStr::Ascii("thdaymas"),
        dictgen::InsensitiveStr::Ascii("thdsy"),
    ],
    values: &[
        &["birdman"],
        &["bridges"],
        &["brigade"],
        &["brigading"],
        &["bright"],
        &["brighten"],
        &["brighter"],
        &["brightest"],
        &["brightness"],
        &["birthday"],
        &["birthdays"],
        &["bidirectionality"],
        &["birmingham"],
        &["birmingham"],
        &["birmingham"],
        &["brisbane"],
        &["birthdays"],
        &["birthdays"],
        &["birthdays"],
    ],
    range: 3..=13,
};

static WORD_BIP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BIP_CHILDREN),
    value: None,
};

pub static WORD_BIP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("loar")],
    values: &[&["bipolar"]],
    range: 4..=4,
};

static WORD_BIO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BIO_CHILDREN),
    value: None,
};

pub static WORD_BIO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("gted"),
        dictgen::InsensitiveStr::Ascii("gtry"),
        dictgen::InsensitiveStr::Ascii("ligical"),
        dictgen::InsensitiveStr::Ascii("ligically"),
        dictgen::InsensitiveStr::Ascii("logia"),
        dictgen::InsensitiveStr::Ascii("logicaly"),
        dictgen::InsensitiveStr::Ascii("logiset"),
        dictgen::InsensitiveStr::Ascii("logiskt"),
        dictgen::InsensitiveStr::Ascii("n"),
        dictgen::InsensitiveStr::Ascii("plar"),
    ],
    values: &[
        &["bigoted"],
        &["bigotry"],
        &["biological"],
        &["biologically"],
        &["biological"],
        &["biologically"],
        &["biologist"],
        &["biologist"],
        &["bio"],
        &["bipolar"],
    ],
    range: 1..=9,
};

static WORD_BIN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BIN_CHILDREN),
    value: None,
};

pub static WORD_BIN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("airy"),
        dictgen::InsensitiveStr::Ascii("anary"),
        dictgen::InsensitiveStr::Ascii("ar"),
        dictgen::InsensitiveStr::Ascii("ay"),
        dictgen::InsensitiveStr::Ascii("dins"),
        dictgen::InsensitiveStr::Ascii("idng"),
        dictgen::InsensitiveStr::Ascii("ominal"),
        dictgen::InsensitiveStr::Ascii("raries"),
        dictgen::InsensitiveStr::Ascii("rary"),
    ],
    values: &[
        &["binary"],
        &["binary"],
        &["binary"],
        &["binary"],
        &["bindings"],
        &["binding"],
        &["binomial"],
        &["binaries"],
        &["binary"],
    ],
    range: 2..=6,
};

static WORD_BIM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BIM_CHILDREN),
    value: None,
};

pub static WORD_BIM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ask"),
        dictgen::InsensitiveStr::Ascii("illenia"),
        dictgen::InsensitiveStr::Ascii("illenial"),
        dictgen::InsensitiveStr::Ascii("illenium"),
        dictgen::InsensitiveStr::Ascii("ontly"),
    ],
    values: &[
        &["bitmask"],
        &["bimillennia"],
        &["bimillennial"],
        &["bimillennium"],
        &["bimonthly"],
    ],
    range: 3..=8,
};

static WORD_BIL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BIL_CHILDREN),
    value: None,
};

pub static WORD_BIL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("angual"),
        dictgen::InsensitiveStr::Ascii("ateraly"),
        dictgen::InsensitiveStr::Ascii("bical"),
        dictgen::InsensitiveStr::Ascii("lbaord"),
        dictgen::InsensitiveStr::Ascii("lboad"),
        dictgen::InsensitiveStr::Ascii("lboars"),
        dictgen::InsensitiveStr::Ascii("lborads"),
        dictgen::InsensitiveStr::Ascii("legerent"),
        dictgen::InsensitiveStr::Ascii("lingualism"),
        dictgen::InsensitiveStr::Ascii("lionairre"),
        dictgen::InsensitiveStr::Ascii("lionairres"),
        dictgen::InsensitiveStr::Ascii("lionairs"),
        dictgen::InsensitiveStr::Ascii("lionarie"),
        dictgen::InsensitiveStr::Ascii("lionaries"),
        dictgen::InsensitiveStr::Ascii("lioniare"),
        dictgen::InsensitiveStr::Ascii("lioniares"),
        dictgen::InsensitiveStr::Ascii("lon"),
        dictgen::InsensitiveStr::Ascii("sters"),
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("zzard"),
        dictgen::InsensitiveStr::Ascii("zzcon"),
    ],
    values: &[
        &["bilingual"],
        &["bilaterally"],
        &["biblical"],
        &["billboard"],
        &["billboard"],
        &["billboards"],
        &["billboards"],
        &["belligerent"],
        &["bilingualism"],
        &["billionaire"],
        &["billionaire"],
        &["billionaires"],
        &["billionaire"],
        &["billionaires"],
        &["billionaire"],
        &["billionaires"],
        &["billion"],
        &["blisters"],
        &["built"],
        &["blizzard"],
        &["blizzcon"],
    ],
    range: 1..=10,
};

static WORD_BII_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BII_CHILDREN),
    value: None,
};

pub static WORD_BII_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("nary")],
    values: &[&["binary"]],
    range: 4..=4,
};

static WORD_BIG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BIG_CHILDREN),
    value: None,
};

pub static WORD_BIG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("allic"),
        dictgen::InsensitiveStr::Ascii("fooot"),
        dictgen::InsensitiveStr::Ascii("ining"),
        dictgen::InsensitiveStr::Ascii("inning"),
        dictgen::InsensitiveStr::Ascii("orty"),
        dictgen::InsensitiveStr::Ascii("rading"),
        dictgen::InsensitiveStr::Ascii("toed"),
        dictgen::InsensitiveStr::Ascii("tory"),
    ],
    values: &[
        &["bigalloc"],
        &["bigfoot"],
        &["beginning"],
        &["beginning"],
        &["bigotry"],
        &["brigading"],
        &["bigoted"],
        &["bigotry"],
    ],
    range: 4..=6,
};

static WORD_BIF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BIF_CHILDREN),
    value: None,
};

pub static WORD_BIF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("goot")],
    values: &[&["bigfoot"]],
    range: 4..=4,
};

static WORD_BIE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BIE_CHILDREN),
    value: None,
};

pub static WORD_BIE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("jing")],
    values: &[&["beijing"]],
    range: 4..=4,
};

static WORD_BID_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BID_CHILDREN),
    value: None,
};

pub static WORD_BID_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("dings"),
        dictgen::InsensitiveStr::Ascii("imentionnal"),
        dictgen::InsensitiveStr::Ascii("ings"),
        dictgen::InsensitiveStr::Ascii("ning"),
        dictgen::InsensitiveStr::Ascii("nings"),
        dictgen::InsensitiveStr::Ascii("rman"),
    ],
    values: &[
        &["bidding"],
        &["bidimensional"],
        &["bidding", "bindings"],
        &["binding"],
        &["bindings"],
        &["birdman"],
    ],
    range: 4..=11,
};

static WORD_BIC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BIC_CHILDREN),
    value: None,
};

pub static WORD_BIC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ast"),
        dictgen::InsensitiveStr::Ascii("thes"),
        dictgen::InsensitiveStr::Ascii("ylces"),
    ],
    values: &[&["bitcast"], &["bitches"], &["bicycles"]],
    range: 3..=5,
};

static WORD_BIB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BIB_CHILDREN),
    value: None,
};

pub static WORD_BIB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ilcal")],
    values: &[&["biblical"]],
    range: 5..=5,
};

static WORD_BIA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BIA_CHILDREN),
    value: None,
};

pub static WORD_BIA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("nries"),
        dictgen::InsensitiveStr::Ascii("nry"),
        dictgen::InsensitiveStr::Ascii("ppicative"),
    ],
    values: &[&["binaries"], &["binary"], &["biapplicative"]],
    range: 3..=9,
};

static WORD_BG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BG_CHILDREN),
    value: None,
};

pub static WORD_BG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("inning")],
    values: &[&["beginning"]],
    range: 6..=6,
};

static WORD_BF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BF_CHILDREN),
    value: None,
};

pub static WORD_BF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("fer")],
    values: &[&["buffer"]],
    range: 3..=3,
};

static WORD_BE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_BE_CHILDREN),
    value: None,
};

static WORD_BE_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_BEA_NODE),
    Some(&WORD_BEB_NODE),
    Some(&WORD_BEC_NODE),
    Some(&WORD_BED_NODE),
    Some(&WORD_BEE_NODE),
    Some(&WORD_BEF_NODE),
    Some(&WORD_BEG_NODE),
    Some(&WORD_BEH_NODE),
    Some(&WORD_BEI_NODE),
    Some(&WORD_BEJ_NODE),
    None,
    Some(&WORD_BEL_NODE),
    Some(&WORD_BEM_NODE),
    Some(&WORD_BEN_NODE),
    Some(&WORD_BEO_NODE),
    None,
    None,
    Some(&WORD_BER_NODE),
    Some(&WORD_BES_NODE),
    Some(&WORD_BET_NODE),
    Some(&WORD_BEU_NODE),
    Some(&WORD_BEV_NODE),
    Some(&WORD_BEW_NODE),
    None,
    Some(&WORD_BEY_NODE),
    None,
];

static WORD_BEY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BEY_CHILDREN),
    value: None,
};

pub static WORD_BEY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("oncye"),
        dictgen::InsensitiveStr::Ascii("one"),
        dictgen::InsensitiveStr::Ascii("ong"),
        dictgen::InsensitiveStr::Ascii("ound"),
    ],
    values: &[&["beyonce"], &["beyond"], &["beyond"], &["beyond"]],
    range: 3..=5,
};

static WORD_BEW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BEW_CHILDREN),
    value: None,
};

pub static WORD_BEW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eeen"),
        dictgen::InsensitiveStr::Ascii("een"),
        dictgen::InsensitiveStr::Ascii("teen"),
        dictgen::InsensitiveStr::Ascii("teeness"),
    ],
    values: &[&["between"], &["between"], &["between"], &["betweenness"]],
    range: 3..=7,
};

static WORD_BEV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BEV_CHILDREN),
    value: None,
};

pub static WORD_BEV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("er"),
        dictgen::InsensitiveStr::Ascii("ore"),
        dictgen::InsensitiveStr::Ascii("orehand"),
        dictgen::InsensitiveStr::Ascii("orhand"),
    ],
    values: &[&["never"], &["before"], &["beforehand"], &["beforehand"]],
    range: 2..=7,
};

static WORD_BEU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BEU_CHILDREN),
    value: None,
};

pub static WORD_BEU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("atiful"),
        dictgen::InsensitiveStr::Ascii("atifully"),
        dictgen::InsensitiveStr::Ascii("case"),
        dictgen::InsensitiveStr::Ascii("racracy"),
        dictgen::InsensitiveStr::Ascii("raucracy"),
        dictgen::InsensitiveStr::Ascii("raucratic"),
        dictgen::InsensitiveStr::Ascii("raucratically"),
        dictgen::InsensitiveStr::Ascii("raucrats"),
        dictgen::InsensitiveStr::Ascii("tification"),
        dictgen::InsensitiveStr::Ascii("tiful"),
        dictgen::InsensitiveStr::Ascii("tifully"),
    ],
    values: &[
        &["beautiful"],
        &["beautifully"],
        &["because"],
        &["bureaucracy"],
        &["bureaucracy"],
        &["bureaucratic"],
        &["bureaucratically"],
        &["bureaucrats"],
        &["beautification"],
        &["beautiful"],
        &["beautifully"],
    ],
    range: 4..=13,
};

static WORD_BET_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BET_CHILDREN),
    value: None,
};

pub static WORD_BET_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ales"),
        dictgen::InsensitiveStr::Ascii("eeen"),
        dictgen::InsensitiveStr::Ascii("een"),
        dictgen::InsensitiveStr::Ascii("ehsda"),
        dictgen::InsensitiveStr::Ascii("er"),
        dictgen::InsensitiveStr::Ascii("eshda"),
        dictgen::InsensitiveStr::Ascii("eween"),
        dictgen::InsensitiveStr::Ascii("hdesa"),
        dictgen::InsensitiveStr::Ascii("hedsa"),
        dictgen::InsensitiveStr::Ascii("hesa"),
        dictgen::InsensitiveStr::Ascii("hseda"),
        dictgen::InsensitiveStr::Ascii("rayd"),
        dictgen::InsensitiveStr::Ascii("rayeado"),
        dictgen::InsensitiveStr::Ascii("rween"),
        dictgen::InsensitiveStr::Ascii("tern"),
        dictgen::InsensitiveStr::Ascii("tery"),
        dictgen::InsensitiveStr::Ascii("tr"),
        dictgen::InsensitiveStr::Ascii("tween"),
        dictgen::InsensitiveStr::Ascii("wean"),
        dictgen::InsensitiveStr::Ascii("wee"),
        dictgen::InsensitiveStr::Ascii("weed"),
        dictgen::InsensitiveStr::Ascii("weeen"),
        dictgen::InsensitiveStr::Ascii("weem"),
        dictgen::InsensitiveStr::Ascii("weend"),
        dictgen::InsensitiveStr::Ascii("weeness"),
        dictgen::InsensitiveStr::Ascii("weent"),
        dictgen::InsensitiveStr::Ascii("wen"),
        dictgen::InsensitiveStr::Ascii("wene"),
        dictgen::InsensitiveStr::Ascii("wenn"),
        dictgen::InsensitiveStr::Ascii("wern"),
        dictgen::InsensitiveStr::Ascii("wween"),
        dictgen::InsensitiveStr::Ascii("wwen"),
    ],
    values: &[
        &["beatles"],
        &["between"],
        &["between"],
        &["bethesda"],
        &["better"],
        &["bethesda"],
        &["between"],
        &["bethesda"],
        &["bethesda"],
        &["bethesda"],
        &["bethesda"],
        &["betrayed"],
        &["betrayed"],
        &["between"],
        &["better"],
        &["better", "battery"],
        &["better", "bettor"],
        &["between"],
        &["between"],
        &["between"],
        &["between"],
        &["between"],
        &["between"],
        &["between"],
        &["betweenness"],
        &["between"],
        &["between"],
        &["between"],
        &["between"],
        &["between"],
        &["between"],
        &["between"],
    ],
    range: 2..=7,
};

static WORD_BES_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BES_CHILDREN),
    value: None,
};

pub static WORD_BES_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cribed"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("eige"),
        dictgen::InsensitiveStr::Ascii("eiged"),
        dictgen::InsensitiveStr::Ascii("eiging"),
        dictgen::InsensitiveStr::Ascii("ided"),
        dictgen::InsensitiveStr::Ascii("itality"),
        dictgen::InsensitiveStr::Ascii("taility"),
        dictgen::InsensitiveStr::Ascii("teality"),
        dictgen::InsensitiveStr::Ascii("tialiy"),
        dictgen::InsensitiveStr::Ascii("tiallity"),
    ],
    values: &[
        &["described"],
        &["based"],
        &["besiege"],
        &["besieged"],
        &["besieging"],
        &["besides"],
        &["bestiality"],
        &["bestiality"],
        &["bestiality"],
        &["bestiality"],
        &["bestiality"],
    ],
    range: 2..=8,
};

static WORD_BER_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BER_CHILDREN),
    value: None,
};

pub static WORD_BER_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aded"),
        dictgen::InsensitiveStr::Ascii("ekley"),
        dictgen::InsensitiveStr::Ascii("fore"),
        dictgen::InsensitiveStr::Ascii("forming"),
        dictgen::InsensitiveStr::Ascii("gamont"),
        dictgen::InsensitiveStr::Ascii("kelely"),
        dictgen::InsensitiveStr::Ascii("kley"),
        dictgen::InsensitiveStr::Ascii("nouilli"),
        dictgen::InsensitiveStr::Ascii("sekr"),
        dictgen::InsensitiveStr::Ascii("sekrer"),
        dictgen::InsensitiveStr::Ascii("serkr"),
        dictgen::InsensitiveStr::Ascii("skerer"),
        dictgen::InsensitiveStr::Ascii("ween"),
    ],
    values: &[
        &["bearded"],
        &["berkeley"],
        &["before"],
        &["performing"],
        &["bergamot"],
        &["berkeley"],
        &["berkeley"],
        &["bernoulli"],
        &["berserk"],
        &["berserker"],
        &["berserker"],
        &["berserker"],
        &["between"],
    ],
    range: 4..=7,
};

static WORD_BEO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BEO_CHILDREN),
    value: None,
};

pub static WORD_BEO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("nd"),
        dictgen::InsensitiveStr::Ascii("ynce"),
    ],
    values: &[&["beyond"], &["beyonce"]],
    range: 2..=4,
};

static WORD_BEN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_BEN_CHILDREN),
    value: None,
};

static WORD_BEN_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_BENA_NODE),
    None,
    Some(&WORD_BENC_NODE),
    None,
    Some(&WORD_BENE_NODE),
    Some(&WORD_BENF_NODE),
    Some(&WORD_BENG_NODE),
    Some(&WORD_BENH_NODE),
    Some(&WORD_BENI_NODE),
    Some(&WORD_BENJ_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_BENO_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_BENO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BENO_CHILDREN),
    value: None,
};

pub static WORD_BENO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("velent")],
    values: &[&["benevolent"]],
    range: 6..=6,
};

static WORD_BENJ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BENJ_CHILDREN),
    value: Some(&["binge"]),
};

pub static WORD_BENJ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("er"),
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("ing"),
    ],
    values: &[&["binged"], &["binger"], &["binges"], &["binging"]],
    range: 2..=3,
};

static WORD_BENI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BENI_CHILDREN),
    value: None,
};

pub static WORD_BENI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("dect"),
        dictgen::InsensitiveStr::Ascii("ficial"),
        dictgen::InsensitiveStr::Ascii("fit"),
        dictgen::InsensitiveStr::Ascii("fite"),
        dictgen::InsensitiveStr::Ascii("fited"),
        dictgen::InsensitiveStr::Ascii("fitial"),
        dictgen::InsensitiveStr::Ascii("fits"),
        dictgen::InsensitiveStr::Ascii("g"),
        dictgen::InsensitiveStr::Ascii("ne"),
    ],
    values: &[
        &["benedict"],
        &["beneficial"],
        &["benefit"],
        &["benefit"],
        &["benefited"],
        &["beneficial"],
        &["benefits"],
        &["being"],
        &["benign"],
    ],
    range: 1..=6,
};

static WORD_BENH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BENH_CHILDREN),
    value: None,
};

pub static WORD_BENH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("gazi"),
        dictgen::InsensitiveStr::Ascii("ind"),
    ],
    values: &[&["benghazi"], &["behind"]],
    range: 3..=4,
};

static WORD_BENG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BENG_CHILDREN),
    value: Some(&["being"]),
};

pub static WORD_BENG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ahzi"),
        dictgen::InsensitiveStr::Ascii("alas"),
        dictgen::InsensitiveStr::Ascii("alos"),
        dictgen::InsensitiveStr::Ascii("azhi"),
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("eing"),
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("hai"),
        dictgen::InsensitiveStr::Ascii("hazhi"),
        dictgen::InsensitiveStr::Ascii("hazzi"),
        dictgen::InsensitiveStr::Ascii("hzai"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("las"),
        dictgen::InsensitiveStr::Ascii("zhai"),
    ],
    values: &[
        &["benghazi"],
        &["bengals"],
        &["bengals"],
        &["benghazi"],
        &["binge"],
        &["binged"],
        &["bingeing"],
        &["binges"],
        &["benghazi"],
        &["benghazi"],
        &["benghazi"],
        &["benghazi"],
        &["binging"],
        &["bengals"],
        &["benghazi"],
    ],
    range: 1..=5,
};

static WORD_BENF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BENF_CHILDREN),
    value: None,
};

pub static WORD_BENF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("its")],
    values: &[&["benefits"]],
    range: 3..=3,
};

static WORD_BENE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BENE_CHILDREN),
    value: None,
};

pub static WORD_BENE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("chmark"),
        dictgen::InsensitiveStr::Ascii("chmarked"),
        dictgen::InsensitiveStr::Ascii("chmarking"),
        dictgen::InsensitiveStr::Ascii("chmarks"),
        dictgen::InsensitiveStr::Ascii("dicat"),
        dictgen::InsensitiveStr::Ascii("dickt"),
        dictgen::InsensitiveStr::Ascii("dit"),
        dictgen::InsensitiveStr::Ascii("eth"),
        dictgen::InsensitiveStr::Ascii("fecial"),
        dictgen::InsensitiveStr::Ascii("fica"),
        dictgen::InsensitiveStr::Ascii("fical"),
        dictgen::InsensitiveStr::Ascii("ficary"),
        dictgen::InsensitiveStr::Ascii("ficiul"),
        dictgen::InsensitiveStr::Ascii("fied"),
        dictgen::InsensitiveStr::Ascii("fitial"),
        dictgen::InsensitiveStr::Ascii("fitical"),
        dictgen::InsensitiveStr::Ascii("ifical"),
        dictgen::InsensitiveStr::Ascii("its"),
        dictgen::InsensitiveStr::Ascii("lovent"),
        dictgen::InsensitiveStr::Ascii("rate"),
        dictgen::InsensitiveStr::Ascii("tifs"),
        dictgen::InsensitiveStr::Ascii("valent"),
        dictgen::InsensitiveStr::Ascii("velant"),
        dictgen::InsensitiveStr::Ascii("velent"),
        dictgen::InsensitiveStr::Ascii("velont"),
        dictgen::InsensitiveStr::Ascii("vloent"),
        dictgen::InsensitiveStr::Ascii("volant"),
    ],
    values: &[
        &["benchmark"],
        &["benchmarked"],
        &["benchmarking"],
        &["benchmarks"],
        &["benedict"],
        &["benedict"],
        &["benedict"],
        &["beneath"],
        &["beneficial"],
        &["beneficial"],
        &["beneficial"],
        &["beneficiary"],
        &["beneficial"],
        &["benefited"],
        &["beneficial"],
        &["beneficial"],
        &["beneficial"],
        &["benefits"],
        &["benevolent"],
        &["generate", "venerate"],
        &["benefits"],
        &["benevolent"],
        &["benevolent"],
        &["benevolent"],
        &["benevolent"],
        &["benevolent"],
        &["benevolent"],
    ],
    range: 3..=9,
};

static WORD_BENC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BENC_CHILDREN),
    value: None,
};

pub static WORD_BENC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("hamarked"),
        dictgen::InsensitiveStr::Ascii("hamarking"),
        dictgen::InsensitiveStr::Ascii("hamrk"),
        dictgen::InsensitiveStr::Ascii("hamrked"),
        dictgen::InsensitiveStr::Ascii("hamrking"),
        dictgen::InsensitiveStr::Ascii("hamrks"),
        dictgen::InsensitiveStr::Ascii("hmakrs"),
        dictgen::InsensitiveStr::Ascii("hmars"),
        dictgen::InsensitiveStr::Ascii("hmkar"),
        dictgen::InsensitiveStr::Ascii("hmkared"),
        dictgen::InsensitiveStr::Ascii("hmkaring"),
        dictgen::InsensitiveStr::Ascii("hmkars"),
        dictgen::InsensitiveStr::Ascii("hs"),
        dictgen::InsensitiveStr::Ascii("kmark"),
        dictgen::InsensitiveStr::Ascii("kmarked"),
        dictgen::InsensitiveStr::Ascii("kmarking"),
        dictgen::InsensitiveStr::Ascii("kmarks"),
    ],
    values: &[
        &["benchmarked"],
        &["benchmarking"],
        &["benchmark"],
        &["benchmarked"],
        &["benchmarking"],
        &["benchmarks"],
        &["benchmarks"],
        &["benchmarks"],
        &["benchmark"],
        &["benchmarked"],
        &["benchmarking"],
        &["benchmarks"],
        &["benches"],
        &["benchmark"],
        &["benchmarked"],
        &["benchmarking"],
        &["benchmarks"],
    ],
    range: 2..=9,
};

static WORD_BENA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BENA_CHILDREN),
    value: None,
};

pub static WORD_BENA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("gls")],
    values: &[&["bengals"]],
    range: 3..=3,
};

static WORD_BEM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BEM_CHILDREN),
    value: None,
};

pub static WORD_BEM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("usemnt")],
    values: &[&["bemusement"]],
    range: 6..=6,
};

static WORD_BEL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_BEL_CHILDREN),
    value: None,
};

static WORD_BEL_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    None,
    None,
    Some(&WORD_BELE_NODE),
    None,
    Some(&WORD_BELG_NODE),
    None,
    Some(&WORD_BELI_NODE),
    None,
    None,
    Some(&WORD_BELL_NODE),
    None,
    None,
    Some(&WORD_BELO_NODE),
    None,
    None,
    None,
    Some(&WORD_BELS_NODE),
    None,
    None,
    None,
    Some(&WORD_BELW_NODE),
    None,
    Some(&WORD_BELY_NODE),
    None,
];

static WORD_BELY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BELY_CHILDREN),
    value: None,
};

pub static WORD_BELY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("s"),
        dictgen::InsensitiveStr::Ascii("w"),
    ],
    values: &[
        &["belie"],
        &["belied"],
        &["belies"],
        &["belies"],
        &["below"],
    ],
    range: 1..=2,
};

static WORD_BELW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BELW_CHILDREN),
    value: None,
};

pub static WORD_BELW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("o")],
    values: &[&["below"]],
    range: 1..=1,
};

static WORD_BELS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BELS_CHILDREN),
    value: None,
};

pub static WORD_BELS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("sings")],
    values: &[&["blessings"]],
    range: 5..=5,
};

static WORD_BELO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BELO_CHILDREN),
    value: None,
};

pub static WORD_BELO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("g"),
        dictgen::InsensitiveStr::Ascii("ging"),
        dictgen::InsensitiveStr::Ascii("gs"),
        dictgen::InsensitiveStr::Ascii("nd"),
        dictgen::InsensitiveStr::Ascii("ning"),
        dictgen::InsensitiveStr::Ascii("ve"),
        dictgen::InsensitiveStr::Ascii("wn"),
    ],
    values: &[
        &["belong"],
        &["belonging"],
        &["belongs"],
        &["belong"],
        &["belonging"],
        &["below", "beloved"],
        &["belong"],
    ],
    range: 1..=4,
};

static WORD_BELL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BELL_CHILDREN),
    value: None,
};

pub static WORD_BELL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("igerant"),
        dictgen::InsensitiveStr::Ascii("igerante"),
        dictgen::InsensitiveStr::Ascii("igirent"),
        dictgen::InsensitiveStr::Ascii("weather"),
    ],
    values: &[
        &["belligerent"],
        &["belligerent"],
        &["belligerent"],
        &["bellwether"],
    ],
    range: 7..=8,
};

static WORD_BELI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BELI_CHILDREN),
    value: None,
};

pub static WORD_BELI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("avable"),
        dictgen::InsensitiveStr::Ascii("ebable"),
        dictgen::InsensitiveStr::Ascii("efable"),
        dictgen::InsensitiveStr::Ascii("efe"),
        dictgen::InsensitiveStr::Ascii("efed"),
        dictgen::InsensitiveStr::Ascii("efes"),
        dictgen::InsensitiveStr::Ascii("efing"),
        dictgen::InsensitiveStr::Ascii("eveble"),
        dictgen::InsensitiveStr::Ascii("evr"),
        dictgen::InsensitiveStr::Ascii("evs"),
        dictgen::InsensitiveStr::Ascii("fes"),
        dictgen::InsensitiveStr::Ascii("gan"),
        dictgen::InsensitiveStr::Ascii("gum"),
        dictgen::InsensitiveStr::Ascii("ng"),
        dictgen::InsensitiveStr::Ascii("ttleing"),
        dictgen::InsensitiveStr::Ascii("ttlling"),
        dictgen::InsensitiveStr::Ascii("v"),
        dictgen::InsensitiveStr::Ascii("vable"),
        dictgen::InsensitiveStr::Ascii("ve"),
        dictgen::InsensitiveStr::Ascii("veable"),
        dictgen::InsensitiveStr::Ascii("veably"),
        dictgen::InsensitiveStr::Ascii("veble"),
        dictgen::InsensitiveStr::Ascii("vebly"),
        dictgen::InsensitiveStr::Ascii("ved"),
        dictgen::InsensitiveStr::Ascii("veing"),
        dictgen::InsensitiveStr::Ascii("ves"),
        dictgen::InsensitiveStr::Ascii("ving"),
    ],
    values: &[
        &["believable"],
        &["believable"],
        &["believable"],
        &["believe", "belief"],
        &["believed"],
        &["beliefs", "believes"],
        &["believing"],
        &["believable"],
        &["believer"],
        &["believes"],
        &["beliefs"],
        &["belgian"],
        &["belgium"],
        &["belong"],
        &["belittling"],
        &["belittling"],
        &["believe", "belief"],
        &["believable"],
        &["believe"],
        &["believable"],
        &["believably"],
        &["believable"],
        &["believably"],
        &["believed", "beloved"],
        &["believing"],
        &["believes", "beliefs"],
        &["believing"],
    ],
    range: 1..=7,
};

static WORD_BELG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BELG_CHILDREN),
    value: None,
};

pub static WORD_BELG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ain"),
        dictgen::InsensitiveStr::Ascii("uim"),
    ],
    values: &[&["belgian"], &["belgium"]],
    range: 3..=3,
};

static WORD_BELE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BELE_CHILDREN),
    value: None,
};

pub static WORD_BELE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("agured"),
        dictgen::InsensitiveStr::Ascii("ave"),
        dictgen::InsensitiveStr::Ascii("aved"),
        dictgen::InsensitiveStr::Ascii("aver"),
        dictgen::InsensitiveStr::Ascii("aves"),
        dictgen::InsensitiveStr::Ascii("aving"),
        dictgen::InsensitiveStr::Ascii("if"),
        dictgen::InsensitiveStr::Ascii("ifable"),
        dictgen::InsensitiveStr::Ascii("ife"),
        dictgen::InsensitiveStr::Ascii("ifed"),
        dictgen::InsensitiveStr::Ascii("ifes"),
        dictgen::InsensitiveStr::Ascii("ifing"),
        dictgen::InsensitiveStr::Ascii("ifs"),
        dictgen::InsensitiveStr::Ascii("iv"),
        dictgen::InsensitiveStr::Ascii("ivable"),
        dictgen::InsensitiveStr::Ascii("ive"),
        dictgen::InsensitiveStr::Ascii("ived"),
        dictgen::InsensitiveStr::Ascii("iver"),
        dictgen::InsensitiveStr::Ascii("ives"),
        dictgen::InsensitiveStr::Ascii("iving"),
    ],
    values: &[
        &["beleaguered"],
        &["believe"],
        &["believed"],
        &["believer"],
        &["believes"],
        &["believing"],
        &["belief"],
        &["believable"],
        &["belief", "believe"],
        &["believed"],
        &["beliefs", "believes"],
        &["believing"],
        &["beliefs"],
        &["believe", "belief"],
        &["believable"],
        &["believe"],
        &["believed"],
        &["believer"],
        &["believes"],
        &["believing"],
    ],
    range: 2..=6,
};

static WORD_BEJ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BEJ_CHILDREN),
    value: None,
};

pub static WORD_BEJ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("iing"),
        dictgen::InsensitiveStr::Ascii("ond"),
    ],
    values: &[&["beijing"], &["beyond"]],
    range: 3..=4,
};

static WORD_BEI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BEI_CHILDREN),
    value: None,
};

pub static WORD_BEI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("gin"),
        dictgen::InsensitiveStr::Ascii("ginning"),
        dictgen::InsensitiveStr::Ascii("nd"),
        dictgen::InsensitiveStr::Ascii("nning"),
    ],
    values: &[
        &["begin"],
        &["beginning"],
        &["behind", "being"],
        &["beginning"],
    ],
    range: 2..=7,
};

static WORD_BEH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BEH_CHILDREN),
    value: None,
};

pub static WORD_BEH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("abior"),
        dictgen::InsensitiveStr::Ascii("abiors"),
        dictgen::InsensitiveStr::Ascii("abiour"),
        dictgen::InsensitiveStr::Ascii("abiours"),
        dictgen::InsensitiveStr::Ascii("abviour"),
        dictgen::InsensitiveStr::Ascii("aivior"),
        dictgen::InsensitiveStr::Ascii("aiviour"),
        dictgen::InsensitiveStr::Ascii("aiviuor"),
        dictgen::InsensitiveStr::Ascii("aivor"),
        dictgen::InsensitiveStr::Ascii("aivors"),
        dictgen::InsensitiveStr::Ascii("aivour"),
        dictgen::InsensitiveStr::Ascii("aivoural"),
        dictgen::InsensitiveStr::Ascii("aivours"),
        dictgen::InsensitiveStr::Ascii("avies"),
        dictgen::InsensitiveStr::Ascii("aviorial"),
        dictgen::InsensitiveStr::Ascii("aviorly"),
        dictgen::InsensitiveStr::Ascii("avios"),
        dictgen::InsensitiveStr::Ascii("avious"),
        dictgen::InsensitiveStr::Ascii("avioutr"),
        dictgen::InsensitiveStr::Ascii("aviro"),
        dictgen::InsensitiveStr::Ascii("aviuor"),
        dictgen::InsensitiveStr::Ascii("avoir"),
        dictgen::InsensitiveStr::Ascii("avoiral"),
        dictgen::InsensitiveStr::Ascii("avoirs"),
        dictgen::InsensitiveStr::Ascii("avoiur"),
        dictgen::InsensitiveStr::Ascii("avoiurs"),
        dictgen::InsensitiveStr::Ascii("avor"),
        dictgen::InsensitiveStr::Ascii("avoral"),
        dictgen::InsensitiveStr::Ascii("avorial"),
        dictgen::InsensitiveStr::Ascii("avour"),
        dictgen::InsensitiveStr::Ascii("avoural"),
        dictgen::InsensitiveStr::Ascii("avriour"),
        dictgen::InsensitiveStr::Ascii("avriours"),
        dictgen::InsensitiveStr::Ascii("inde"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("ngazi"),
        dictgen::InsensitiveStr::Ascii("oviour"),
        dictgen::InsensitiveStr::Ascii("tesda"),
        dictgen::InsensitiveStr::Ascii("vaior"),
        dictgen::InsensitiveStr::Ascii("vaiour"),
        dictgen::InsensitiveStr::Ascii("vaiours"),
        dictgen::InsensitiveStr::Ascii("viour"),
    ],
    values: &[
        &["behavior"],
        &["behaviors"],
        &["behaviour"],
        &["behaviours"],
        &["behaviour"],
        &["behavior"],
        &["behaviour"],
        &["behavior"],
        &["behavior"],
        &["behaviors"],
        &["behaviour"],
        &["behavioural"],
        &["behaviours"],
        &["behaves"],
        &["behavioral"],
        &["behavioral"],
        &["behaviors"],
        &["behaviour", "behaviours"],
        &["behaviour"],
        &["behavior"],
        &["behavior"],
        &["behavior"],
        &["behavioral"],
        &["behaviors"],
        &["behaviour"],
        &["behaviours"],
        &["behavior"],
        &["behavioral"],
        &["behavioral"],
        &["behaviour"],
        &["behavioural"],
        &["behaviour"],
        &["behaviours"],
        &["behind"],
        &["behind", "being"],
        &["benghazi"],
        &["behaviour"],
        &["bethesda"],
        &["behavior"],
        &["behaviour"],
        &["behaviours"],
        &["behaviour"],
    ],
    range: 3..=8,
};

static WORD_BEG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BEG_CHILDREN),
    value: None,
};

pub static WORD_BEG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("gin"),
        dictgen::InsensitiveStr::Ascii("giner"),
        dictgen::InsensitiveStr::Ascii("giners"),
        dictgen::InsensitiveStr::Ascii("gingin"),
        dictgen::InsensitiveStr::Ascii("ginging"),
        dictgen::InsensitiveStr::Ascii("ginig"),
        dictgen::InsensitiveStr::Ascii("gining"),
        dictgen::InsensitiveStr::Ascii("ginings"),
        dictgen::InsensitiveStr::Ascii("ginng"),
        dictgen::InsensitiveStr::Ascii("ginnig"),
        dictgen::InsensitiveStr::Ascii("ginning"),
        dictgen::InsensitiveStr::Ascii("gins"),
        dictgen::InsensitiveStr::Ascii("havior"),
        dictgen::InsensitiveStr::Ascii("haviors"),
        dictgen::InsensitiveStr::Ascii("iinning"),
        dictgen::InsensitiveStr::Ascii("iner"),
        dictgen::InsensitiveStr::Ascii("ines"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("ining"),
        dictgen::InsensitiveStr::Ascii("inining"),
        dictgen::InsensitiveStr::Ascii("ininings"),
        dictgen::InsensitiveStr::Ascii("ininng"),
        dictgen::InsensitiveStr::Ascii("ininngs"),
        dictgen::InsensitiveStr::Ascii("inn"),
        dictgen::InsensitiveStr::Ascii("innig"),
        dictgen::InsensitiveStr::Ascii("innin"),
        dictgen::InsensitiveStr::Ascii("inninng"),
        dictgen::InsensitiveStr::Ascii("innins"),
        dictgen::InsensitiveStr::Ascii("innning"),
        dictgen::InsensitiveStr::Ascii("innnings"),
        dictgen::InsensitiveStr::Ascii("lian"),
        dictgen::InsensitiveStr::Ascii("lium"),
        dictgen::InsensitiveStr::Ascii("nals"),
    ],
    values: &[
        &["begin", "begging"],
        &["beginner"],
        &["beginners"],
        &["beginning"],
        &["beginning"],
        &["begging", "beginning"],
        &["beginning"],
        &["beginnings"],
        &["begging"],
        &["beginning"],
        &["beginning"],
        &["begins"],
        &["behavior"],
        &["behaviors"],
        &["beginning"],
        &["beginner"],
        &["begins"],
        &["begging", "beginning", "being"],
        &["beginning"],
        &["beginning"],
        &["beginnings"],
        &["beginning"],
        &["beginnings"],
        &["begin"],
        &["beginning"],
        &["beginning"],
        &["beginnings"],
        &["beginnings"],
        &["beginning"],
        &["beginnings"],
        &["belgian"],
        &["belgium"],
        &["bengals"],
    ],
    range: 3..=8,
};

static WORD_BEF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BEF_CHILDREN),
    value: None,
};

pub static WORD_BEF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("fer"),
        dictgen::InsensitiveStr::Ascii("irend"),
        dictgen::InsensitiveStr::Ascii("oer"),
        dictgen::InsensitiveStr::Ascii("or"),
        dictgen::InsensitiveStr::Ascii("orehands"),
        dictgen::InsensitiveStr::Ascii("orere"),
        dictgen::InsensitiveStr::Ascii("ores"),
        dictgen::InsensitiveStr::Ascii("oring"),
        dictgen::InsensitiveStr::Ascii("reind"),
        dictgen::InsensitiveStr::Ascii("ried"),
        dictgen::InsensitiveStr::Ascii("ure"),
    ],
    values: &[
        &["buffer"],
        &["befriend"],
        &["before"],
        &["before"],
        &["beforehand"],
        &["before"],
        &["before"],
        &["before"],
        &["befriend"],
        &["befriend"],
        &["before"],
    ],
    range: 2..=8,
};

static WORD_BEE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BEE_CHILDREN),
    value: None,
};

pub static WORD_BEE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("d"),
        dictgen::InsensitiveStr::Ascii("en"),
        dictgen::InsensitiveStr::Ascii("htoven"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("ings"),
        dictgen::InsensitiveStr::Ascii("rer"),
        dictgen::InsensitiveStr::Ascii("thoveen"),
        dictgen::InsensitiveStr::Ascii("tween"),
        dictgen::InsensitiveStr::Ascii("twen"),
    ],
    values: &[
        &["bead", "been", "beer", "bees", "beet"],
        &["been"],
        &["beethoven"],
        &["being", "been"],
        &["beings"],
        &["bearer"],
        &["beethoven"],
        &["between"],
        &["between"],
    ],
    range: 1..=7,
};

static WORD_BED_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BED_CHILDREN),
    value: None,
};

pub static WORD_BED_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("ore"),
    ],
    values: &[&["bedding", "begging"], &["before"]],
    range: 3..=3,
};

static WORD_BEC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BEC_CHILDREN),
    value: None,
};

pub static WORD_BEC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aause"),
        dictgen::InsensitiveStr::Ascii("acdd"),
        dictgen::InsensitiveStr::Ascii("ahse"),
        dictgen::InsensitiveStr::Ascii("amae"),
        dictgen::InsensitiveStr::Ascii("ames"),
        dictgen::InsensitiveStr::Ascii("aouse"),
        dictgen::InsensitiveStr::Ascii("ase"),
        dictgen::InsensitiveStr::Ascii("asue"),
        dictgen::InsensitiveStr::Ascii("asuse"),
        dictgen::InsensitiveStr::Ascii("auae"),
        dictgen::InsensitiveStr::Ascii("auce"),
        dictgen::InsensitiveStr::Ascii("aue"),
        dictgen::InsensitiveStr::Ascii("aues"),
        dictgen::InsensitiveStr::Ascii("aus"),
        dictgen::InsensitiveStr::Ascii("ausee"),
        dictgen::InsensitiveStr::Ascii("auseq"),
        dictgen::InsensitiveStr::Ascii("auses"),
        dictgen::InsensitiveStr::Ascii("ausw"),
        dictgen::InsensitiveStr::Ascii("cause"),
        dictgen::InsensitiveStr::Ascii("hmark"),
        dictgen::InsensitiveStr::Ascii("hmarked"),
        dictgen::InsensitiveStr::Ascii("hmarking"),
        dictgen::InsensitiveStr::Ascii("hmarks"),
        dictgen::InsensitiveStr::Ascii("nhmark"),
        dictgen::InsensitiveStr::Ascii("nhmarks"),
        dictgen::InsensitiveStr::Ascii("oem"),
        dictgen::InsensitiveStr::Ascii("omeing"),
        dictgen::InsensitiveStr::Ascii("omme"),
        dictgen::InsensitiveStr::Ascii("ommes"),
        dictgen::InsensitiveStr::Ascii("omming"),
        dictgen::InsensitiveStr::Ascii("oms"),
        dictgen::InsensitiveStr::Ascii("ouse"),
        dictgen::InsensitiveStr::Ascii("oz"),
        dictgen::InsensitiveStr::Ascii("tor"),
        dictgen::InsensitiveStr::Ascii("tors"),
        dictgen::InsensitiveStr::Ascii("uaes"),
        dictgen::InsensitiveStr::Ascii("uase"),
        dictgen::InsensitiveStr::Ascii("uasse"),
        dictgen::InsensitiveStr::Ascii("usae"),
        dictgen::InsensitiveStr::Ascii("use"),
        dictgen::InsensitiveStr::Ascii("uz"),
        dictgen::InsensitiveStr::Ascii("xause"),
    ],
    values: &[
        &["because"],
        &["because"],
        &["because"],
        &["became"],
        &["becomes", "became"],
        &["because"],
        &["because"],
        &["because"],
        &["because"],
        &["because"],
        &["because"],
        &["because"],
        &["because"],
        &["because"],
        &["because"],
        &["because"],
        &["because"],
        &["because"],
        &["because"],
        &["benchmark"],
        &["benchmarked"],
        &["benchmarking"],
        &["benchmarks"],
        &["benchmark"],
        &["benchmarks"],
        &["become"],
        &["becoming"],
        &["become"],
        &["becomes"],
        &["becoming"],
        &["becomes"],
        &["because"],
        &["because"],
        &["vector"],
        &["vectors"],
        &["because"],
        &["because"],
        &["because"],
        &["because"],
        &["because"],
        &["because"],
        &["because"],
    ],
    range: 2..=8,
};

static WORD_BEB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BEB_CHILDREN),
    value: None,
};

pub static WORD_BEB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("efore"),
        dictgen::InsensitiveStr::Ascii("ongs"),
        dictgen::InsensitiveStr::Ascii("ore"),
    ],
    values: &[&["before"], &["belongs"], &["before"]],
    range: 3..=5,
};

static WORD_BEA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BEA_CHILDREN),
    value: None,
};

pub static WORD_BEA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("caon"),
        dictgen::InsensitiveStr::Ascii("cause"),
        dictgen::InsensitiveStr::Ascii("chead"),
        dictgen::InsensitiveStr::Ascii("cuoup"),
        dictgen::InsensitiveStr::Ascii("cuse"),
        dictgen::InsensitiveStr::Ascii("hvior"),
        dictgen::InsensitiveStr::Ascii("hviour"),
        dictgen::InsensitiveStr::Ascii("hviours"),
        dictgen::InsensitiveStr::Ascii("ltes"),
        dictgen::InsensitiveStr::Ascii("nches"),
        dictgen::InsensitiveStr::Ascii("on"),
        dictgen::InsensitiveStr::Ascii("rdude"),
        dictgen::InsensitiveStr::Ascii("rword"),
        dictgen::InsensitiveStr::Ascii("slty"),
        dictgen::InsensitiveStr::Ascii("stiality"),
        dictgen::InsensitiveStr::Ascii("stiaries"),
        dictgen::InsensitiveStr::Ascii("stiary"),
        dictgen::InsensitiveStr::Ascii("stley"),
        dictgen::InsensitiveStr::Ascii("tels"),
        dictgen::InsensitiveStr::Ascii("tiful"),
        dictgen::InsensitiveStr::Ascii("ucop"),
        dictgen::InsensitiveStr::Ascii("uitful"),
        dictgen::InsensitiveStr::Ascii("uquet"),
        dictgen::InsensitiveStr::Ascii("uquets"),
        dictgen::InsensitiveStr::Ascii("uracracy"),
        dictgen::InsensitiveStr::Ascii("uracratic"),
        dictgen::InsensitiveStr::Ascii("uracratical"),
        dictgen::InsensitiveStr::Ascii("uracratically"),
        dictgen::InsensitiveStr::Ascii("urocracy"),
        dictgen::InsensitiveStr::Ascii("urocratic"),
        dictgen::InsensitiveStr::Ascii("urocratical"),
        dictgen::InsensitiveStr::Ascii("urocratically"),
        dictgen::InsensitiveStr::Ascii("use"),
        dictgen::InsensitiveStr::Ascii("uti"),
        dictgen::InsensitiveStr::Ascii("utifull"),
        dictgen::InsensitiveStr::Ascii("utifullly"),
        dictgen::InsensitiveStr::Ascii("utifuly"),
        dictgen::InsensitiveStr::Ascii("utifyl"),
        dictgen::InsensitiveStr::Ascii("utilful"),
        dictgen::InsensitiveStr::Ascii("utiy"),
        dictgen::InsensitiveStr::Ascii("utyfied"),
        dictgen::InsensitiveStr::Ascii("utyfull"),
        dictgen::InsensitiveStr::Ascii("utyfully"),
        dictgen::InsensitiveStr::Ascii("vior"),
        dictgen::InsensitiveStr::Ascii("viour"),
    ],
    values: &[
        &["beacon"],
        &["because"],
        &["beachhead"],
        &["beaucoup"],
        &["because"],
        &["behavior"],
        &["behaviour"],
        &["behaviours"],
        &["beatles"],
        &["benches", "branches"],
        &["beacon"],
        &["bearded"],
        &["bareword"],
        &["beastly"],
        &["bestiality"],
        &["bestiaries"],
        &["bestiary"],
        &["beastly"],
        &["beatles"],
        &["beautiful"],
        &["beaucoup"],
        &["beautiful"],
        &["bouquet"],
        &["bouquets"],
        &["bureaucracy"],
        &["bureaucratic"],
        &["bureaucratic"],
        &["bureaucratically"],
        &["bureaucracy"],
        &["bureaucratic"],
        &["bureaucratic"],
        &["bureaucratically"],
        &["because"],
        &["beauty"],
        &["beautiful", "beautifully"],
        &["beautifully"],
        &["beautifully"],
        &["beautifully"],
        &["beautifully"],
        &["beauty"],
        &["beautified"],
        &["beautiful"],
        &["beautifully"],
        &["behavior"],
        &["behaviour"],
    ],
    range: 2..=13,
};

static WORD_BC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BC_CHILDREN),
    value: None,
};

pub static WORD_BC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ak"),
        dictgen::InsensitiveStr::Ascii("ause"),
        dictgen::InsensitiveStr::Ascii("euase"),
    ],
    values: &[&["back"], &["because"], &["because"]],
    range: 2..=5,
};

static WORD_BB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BB_CHILDREN),
    value: None,
};

pub static WORD_BB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("efore"),
        dictgen::InsensitiveStr::Ascii("oolean"),
        dictgen::InsensitiveStr::Ascii("ooleans"),
    ],
    values: &[&["before"], &["boolean"], &["booleans"]],
    range: 5..=7,
};

static WORD_BA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_BA_CHILDREN),
    value: Some(&["by", "be"]),
};

static WORD_BA_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_BAA_NODE),
    Some(&WORD_BAB_NODE),
    Some(&WORD_BAC_NODE),
    Some(&WORD_BAD_NODE),
    Some(&WORD_BAE_NODE),
    Some(&WORD_BAF_NODE),
    Some(&WORD_BAG_NODE),
    Some(&WORD_BAH_NODE),
    Some(&WORD_BAI_NODE),
    None,
    Some(&WORD_BAK_NODE),
    Some(&WORD_BAL_NODE),
    None,
    Some(&WORD_BAN_NODE),
    Some(&WORD_BAO_NODE),
    Some(&WORD_BAP_NODE),
    None,
    Some(&WORD_BAR_NODE),
    Some(&WORD_BAS_NODE),
    Some(&WORD_BAT_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_BAY_NODE),
    Some(&WORD_BAZ_NODE),
];

static WORD_BAZ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BAZ_CHILDREN),
    value: None,
};

pub static WORD_BAZ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("are"),
        dictgen::InsensitiveStr::Ascii("erk"),
    ],
    values: &[&["bazaar", "bizarre"], &["berserk"]],
    range: 3..=3,
};

static WORD_BAY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BAY_CHILDREN),
    value: None,
};

pub static WORD_BAY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("blon"),
        dictgen::InsensitiveStr::Ascii("ge"),
        dictgen::InsensitiveStr::Ascii("liwick"),
        dictgen::InsensitiveStr::Ascii("noet"),
        dictgen::InsensitiveStr::Ascii("oent"),
        dictgen::InsensitiveStr::Ascii("onent"),
    ],
    values: &[
        &["babylon"],
        &["beige"],
        &["bailiwick"],
        &["bayonet"],
        &["bayonet"],
        &["bayonet"],
    ],
    range: 2..=6,
};

static WORD_BAT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BAT_CHILDREN),
    value: None,
};

pub static WORD_BAT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("chleur"),
        dictgen::InsensitiveStr::Ascii("chleurs"),
        dictgen::InsensitiveStr::Ascii("eries"),
        dictgen::InsensitiveStr::Ascii("ery"),
        dictgen::InsensitiveStr::Ascii("hrom"),
        dictgen::InsensitiveStr::Ascii("hrooom"),
        dictgen::InsensitiveStr::Ascii("istia"),
        dictgen::InsensitiveStr::Ascii("itsa"),
        dictgen::InsensitiveStr::Ascii("limore"),
        dictgen::InsensitiveStr::Ascii("sita"),
        dictgen::InsensitiveStr::Ascii("tailon"),
        dictgen::InsensitiveStr::Ascii("talin"),
        dictgen::InsensitiveStr::Ascii("taries"),
        dictgen::InsensitiveStr::Ascii("tary"),
        dictgen::InsensitiveStr::Ascii("telfield"),
        dictgen::InsensitiveStr::Ascii("telfront"),
        dictgen::InsensitiveStr::Ascii("telship"),
        dictgen::InsensitiveStr::Ascii("telships"),
        dictgen::InsensitiveStr::Ascii("telstar"),
        dictgen::InsensitiveStr::Ascii("tey"),
        dictgen::InsensitiveStr::Ascii("tlaion"),
        dictgen::InsensitiveStr::Ascii("tlearts"),
        dictgen::InsensitiveStr::Ascii("tlechip"),
        dictgen::InsensitiveStr::Ascii("tlefeild"),
        dictgen::InsensitiveStr::Ascii("tlefied"),
        dictgen::InsensitiveStr::Ascii("tlefiend"),
        dictgen::InsensitiveStr::Ascii("tlefiled"),
        dictgen::InsensitiveStr::Ascii("tlefont"),
        dictgen::InsensitiveStr::Ascii("tlefornt"),
        dictgen::InsensitiveStr::Ascii("tlehips"),
        dictgen::InsensitiveStr::Ascii("tlehsips"),
        dictgen::InsensitiveStr::Ascii("tlesaur"),
        dictgen::InsensitiveStr::Ascii("tlescar"),
        dictgen::InsensitiveStr::Ascii("tleshop"),
        dictgen::InsensitiveStr::Ascii("tlestsr"),
    ],
    values: &[
        &["bachelor"],
        &["bachelors"],
        &["batteries"],
        &["battery"],
        &["bathroom"],
        &["bathroom"],
        &["batista"],
        &["batista"],
        &["baltimore"],
        &["batista"],
        &["battalion"],
        &["battalion"],
        &["batteries"],
        &["battery"],
        &["battlefield"],
        &["battlefront"],
        &["battleship"],
        &["battleship"],
        &["battlestar"],
        &["battery"],
        &["battalion"],
        &["battlestar"],
        &["battleship"],
        &["battlefield"],
        &["battlefield"],
        &["battlefield"],
        &["battlefield"],
        &["battlefront"],
        &["battlefront"],
        &["battleship"],
        &["battleship"],
        &["battlestar"],
        &["battlestar"],
        &["battleship"],
        &["battlestar"],
    ],
    range: 3..=8,
};

static WORD_BAS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BAS_CHILDREN),
    value: None,
};

pub static WORD_BAS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ci"),
        dictgen::InsensitiveStr::Ascii("cially"),
        dictgen::InsensitiveStr::Ascii("cily"),
        dictgen::InsensitiveStr::Ascii("cktrack"),
        dictgen::InsensitiveStr::Ascii("ektball"),
        dictgen::InsensitiveStr::Ascii("f"),
        dictgen::InsensitiveStr::Ascii("icallly"),
        dictgen::InsensitiveStr::Ascii("icaly"),
        dictgen::InsensitiveStr::Ascii("iclay"),
        dictgen::InsensitiveStr::Ascii("icley"),
        dictgen::InsensitiveStr::Ascii("icliy"),
        dictgen::InsensitiveStr::Ascii("iclly"),
        dictgen::InsensitiveStr::Ascii("icly"),
        dictgen::InsensitiveStr::Ascii("ilcy"),
        dictgen::InsensitiveStr::Ascii("iton"),
        dictgen::InsensitiveStr::Ascii("kteball"),
        dictgen::InsensitiveStr::Ascii("line"),
        dictgen::InsensitiveStr::Ascii("lines"),
        dictgen::InsensitiveStr::Ascii("nhee"),
        dictgen::InsensitiveStr::Ascii("sic"),
        dictgen::InsensitiveStr::Ascii("sically"),
        dictgen::InsensitiveStr::Ascii("tane"),
        dictgen::InsensitiveStr::Ascii("tardes"),
        dictgen::InsensitiveStr::Ascii("tardos"),
        dictgen::InsensitiveStr::Ascii("tardous"),
        dictgen::InsensitiveStr::Ascii("tardus"),
        dictgen::InsensitiveStr::Ascii("tars"),
        dictgen::InsensitiveStr::Ascii("tino"),
        dictgen::InsensitiveStr::Ascii("tract"),
        dictgen::InsensitiveStr::Ascii("tracted"),
        dictgen::InsensitiveStr::Ascii("tracter"),
        dictgen::InsensitiveStr::Ascii("tracting"),
        dictgen::InsensitiveStr::Ascii("traction"),
        dictgen::InsensitiveStr::Ascii("tractions"),
        dictgen::InsensitiveStr::Ascii("tractly"),
        dictgen::InsensitiveStr::Ascii("tractness"),
        dictgen::InsensitiveStr::Ascii("tractor"),
        dictgen::InsensitiveStr::Ascii("tracts"),
    ],
    values: &[
        &["basic"],
        &["basically"],
        &["basically"],
        &["backtrack"],
        &["basketball"],
        &["base"],
        &["basically"],
        &["basically"],
        &["basically"],
        &["basically"],
        &["basically"],
        &["basically"],
        &["basically"],
        &["basically"],
        &["bastion"],
        &["basketball"],
        &["baseline"],
        &["baselines"],
        &["banshee"],
        &["basic"],
        &["basically"],
        &["bastante"],
        &["bastards"],
        &["bastards"],
        &["bastards"],
        &["bastards"],
        &["bastards"],
        &["bastion"],
        &["abstract"],
        &["abstracted"],
        &["abstracter"],
        &["abstracting"],
        &["abstraction"],
        &["abstractions"],
        &["abstractly"],
        &["abstractness"],
        &["abstractor"],
        &["abstracts"],
    ],
    range: 1..=9,
};

static WORD_BAR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BAR_CHILDREN),
    value: None,
};

pub static WORD_BAR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("abrian"),
        dictgen::InsensitiveStr::Ascii("abrians"),
        dictgen::InsensitiveStr::Ascii("abric"),
        dictgen::InsensitiveStr::Ascii("aches"),
        dictgen::InsensitiveStr::Ascii("agin"),
        dictgen::InsensitiveStr::Ascii("ay"),
        dictgen::InsensitiveStr::Ascii("ays"),
        dictgen::InsensitiveStr::Ascii("barain"),
        dictgen::InsensitiveStr::Ascii("bariens"),
        dictgen::InsensitiveStr::Ascii("barin"),
        dictgen::InsensitiveStr::Ascii("barina"),
        dictgen::InsensitiveStr::Ascii("barions"),
        dictgen::InsensitiveStr::Ascii("baris"),
        dictgen::InsensitiveStr::Ascii("barisch"),
        dictgen::InsensitiveStr::Ascii("bedos"),
        dictgen::InsensitiveStr::Ascii("berians"),
        dictgen::InsensitiveStr::Ascii("celets"),
        dictgen::InsensitiveStr::Ascii("cleona"),
        dictgen::InsensitiveStr::Ascii("dford"),
        dictgen::InsensitiveStr::Ascii("eclona"),
        dictgen::InsensitiveStr::Ascii("gaing"),
        dictgen::InsensitiveStr::Ascii("gainning"),
        dictgen::InsensitiveStr::Ascii("gani"),
        dictgen::InsensitiveStr::Ascii("gian"),
        dictgen::InsensitiveStr::Ascii("gianing"),
        dictgen::InsensitiveStr::Ascii("gin"),
        dictgen::InsensitiveStr::Ascii("gins"),
        dictgen::InsensitiveStr::Ascii("iier"),
        dictgen::InsensitiveStr::Ascii("iner"),
        dictgen::InsensitiveStr::Ascii("istia"),
        dictgen::InsensitiveStr::Ascii("lkey"),
        dictgen::InsensitiveStr::Ascii("nch"),
        dictgen::InsensitiveStr::Ascii("nched"),
        dictgen::InsensitiveStr::Ascii("ncher"),
        dictgen::InsensitiveStr::Ascii("nchers"),
        dictgen::InsensitiveStr::Ascii("nches"),
        dictgen::InsensitiveStr::Ascii("nching"),
        dictgen::InsensitiveStr::Ascii("oke"),
        dictgen::InsensitiveStr::Ascii("rackus"),
        dictgen::InsensitiveStr::Ascii("racs"),
        dictgen::InsensitiveStr::Ascii("rakcs"),
        dictgen::InsensitiveStr::Ascii("rells"),
        dictgen::InsensitiveStr::Ascii("rer"),
        dictgen::InsensitiveStr::Ascii("riors"),
        dictgen::InsensitiveStr::Ascii("rles"),
        dictgen::InsensitiveStr::Ascii("rriers"),
        dictgen::InsensitiveStr::Ascii("sita"),
        dictgen::InsensitiveStr::Ascii("tendars"),
        dictgen::InsensitiveStr::Ascii("very"),
        dictgen::InsensitiveStr::Ascii("ycentic"),
    ],
    values: &[
        &["barbarian"],
        &["barbarians"],
        &["barbaric"],
        &["branches"],
        &["bargain"],
        &["beret"],
        &["berets"],
        &["barbarian"],
        &["barbarians"],
        &["barbarian"],
        &["barbarian"],
        &["barbarians"],
        &["barbarians"],
        &["barbaric"],
        &["barbados"],
        &["barbarians"],
        &["bracelets"],
        &["barcelona"],
        &["bradford"],
        &["barcelona"],
        &["bargaining"],
        &["bargaining"],
        &["bargain"],
        &["bargain"],
        &["bargaining"],
        &["bargain"],
        &["bargains"],
        &["barrier"],
        &["brainer"],
        &["barista"],
        &["barkley"],
        &["branch"],
        &["branched"],
        &["brancher"],
        &["branchers"],
        &["branches"],
        &["branching"],
        &["baroque"],
        &["barracks"],
        &["barracks"],
        &["barracks"],
        &["barrels"],
        &["barred", "barrel", "barren", "barrier"],
        &["barriers"],
        &["barrels"],
        &["barriers"],
        &["barista"],
        &["bartenders"],
        &["bravery"],
        &["barycentric"],
    ],
    range: 2..=8,
};

static WORD_BAP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BAP_CHILDREN),
    value: None,
};

pub static WORD_BAP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("tims"),
        dictgen::InsensitiveStr::Ascii("tisim"),
        dictgen::InsensitiveStr::Ascii("tsim"),
    ],
    values: &[&["baptism"], &["baptism"], &["baptism"]],
    range: 4..=5,
};

static WORD_BAO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BAO_CHILDREN),
    value: None,
};

pub static WORD_BAO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("rdwalk"),
        dictgen::InsensitiveStr::Ascii("ut"),
        dictgen::InsensitiveStr::Ascii("ynet"),
    ],
    values: &[&["boardwalk"], &["about", "bout"], &["bayonet"]],
    range: 2..=6,
};

static WORD_BAN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BAN_CHILDREN),
    value: None,
};

pub static WORD_BAN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("annas"),
        dictgen::InsensitiveStr::Ascii("ch"),
        dictgen::InsensitiveStr::Ascii("ched"),
        dictgen::InsensitiveStr::Ascii("ches"),
        dictgen::InsensitiveStr::Ascii("ditas"),
        dictgen::InsensitiveStr::Ascii("diwdth"),
        dictgen::InsensitiveStr::Ascii("dwagoon"),
        dictgen::InsensitiveStr::Ascii("dwdith"),
        dictgen::InsensitiveStr::Ascii("dwdiths"),
        dictgen::InsensitiveStr::Ascii("dwidht"),
        dictgen::InsensitiveStr::Ascii("dwidthm"),
        dictgen::InsensitiveStr::Ascii("dwitdh"),
        dictgen::InsensitiveStr::Ascii("dwith"),
        dictgen::InsensitiveStr::Ascii("galdesh"),
        dictgen::InsensitiveStr::Ascii("galdeshi"),
        dictgen::InsensitiveStr::Ascii("gkock"),
        dictgen::InsensitiveStr::Ascii("gladash"),
        dictgen::InsensitiveStr::Ascii("gladesch"),
        dictgen::InsensitiveStr::Ascii("gledash"),
        dictgen::InsensitiveStr::Ascii("gledesh"),
        dictgen::InsensitiveStr::Ascii("glidesh"),
        dictgen::InsensitiveStr::Ascii("gquit"),
        dictgen::InsensitiveStr::Ascii("gquits"),
        dictgen::InsensitiveStr::Ascii("hsee"),
        dictgen::InsensitiveStr::Ascii("kgok"),
        dictgen::InsensitiveStr::Ascii("krupcty"),
        dictgen::InsensitiveStr::Ascii("krupcy"),
        dictgen::InsensitiveStr::Ascii("kruptsy"),
        dictgen::InsensitiveStr::Ascii("krupty"),
        dictgen::InsensitiveStr::Ascii("krutpcy"),
        dictgen::InsensitiveStr::Ascii("lance"),
        dictgen::InsensitiveStr::Ascii("net"),
        dictgen::InsensitiveStr::Ascii("nets"),
        dictgen::InsensitiveStr::Ascii("ruptcy"),
    ],
    values: &[
        &["bananas"],
        &["bank", "branch", "bench"],
        &["branched", "benched"],
        &["branches", "benches"],
        &["bandits"],
        &["bandwidth"],
        &["bandwagon"],
        &["bandwidth"],
        &["bandwidths"],
        &["bandwidth"],
        &["bandwidth"],
        &["bandwidth"],
        &["bandwidth"],
        &["bangladesh"],
        &["bangladesh"],
        &["bangkok"],
        &["bangladesh"],
        &["bangladesh"],
        &["bangladesh"],
        &["bangladesh"],
        &["bangladesh"],
        &["banquet"],
        &["banquets"],
        &["banshee"],
        &["bangkok"],
        &["bankruptcy"],
        &["bankruptcy"],
        &["bankruptcy"],
        &["bankruptcy"],
        &["bankruptcy"],
        &["balance"],
        &["bayonet"],
        &["bayonets"],
        &["bankruptcy"],
    ],
    range: 2..=8,
};

static WORD_BAL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BAL_CHILDREN),
    value: None,
};

pub static WORD_BAL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("acing"),
        dictgen::InsensitiveStr::Ascii("anceada"),
        dictgen::InsensitiveStr::Ascii("anceado"),
        dictgen::InsensitiveStr::Ascii("anse"),
        dictgen::InsensitiveStr::Ascii("aster"),
        dictgen::InsensitiveStr::Ascii("asters"),
        dictgen::InsensitiveStr::Ascii("canes"),
        dictgen::InsensitiveStr::Ascii("ck"),
        dictgen::InsensitiveStr::Ascii("ckberry"),
        dictgen::InsensitiveStr::Ascii("cked"),
        dictgen::InsensitiveStr::Ascii("ckhawks"),
        dictgen::InsensitiveStr::Ascii("ckjack"),
        dictgen::InsensitiveStr::Ascii("cklist"),
        dictgen::InsensitiveStr::Ascii("cksmith"),
        dictgen::InsensitiveStr::Ascii("coney"),
        dictgen::InsensitiveStr::Ascii("conny"),
        dictgen::InsensitiveStr::Ascii("ence"),
        dictgen::InsensitiveStr::Ascii("itmore"),
        dictgen::InsensitiveStr::Ascii("lance"),
        dictgen::InsensitiveStr::Ascii("lances"),
        dictgen::InsensitiveStr::Ascii("lisitc"),
        dictgen::InsensitiveStr::Ascii("listc"),
        dictgen::InsensitiveStr::Ascii("lsitic"),
        dictgen::InsensitiveStr::Ascii("naced"),
        dictgen::InsensitiveStr::Ascii("ona"),
        dictgen::InsensitiveStr::Ascii("ony"),
        dictgen::InsensitiveStr::Ascii("oon"),
        dictgen::InsensitiveStr::Ascii("oons"),
        dictgen::InsensitiveStr::Ascii("se"),
        dictgen::InsensitiveStr::Ascii("sphemy"),
    ],
    values: &[
        &["balancing"],
        &["balanced"],
        &["balanced"],
        &["balances"],
        &["baluster"],
        &["balusters"],
        &["balances"],
        &["black", "balk"],
        &["blackberry"],
        &["blacked"],
        &["blackhawks"],
        &["blackjack"],
        &["blacklist"],
        &["blacksmith"],
        &["balcony"],
        &["balcony"],
        &["balance"],
        &["baltimore"],
        &["balance"],
        &["balances"],
        &["ballistic"],
        &["ballistic"],
        &["ballistic"],
        &["balanced"],
        &["bologna"],
        &["baloney", "bologna"],
        &["balloon"],
        &["balloons"],
        &["false"],
        &["blasphemy"],
    ],
    range: 2..=7,
};

static WORD_BAK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BAK_CHILDREN),
    value: None,
};

pub static WORD_BAK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("c"),
        dictgen::InsensitiveStr::Ascii("cers"),
        dictgen::InsensitiveStr::Ascii("crefs"),
        dictgen::InsensitiveStr::Ascii("end"),
        dictgen::InsensitiveStr::Ascii("ends"),
        dictgen::InsensitiveStr::Ascii("ground"),
        dictgen::InsensitiveStr::Ascii("grounds"),
        dictgen::InsensitiveStr::Ascii("setball"),
        dictgen::InsensitiveStr::Ascii("up"),
        dictgen::InsensitiveStr::Ascii("ups"),
        dictgen::InsensitiveStr::Ascii("ward"),
        dictgen::InsensitiveStr::Ascii("wards"),
    ],
    values: &[
        &["back"],
        &["backers"],
        &["backrefs"],
        &["backend", "baked"],
        &["backends"],
        &["background"],
        &["backgrounds"],
        &["basketball"],
        &["backup"],
        &["backups"],
        &["backward"],
        &["backwards"],
    ],
    range: 1..=7,
};

static WORD_BAI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BAI_CHILDREN),
    value: None,
};

pub static WORD_BAI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("sc"),
        dictgen::InsensitiveStr::Ascii("scly"),
        dictgen::InsensitiveStr::Ascii("sed"),
        dictgen::InsensitiveStr::Ascii("ses"),
    ],
    values: &[&["basic"], &["basically"], &["raised"], &["biases"]],
    range: 2..=4,
};

static WORD_BAH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BAH_CHILDREN),
    value: None,
};

pub static WORD_BAH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aving"),
        dictgen::InsensitiveStr::Ascii("avior"),
        dictgen::InsensitiveStr::Ascii("avioral"),
        dictgen::InsensitiveStr::Ascii("aviors"),
        dictgen::InsensitiveStr::Ascii("aviour"),
    ],
    values: &[
        &["behaving"],
        &["behavior"],
        &["behavioral"],
        &["behaviors"],
        &["behaviour"],
    ],
    range: 5..=7,
};

static WORD_BAG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BAG_CHILDREN),
    value: None,
};

pub static WORD_BAG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("ed"),
    ],
    values: &[&["bag"], &["badge", "bagged"]],
    range: 1..=2,
};

static WORD_BAF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BAF_CHILDREN),
    value: None,
};

pub static WORD_BAF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ore")],
    values: &[&["before"]],
    range: 3..=3,
};

static WORD_BAE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BAE_CHILDREN),
    value: None,
};

pub static WORD_BAE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("d")],
    values: &[&["based"]],
    range: 1..=1,
};

static WORD_BAD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BAD_CHILDREN),
    value: None,
};

pub static WORD_BAD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("mitten"),
        dictgen::InsensitiveStr::Ascii("nits"),
        dictgen::InsensitiveStr::Ascii("nwagon"),
        dictgen::InsensitiveStr::Ascii("nwidth"),
    ],
    values: &[&["badminton"], &["bandits"], &["bandwagon"], &["bandwidth"]],
    range: 4..=6,
};

static WORD_BAC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_BAC_CHILDREN),
    value: None,
};

static WORD_BAC_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_BACA_NODE),
    None,
    None,
    None,
    Some(&WORD_BACE_NODE),
    None,
    Some(&WORD_BACG_NODE),
    Some(&WORD_BACH_NODE),
    Some(&WORD_BACI_NODE),
    None,
    Some(&WORD_BACK_NODE),
    Some(&WORD_BACL_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_BACT_NODE),
    Some(&WORD_BACU_NODE),
    None,
    Some(&WORD_BACW_NODE),
    None,
    None,
    None,
];

static WORD_BACW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BACW_CHILDREN),
    value: None,
};

pub static WORD_BACW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ard"),
        dictgen::InsensitiveStr::Ascii("ards"),
    ],
    values: &[&["backward"], &["backwards"]],
    range: 3..=4,
};

static WORD_BACU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BACU_CHILDREN),
    value: None,
};

pub static WORD_BACU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("p")],
    values: &[&["backup"]],
    range: 1..=1,
};

static WORD_BACT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BACT_CHILDREN),
    value: None,
};

pub static WORD_BACT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("racking")],
    values: &[&["backtracking"]],
    range: 7..=7,
};

static WORD_BACL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BACL_CHILDREN),
    value: None,
};

pub static WORD_BACL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ony")],
    values: &[&["balcony"]],
    range: 3..=3,
};

static WORD_BACK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_BACK_CHILDREN),
    value: None,
};

static WORD_BACK_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_BACKA_NODE),
    Some(&WORD_BACKB_NODE),
    None,
    Some(&WORD_BACKD_NODE),
    Some(&WORD_BACKE_NODE),
    Some(&WORD_BACKF_NODE),
    Some(&WORD_BACKG_NODE),
    Some(&WORD_BACKH_NODE),
    None,
    Some(&WORD_BACKJ_NODE),
    None,
    Some(&WORD_BACKL_NODE),
    None,
    Some(&WORD_BACKN_NODE),
    Some(&WORD_BACKO_NODE),
    Some(&WORD_BACKP_NODE),
    None,
    Some(&WORD_BACKR_NODE),
    Some(&WORD_BACKS_NODE),
    Some(&WORD_BACKT_NODE),
    None,
    None,
    Some(&WORD_BACKW_NODE),
    None,
    None,
    None,
];

static WORD_BACKW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BACKW_CHILDREN),
    value: None,
};

pub static WORD_BACKW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ad"),
        dictgen::InsensitiveStr::Ascii("ardss"),
        dictgen::InsensitiveStr::Ascii("are"),
        dictgen::InsensitiveStr::Ascii("ark"),
        dictgen::InsensitiveStr::Ascii("ars"),
        dictgen::InsensitiveStr::Ascii("ord"),
        dictgen::InsensitiveStr::Ascii("rad"),
    ],
    values: &[
        &["backward"],
        &["backwards"],
        &["backward"],
        &["backward"],
        &["backward", "backwards"],
        &["backward"],
        &["backward"],
    ],
    range: 2..=5,
};

static WORD_BACKT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BACKT_CHILDREN),
    value: None,
};

pub static WORD_BACKT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("acking")],
    values: &[&["backpacking"]],
    range: 6..=6,
};

static WORD_BACKS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BACKS_CHILDREN),
    value: None,
};

pub static WORD_BACKS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("apce"),
        dictgen::InsensitiveStr::Ascii("lase"),
        dictgen::InsensitiveStr::Ascii("lases"),
        dictgen::InsensitiveStr::Ascii("lashs"),
        dictgen::InsensitiveStr::Ascii("ta"),
    ],
    values: &[
        &["backspace"],
        &["backslash"],
        &["backslashes"],
        &["backslashes"],
        &["backseat"],
    ],
    range: 2..=5,
};

static WORD_BACKR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BACKR_CHILDREN),
    value: None,
};

pub static WORD_BACKR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("efence"),
        dictgen::InsensitiveStr::Ascii("gound"),
        dictgen::InsensitiveStr::Ascii("gounds"),
        dictgen::InsensitiveStr::Ascii("ound"),
        dictgen::InsensitiveStr::Ascii("ounds"),
    ],
    values: &[
        &["backreference"],
        &["backgrounds", "background"],
        &["backgrounds"],
        &["background"],
        &["backgrounds"],
    ],
    range: 4..=6,
};

static WORD_BACKP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BACKP_CHILDREN),
    value: None,
};

pub static WORD_BACKP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("acing"),
        dictgen::InsensitiveStr::Ascii("ackng"),
        dictgen::InsensitiveStr::Ascii("acs"),
        dictgen::InsensitiveStr::Ascii("akcs"),
        dictgen::InsensitiveStr::Ascii("sace"),
    ],
    values: &[
        &["backpacking"],
        &["backpacking"],
        &["backpacks"],
        &["backpacks"],
        &["backspace"],
    ],
    range: 3..=5,
};

static WORD_BACKO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BACKO_CHILDREN),
    value: None,
};

pub static WORD_BACKO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("und"),
        dictgen::InsensitiveStr::Ascii("unds"),
    ],
    values: &[&["background"], &["backgrounds"]],
    range: 3..=4,
};

static WORD_BACKN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BACKN_CHILDREN),
    value: None,
};

pub static WORD_BACKN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("eds"),
    ],
    values: &[&["backend"], &["backends"]],
    range: 2..=3,
};

static WORD_BACKL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BACKL_CHILDREN),
    value: None,
};

pub static WORD_BACKL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ght"),
        dictgen::InsensitiveStr::Ascii("ghting"),
        dictgen::InsensitiveStr::Ascii("ghts"),
    ],
    values: &[&["backlight"], &["backlighting"], &["backlights"]],
    range: 3..=6,
};

static WORD_BACKJ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BACKJ_CHILDREN),
    value: None,
};

pub static WORD_BACKJ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("acking")],
    values: &[&["backpacking"]],
    range: 6..=6,
};

static WORD_BACKH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BACKH_CHILDREN),
    value: None,
};

pub static WORD_BACKH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("acking")],
    values: &[&["backpacking"]],
    range: 6..=6,
};

static WORD_BACKG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BACKG_CHILDREN),
    value: None,
};

pub static WORD_BACKG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("orund"),
        dictgen::InsensitiveStr::Ascii("orunds"),
        dictgen::InsensitiveStr::Ascii("ound"),
        dictgen::InsensitiveStr::Ascii("ounds"),
        dictgen::InsensitiveStr::Ascii("ournd"),
        dictgen::InsensitiveStr::Ascii("ournds"),
        dictgen::InsensitiveStr::Ascii("rond"),
        dictgen::InsensitiveStr::Ascii("ronds"),
        dictgen::InsensitiveStr::Ascii("roound"),
        dictgen::InsensitiveStr::Ascii("roounds"),
        dictgen::InsensitiveStr::Ascii("roud"),
        dictgen::InsensitiveStr::Ascii("roudn"),
        dictgen::InsensitiveStr::Ascii("roudns"),
        dictgen::InsensitiveStr::Ascii("rouds"),
        dictgen::InsensitiveStr::Ascii("roun"),
        dictgen::InsensitiveStr::Ascii("roung"),
        dictgen::InsensitiveStr::Ascii("roungs"),
        dictgen::InsensitiveStr::Ascii("rouns"),
        dictgen::InsensitiveStr::Ascii("rount"),
        dictgen::InsensitiveStr::Ascii("rounts"),
        dictgen::InsensitiveStr::Ascii("rouund"),
        dictgen::InsensitiveStr::Ascii("rund"),
        dictgen::InsensitiveStr::Ascii("runds"),
        dictgen::InsensitiveStr::Ascii("ruond"),
        dictgen::InsensitiveStr::Ascii("ruonds"),
    ],
    values: &[
        &["background"],
        &["backgrounds"],
        &["background"],
        &["backgrounds"],
        &["background"],
        &["backgrounds"],
        &["background"],
        &["backgrounds"],
        &["background"],
        &["backgrounds"],
        &["background"],
        &["backgrounds", "background"],
        &["backgrounds"],
        &["backgrounds"],
        &["background"],
        &["background"],
        &["backgrounds"],
        &["backgrounds"],
        &["background"],
        &["backgrounds"],
        &["background"],
        &["background"],
        &["backgrounds"],
        &["backgrounds", "background"],
        &["backgrounds"],
    ],
    range: 4..=7,
};

static WORD_BACKF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BACKF_CHILDREN),
    value: None,
};

pub static WORD_BACKF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eild"),
        dictgen::InsensitiveStr::Ascii("ied"),
        dictgen::InsensitiveStr::Ascii("iled"),
    ],
    values: &[&["backfield"], &["backfield"], &["backfield"]],
    range: 3..=4,
};

static WORD_BACKE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BACKE_CHILDREN),
    value: None,
};

pub static WORD_BACKE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ast"),
        dictgen::InsensitiveStr::Ascii("dn"),
        dictgen::InsensitiveStr::Ascii("dns"),
        dictgen::InsensitiveStr::Ascii("ned"),
        dictgen::InsensitiveStr::Ascii("neds"),
        dictgen::InsensitiveStr::Ascii("rds"),
        dictgen::InsensitiveStr::Ascii("ts"),
    ],
    values: &[
        &["backseat"],
        &["backend"],
        &["backends"],
        &["backend", "blackened"],
        &["backends", "blackens"],
        &["backers"],
        &["baskets", "brackets", "buckets"],
    ],
    range: 2..=4,
};

static WORD_BACKD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BACKD_CHILDREN),
    value: None,
};

pub static WORD_BACKD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ooor"),
        dictgen::InsensitiveStr::Ascii("or"),
    ],
    values: &[&["backdoor"], &["backdoor"]],
    range: 2..=4,
};

static WORD_BACKB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BACKB_CHILDREN),
    value: None,
};

pub static WORD_BACKB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("acking"),
        dictgen::InsensitiveStr::Ascii("round"),
        dictgen::InsensitiveStr::Ascii("rounds"),
    ],
    values: &[&["backpacking"], &["background"], &["backgrounds"]],
    range: 5..=6,
};

static WORD_BACKA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BACKA_CHILDREN),
    value: None,
};

pub static WORD_BACKA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("loriette"),
        dictgen::InsensitiveStr::Ascii("loriettes"),
        dictgen::InsensitiveStr::Ascii("rds"),
    ],
    values: &[&["baccalaureate"], &["baccalaureates"], &["backwards"]],
    range: 3..=9,
};

static WORD_BACI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BACI_CHILDREN),
    value: None,
};

pub static WORD_BACI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("c")],
    values: &[&["basic"]],
    range: 1..=1,
};

static WORD_BACH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BACH_CHILDREN),
    value: None,
};

pub static WORD_BACH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("elores"),
        dictgen::InsensitiveStr::Ascii("elour"),
        dictgen::InsensitiveStr::Ascii("leor"),
        dictgen::InsensitiveStr::Ascii("leors"),
        dictgen::InsensitiveStr::Ascii("ler"),
        dictgen::InsensitiveStr::Ascii("lers"),
        dictgen::InsensitiveStr::Ascii("oler"),
        dictgen::InsensitiveStr::Ascii("olers"),
    ],
    values: &[
        &["bachelors"],
        &["bachelor"],
        &["bachelor"],
        &["bachelors"],
        &["bachelor"],
        &["bachelors"],
        &["bachelor"],
        &["bachelors"],
    ],
    range: 3..=6,
};

static WORD_BACG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BACG_CHILDREN),
    value: None,
};

pub static WORD_BACG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("round")],
    values: &[&["background"]],
    range: 5..=5,
};

static WORD_BACE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BACE_CHILDREN),
    value: None,
};

pub static WORD_BACE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ause"),
        dictgen::InsensitiveStr::Ascii("hlor"),
        dictgen::InsensitiveStr::Ascii("hlors"),
    ],
    values: &[&["because"], &["bachelor"], &["bachelors"]],
    range: 4..=5,
};

static WORD_BACA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BACA_CHILDREN),
    value: None,
};

pub static WORD_BACA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("use")],
    values: &[&["because"]],
    range: 3..=3,
};

static WORD_BAB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BAB_CHILDREN),
    value: None,
};

pub static WORD_BAB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("le"),
        dictgen::InsensitiveStr::Ascii("lyon"),
        dictgen::InsensitiveStr::Ascii("ysister"),
        dictgen::InsensitiveStr::Ascii("ysite"),
        dictgen::InsensitiveStr::Ascii("ysiting"),
        dictgen::InsensitiveStr::Ascii("ysittng"),
        dictgen::InsensitiveStr::Ascii("ysittter"),
        dictgen::InsensitiveStr::Ascii("ysittting"),
    ],
    values: &[
        &["babel", "table", "bible"],
        &["babylon"],
        &["babysitter"],
        &["babysitter"],
        &["babysitting"],
        &["babysitting"],
        &["babysitter"],
        &["babysitting"],
    ],
    range: 2..=9,
};

static WORD_BAA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_BAA_CHILDREN),
    value: None,
};

pub static WORD_BAA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("se")],
    values: &[&["abase", "base"]],
    range: 2..=2,
};

static WORD_A_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_A_CHILDREN),
    value: None,
};

static WORD_A_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_AA_NODE),
    Some(&WORD_AB_NODE),
    Some(&WORD_AC_NODE),
    Some(&WORD_AD_NODE),
    Some(&WORD_AE_NODE),
    Some(&WORD_AF_NODE),
    Some(&WORD_AG_NODE),
    Some(&WORD_AH_NODE),
    Some(&WORD_AI_NODE),
    Some(&WORD_AJ_NODE),
    Some(&WORD_AK_NODE),
    Some(&WORD_AL_NODE),
    Some(&WORD_AM_NODE),
    Some(&WORD_AN_NODE),
    Some(&WORD_AO_NODE),
    Some(&WORD_AP_NODE),
    Some(&WORD_AQ_NODE),
    Some(&WORD_AR_NODE),
    Some(&WORD_AS_NODE),
    Some(&WORD_AT_NODE),
    Some(&WORD_AU_NODE),
    Some(&WORD_AV_NODE),
    Some(&WORD_AW_NODE),
    Some(&WORD_AX_NODE),
    Some(&WORD_AY_NODE),
    Some(&WORD_AZ_NODE),
];

static WORD_AZ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AZ_CHILDREN),
    value: None,
};

pub static WORD_AZ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ma"),
        dictgen::InsensitiveStr::Ascii("mith"),
        dictgen::InsensitiveStr::Ascii("miths"),
    ],
    values: &[&["asthma"], &["azimuth"], &["azimuths"]],
    range: 2..=5,
};

static WORD_AY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AY_CHILDREN),
    value: None,
};

pub static WORD_AY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("nchronous"),
        dictgen::InsensitiveStr::Ascii("snc"),
        dictgen::InsensitiveStr::Ascii("thing"),
        dictgen::InsensitiveStr::Ascii("way"),
        dictgen::InsensitiveStr::Ascii("ways"),
    ],
    values: &[
        &["asynchronous"],
        &["async"],
        &["anything"],
        &["anyway", "away"],
        &["always"],
    ],
    range: 3..=9,
};

static WORD_AX_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AX_CHILDREN),
    value: None,
};

pub static WORD_AX_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ises"),
        dictgen::InsensitiveStr::Ascii("issymmetric"),
        dictgen::InsensitiveStr::Ascii("ix"),
        dictgen::InsensitiveStr::Ascii("ixsymmetric"),
        dictgen::InsensitiveStr::Ascii("pressed"),
    ],
    values: &[
        &["axes"],
        &["axisymmetric"],
        &["axis"],
        &["axisymmetric"],
        &["expressed"],
    ],
    range: 2..=11,
};

static WORD_AW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AW_CHILDREN),
    value: None,
};

pub static WORD_AW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ailable"),
        dictgen::InsensitiveStr::Ascii("akend"),
        dictgen::InsensitiveStr::Ascii("akenend"),
        dictgen::InsensitiveStr::Ascii("ared"),
        dictgen::InsensitiveStr::Ascii("ays"),
        dictgen::InsensitiveStr::Ascii("eful"),
        dictgen::InsensitiveStr::Ascii("efully"),
        dictgen::InsensitiveStr::Ascii("ekened"),
        dictgen::InsensitiveStr::Ascii("esomeley"),
        dictgen::InsensitiveStr::Ascii("esomelly"),
        dictgen::InsensitiveStr::Ascii("esomenss"),
        dictgen::InsensitiveStr::Ascii("esomey"),
        dictgen::InsensitiveStr::Ascii("esomley"),
        dictgen::InsensitiveStr::Ascii("esoneness"),
        dictgen::InsensitiveStr::Ascii("fullly"),
        dictgen::InsensitiveStr::Ascii("kard"),
        dictgen::InsensitiveStr::Ascii("kawrdly"),
        dictgen::InsensitiveStr::Ascii("knowledged"),
        dictgen::InsensitiveStr::Ascii("knowledgement"),
        dictgen::InsensitiveStr::Ascii("knowledges"),
        dictgen::InsensitiveStr::Ascii("knowledging"),
        dictgen::InsensitiveStr::Ascii("kwardess"),
        dictgen::InsensitiveStr::Ascii("kwardsness"),
        dictgen::InsensitiveStr::Ascii("kwardy"),
        dictgen::InsensitiveStr::Ascii("ming"),
        dictgen::InsensitiveStr::Ascii("mings"),
        dictgen::InsensitiveStr::Ascii("nser"),
        dictgen::InsensitiveStr::Ascii("nsered"),
        dictgen::InsensitiveStr::Ascii("nsering"),
        dictgen::InsensitiveStr::Ascii("nsers"),
        dictgen::InsensitiveStr::Ascii("oid"),
        dictgen::InsensitiveStr::Ascii("rning"),
        dictgen::InsensitiveStr::Ascii("rnings"),
        dictgen::InsensitiveStr::Ascii("some"),
        dictgen::InsensitiveStr::Ascii("ya"),
    ],
    values: &[
        &["available"],
        &["awakened"],
        &["awakened"],
        &["awarded"],
        &["always", "away"],
        &["awful"],
        &["awfully"],
        &["weakened"],
        &["awesomely"],
        &["awesomely"],
        &["awesomeness"],
        &["awesomely"],
        &["awesomely"],
        &["awesomeness"],
        &["awfully"],
        &["awkward"],
        &["awkwardly"],
        &["acknowledged"],
        &["acknowledgement"],
        &["acknowledges"],
        &["acknowledging"],
        &["awkwardness"],
        &["awkwardness"],
        &["awkwardly"],
        &["awning"],
        &["awnings"],
        &["answer"],
        &["answered"],
        &["answering"],
        &["answers"],
        &["avoid"],
        &["awning", "warning"],
        &["warnings"],
        &["awesome"],
        &["away"],
    ],
    range: 2..=13,
};

static WORD_AV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_AV_CHILDREN),
    value: None,
};

static WORD_AV_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_AVA_NODE),
    None,
    Some(&WORD_AVC_NODE),
    Some(&WORD_AVD_NODE),
    Some(&WORD_AVE_NODE),
    None,
    Some(&WORD_AVG_NODE),
    None,
    Some(&WORD_AVI_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_AVN_NODE),
    Some(&WORD_AVO_NODE),
    None,
    None,
    Some(&WORD_AVR_NODE),
    None,
    Some(&WORD_AVT_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_AVT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AVT_CHILDREN),
    value: None,
};

pub static WORD_AVT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aars"),
        dictgen::InsensitiveStr::Ascii("ive"),
    ],
    values: &[&["avatars"], &["active"]],
    range: 3..=4,
};

static WORD_AVR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AVR_CHILDREN),
    value: None,
};

pub static WORD_AVR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("iable"),
        dictgen::InsensitiveStr::Ascii("iables"),
        dictgen::InsensitiveStr::Ascii("iant"),
        dictgen::InsensitiveStr::Ascii("iants"),
    ],
    values: &[&["variable"], &["variables"], &["variant"], &["variants"]],
    range: 4..=6,
};

static WORD_AVO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AVO_CHILDREN),
    value: None,
};

pub static WORD_AVO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("d"),
        dictgen::InsensitiveStr::Ascii("dacos"),
        dictgen::InsensitiveStr::Ascii("ded"),
        dictgen::InsensitiveStr::Ascii("ding"),
        dictgen::InsensitiveStr::Ascii("ds"),
        dictgen::InsensitiveStr::Ascii("idence"),
        dictgen::InsensitiveStr::Ascii("ind"),
        dictgen::InsensitiveStr::Ascii("inded"),
        dictgen::InsensitiveStr::Ascii("inding"),
        dictgen::InsensitiveStr::Ascii("inds"),
        dictgen::InsensitiveStr::Ascii("ud"),
        dictgen::InsensitiveStr::Ascii("ve"),
    ],
    values: &[
        &["avoid"],
        &["avocados"],
        &["avoided"],
        &["avoiding"],
        &["avoids"],
        &["avoidance"],
        &["avoid"],
        &["avoided"],
        &["avoiding"],
        &["avoids"],
        &["avoid"],
        &["above"],
    ],
    range: 1..=6,
};

static WORD_AVN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AVN_CHILDREN),
    value: None,
};

pub static WORD_AVN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("egers")],
    values: &[&["avengers"]],
    range: 5..=5,
};

static WORD_AVI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AVI_CHILDREN),
    value: None,
};

pub static WORD_AVI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("able"),
        dictgen::InsensitiveStr::Ascii("aiton"),
        dictgen::InsensitiveStr::Ascii("alability"),
        dictgen::InsensitiveStr::Ascii("alable"),
        dictgen::InsensitiveStr::Ascii("alible"),
        dictgen::InsensitiveStr::Ascii("lability"),
        dictgen::InsensitiveStr::Ascii("lable"),
        dictgen::InsensitiveStr::Ascii("od"),
        dictgen::InsensitiveStr::Ascii("oded"),
        dictgen::InsensitiveStr::Ascii("oding"),
        dictgen::InsensitiveStr::Ascii("ods"),
        dictgen::InsensitiveStr::Ascii("sories"),
        dictgen::InsensitiveStr::Ascii("soriy"),
        dictgen::InsensitiveStr::Ascii("soriyes"),
        dictgen::InsensitiveStr::Ascii("sory"),
    ],
    values: &[
        &["available"],
        &["aviation"],
        &["availability"],
        &["available"],
        &["available"],
        &["availability"],
        &["available"],
        &["avoid"],
        &["avoided"],
        &["avoiding"],
        &["avoids"],
        &["advisories"],
        &["advisory", "advisories"],
        &["advisories"],
        &["advisory"],
    ],
    range: 2..=9,
};

static WORD_AVG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AVG_CHILDREN),
    value: None,
};

pub static WORD_AVG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("erage")],
    values: &[&["average"]],
    range: 5..=5,
};

static WORD_AVE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AVE_CHILDREN),
    value: None,
};

pub static WORD_AVE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ngence"),
        dictgen::InsensitiveStr::Ascii("radge"),
        dictgen::InsensitiveStr::Ascii("rageadi"),
        dictgen::InsensitiveStr::Ascii("rageed"),
        dictgen::InsensitiveStr::Ascii("rageifs"),
        dictgen::InsensitiveStr::Ascii("ragine"),
        dictgen::InsensitiveStr::Ascii("rgaed"),
        dictgen::InsensitiveStr::Ascii("rgaes"),
        dictgen::InsensitiveStr::Ascii("rload"),
        dictgen::InsensitiveStr::Ascii("rloaded"),
        dictgen::InsensitiveStr::Ascii("rloads"),
        dictgen::InsensitiveStr::Ascii("rtising"),
    ],
    values: &[
        &["vengeance"],
        &["averaged"],
        &["averaged"],
        &["averaged"],
        &["averages"],
        &["averaging"],
        &["averaged"],
        &["averages"],
        &["overload"],
        &["overloaded"],
        &["overloads"],
        &["advertising"],
    ],
    range: 5..=7,
};

static WORD_AVD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AVD_CHILDREN),
    value: None,
};

pub static WORD_AVD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("isories"),
        dictgen::InsensitiveStr::Ascii("isoriy"),
        dictgen::InsensitiveStr::Ascii("isoriyes"),
        dictgen::InsensitiveStr::Ascii("isory"),
    ],
    values: &[
        &["advisories"],
        &["advisory", "advisories"],
        &["advisories"],
        &["advisory"],
    ],
    range: 5..=8,
};

static WORD_AVC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AVC_CHILDREN),
    value: None,
};

pub static WORD_AVC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("oid"),
        dictgen::InsensitiveStr::Ascii("oids"),
    ],
    values: &[&["avoid"], &["avoids"]],
    range: 3..=4,
};

static WORD_AVA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_AVA_CHILDREN),
    value: None,
};

static WORD_AVA_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    Some(&WORD_AVAC_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_AVAI_NODE),
    None,
    None,
    Some(&WORD_AVAL_NODE),
    None,
    Some(&WORD_AVAN_NODE),
    Some(&WORD_AVAO_NODE),
    None,
    None,
    Some(&WORD_AVAR_NODE),
    None,
    Some(&WORD_AVAT_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_AVAT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AVAT_CHILDREN),
    value: None,
};

pub static WORD_AVAT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aras"),
        dictgen::InsensitiveStr::Ascii("ards"),
        dictgen::InsensitiveStr::Ascii("ares"),
        dictgen::InsensitiveStr::Ascii("ion"),
    ],
    values: &[&["avatars"], &["avatars"], &["avatars"], &["aviation"]],
    range: 3..=4,
};

static WORD_AVAR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AVAR_CHILDREN),
    value: None,
};

pub static WORD_AVAR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("age"),
        dictgen::InsensitiveStr::Ascii("ageing"),
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("ege"),
        dictgen::InsensitiveStr::Ascii("y"),
    ],
    values: &[
        &["average"],
        &["averaging"],
        &["aware"],
        &["average"],
        &["every", "aviary"],
    ],
    range: 1..=6,
};

static WORD_AVAO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AVAO_CHILDREN),
    value: None,
};

pub static WORD_AVAO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("id"),
        dictgen::InsensitiveStr::Ascii("idable"),
        dictgen::InsensitiveStr::Ascii("ided"),
    ],
    values: &[&["avoid"], &["avoidable"], &["avoided"]],
    range: 2..=6,
};

static WORD_AVAN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AVAN_CHILDREN),
    value: None,
};

pub static WORD_AVAN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ce"),
        dictgen::InsensitiveStr::Ascii("ced"),
        dictgen::InsensitiveStr::Ascii("ces"),
        dictgen::InsensitiveStr::Ascii("cing"),
    ],
    values: &[&["advance"], &["advanced"], &["advances"], &["advancing"]],
    range: 2..=4,
};

static WORD_AVAL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AVAL_CHILDREN),
    value: None,
};

pub static WORD_AVAL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("able"),
        dictgen::InsensitiveStr::Ascii("aible"),
        dictgen::InsensitiveStr::Ascii("ance"),
        dictgen::InsensitiveStr::Ascii("iability"),
        dictgen::InsensitiveStr::Ascii("iable"),
        dictgen::InsensitiveStr::Ascii("ibale"),
        dictgen::InsensitiveStr::Ascii("ible"),
        dictgen::InsensitiveStr::Ascii("oable"),
        dictgen::InsensitiveStr::Ascii("uate"),
        dictgen::InsensitiveStr::Ascii("uated"),
        dictgen::InsensitiveStr::Ascii("uates"),
        dictgen::InsensitiveStr::Ascii("uating"),
    ],
    values: &[
        &["available"],
        &["available"],
        &["avalanche"],
        &["availability"],
        &["available"],
        &["available"],
        &["available"],
        &["available"],
        &["evaluate"],
        &["evaluated"],
        &["evaluates"],
        &["evaluating"],
    ],
    range: 4..=8,
};

static WORD_AVAI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_AVAI_CHILDREN),
    value: None,
};

static WORD_AVAI_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_AVAIA_NODE),
    Some(&WORD_AVAIB_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_AVAII_NODE),
    None,
    None,
    Some(&WORD_AVAIL_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_AVAIT_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_AVAIT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AVAIT_CHILDREN),
    value: None,
};

pub static WORD_AVAIT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ion")],
    values: &[&["aviation"]],
    range: 3..=3,
};

static WORD_AVAIL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AVAIL_CHILDREN),
    value: None,
};

pub static WORD_AVAIL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aable"),
        dictgen::InsensitiveStr::Ascii("abable"),
        dictgen::InsensitiveStr::Ascii("abal"),
        dictgen::InsensitiveStr::Ascii("abale"),
        dictgen::InsensitiveStr::Ascii("abality"),
        dictgen::InsensitiveStr::Ascii("abble"),
        dictgen::InsensitiveStr::Ascii("abe"),
        dictgen::InsensitiveStr::Ascii("abed"),
        dictgen::InsensitiveStr::Ascii("abel"),
        dictgen::InsensitiveStr::Ascii("abele"),
        dictgen::InsensitiveStr::Ascii("abelity"),
        dictgen::InsensitiveStr::Ascii("abiliy"),
        dictgen::InsensitiveStr::Ascii("abillity"),
        dictgen::InsensitiveStr::Ascii("abilty"),
        dictgen::InsensitiveStr::Ascii("abke"),
        dictgen::InsensitiveStr::Ascii("abl"),
        dictgen::InsensitiveStr::Ascii("abled"),
        dictgen::InsensitiveStr::Ascii("ablen"),
        dictgen::InsensitiveStr::Ascii("ablility"),
        dictgen::InsensitiveStr::Ascii("ablity"),
        dictgen::InsensitiveStr::Ascii("abyl"),
        dictgen::InsensitiveStr::Ascii("aiable"),
        dictgen::InsensitiveStr::Ascii("aibility"),
        dictgen::InsensitiveStr::Ascii("aible"),
        dictgen::InsensitiveStr::Ascii("ailability"),
        dictgen::InsensitiveStr::Ascii("aility"),
        dictgen::InsensitiveStr::Ascii("alable"),
        dictgen::InsensitiveStr::Ascii("albe"),
        dictgen::InsensitiveStr::Ascii("alble"),
        dictgen::InsensitiveStr::Ascii("ale"),
        dictgen::InsensitiveStr::Ascii("aliable"),
        dictgen::InsensitiveStr::Ascii("ality"),
        dictgen::InsensitiveStr::Ascii("anle"),
        dictgen::InsensitiveStr::Ascii("avble"),
        dictgen::InsensitiveStr::Ascii("avility"),
        dictgen::InsensitiveStr::Ascii("avle"),
        dictgen::InsensitiveStr::Ascii("bable"),
        dictgen::InsensitiveStr::Ascii("bale"),
        dictgen::InsensitiveStr::Ascii("be"),
        dictgen::InsensitiveStr::Ascii("ble"),
        dictgen::InsensitiveStr::Ascii("eable"),
        dictgen::InsensitiveStr::Ascii("ebilities"),
        dictgen::InsensitiveStr::Ascii("ebility"),
        dictgen::InsensitiveStr::Ascii("eble"),
        dictgen::InsensitiveStr::Ascii("iable"),
        dictgen::InsensitiveStr::Ascii("ibility"),
        dictgen::InsensitiveStr::Ascii("ibilty"),
        dictgen::InsensitiveStr::Ascii("ibity"),
        dictgen::InsensitiveStr::Ascii("ible"),
        dictgen::InsensitiveStr::Ascii("lable"),
    ],
    values: &[
        &["available"],
        &["available"],
        &["available"],
        &["available"],
        &["availability"],
        &["available"],
        &["available"],
        &["available"],
        &["available"],
        &["available"],
        &["availability"],
        &["availability"],
        &["availability"],
        &["availability"],
        &["available"],
        &["available"],
        &["available"],
        &["available"],
        &["availability"],
        &["availability"],
        &["available"],
        &["available"],
        &["availability"],
        &["available"],
        &["availability"],
        &["availability"],
        &["available"],
        &["available"],
        &["available"],
        &["available"],
        &["available"],
        &["availability"],
        &["available"],
        &["available"],
        &["availability"],
        &["available"],
        &["available"],
        &["available"],
        &["available"],
        &["available"],
        &["available"],
        &["availabilities"],
        &["availability"],
        &["available"],
        &["available"],
        &["availability"],
        &["availability"],
        &["availability"],
        &["available"],
        &["available"],
    ],
    range: 2..=10,
};

static WORD_AVAII_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AVAII_CHILDREN),
    value: None,
};

pub static WORD_AVAII_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ability"),
        dictgen::InsensitiveStr::Ascii("able"),
        dictgen::InsensitiveStr::Ascii("bility"),
        dictgen::InsensitiveStr::Ascii("ble"),
        dictgen::InsensitiveStr::Ascii("lable"),
    ],
    values: &[
        &["availability"],
        &["available"],
        &["availability"],
        &["available"],
        &["available"],
    ],
    range: 3..=7,
};

static WORD_AVAIB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AVAIB_CHILDREN),
    value: None,
};

pub static WORD_AVAIB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("lable"),
        dictgen::InsensitiveStr::Ascii("le"),
    ],
    values: &[&["available"], &["available"]],
    range: 2..=5,
};

static WORD_AVAIA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AVAIA_CHILDREN),
    value: None,
};

pub static WORD_AVAIA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ble"),
        dictgen::InsensitiveStr::Ascii("lable"),
        dictgen::InsensitiveStr::Ascii("lbale"),
        dictgen::InsensitiveStr::Ascii("lbe"),
        dictgen::InsensitiveStr::Ascii("lbel"),
        dictgen::InsensitiveStr::Ascii("lbility"),
        dictgen::InsensitiveStr::Ascii("lble"),
    ],
    values: &[
        &["available"],
        &["available"],
        &["available"],
        &["available"],
        &["available"],
        &["availability"],
        &["available"],
    ],
    range: 3..=7,
};

static WORD_AVAC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AVAC_CHILDREN),
    value: None,
};

pub static WORD_AVAC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ado"),
        dictgen::InsensitiveStr::Ascii("ados"),
        dictgen::InsensitiveStr::Ascii("odos"),
    ],
    values: &[&["avocado"], &["avocados"], &["avocados"]],
    range: 3..=4,
};

static WORD_AU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_AU_CHILDREN),
    value: None,
};

static WORD_AU_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    Some(&WORD_AUC_NODE),
    Some(&WORD_AUD_NODE),
    None,
    Some(&WORD_AUF_NODE),
    Some(&WORD_AUG_NODE),
    Some(&WORD_AUH_NODE),
    Some(&WORD_AUI_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_AUN_NODE),
    Some(&WORD_AUO_NODE),
    None,
    None,
    Some(&WORD_AUR_NODE),
    Some(&WORD_AUS_NODE),
    Some(&WORD_AUT_NODE),
    None,
    None,
    None,
    Some(&WORD_AUX_NODE),
    None,
    None,
];

static WORD_AUX_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AUX_CHILDREN),
    value: None,
};

pub static WORD_AUX_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ialiary"),
        dictgen::InsensitiveStr::Ascii("ilaries"),
        dictgen::InsensitiveStr::Ascii("ilary"),
        dictgen::InsensitiveStr::Ascii("ileries"),
        dictgen::InsensitiveStr::Ascii("ilery"),
        dictgen::InsensitiveStr::Ascii("iliar"),
        dictgen::InsensitiveStr::Ascii("illaries"),
        dictgen::InsensitiveStr::Ascii("illary"),
        dictgen::InsensitiveStr::Ascii("illeries"),
        dictgen::InsensitiveStr::Ascii("illery"),
        dictgen::InsensitiveStr::Ascii("illiaries"),
        dictgen::InsensitiveStr::Ascii("illiary"),
        dictgen::InsensitiveStr::Ascii("iluary"),
        dictgen::InsensitiveStr::Ascii("liliary"),
    ],
    values: &[
        &["auxiliary"],
        &["auxiliaries"],
        &["auxiliary"],
        &["auxiliaries"],
        &["auxiliary"],
        &["auxiliary"],
        &["auxiliaries"],
        &["auxiliary"],
        &["auxiliaries"],
        &["auxiliary"],
        &["auxiliaries"],
        &["auxiliary"],
        &["auxiliary"],
        &["auxiliary"],
    ],
    range: 5..=9,
};

static WORD_AUT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_AUT_CHILDREN),
    value: None,
};

static WORD_AUT_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_AUTA_NODE),
    None,
    Some(&WORD_AUTC_NODE),
    None,
    Some(&WORD_AUTE_NODE),
    None,
    None,
    Some(&WORD_AUTH_NODE),
    Some(&WORD_AUTI_NODE),
    None,
    None,
    None,
    Some(&WORD_AUTM_NODE),
    None,
    Some(&WORD_AUTO_NODE),
    None,
    None,
    None,
    Some(&WORD_AUTS_NODE),
    Some(&WORD_AUTT_NODE),
    Some(&WORD_AUTU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_AUTU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AUTU_CHILDREN),
    value: None,
};

pub static WORD_AUTU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("m")],
    values: &[&["autumn"]],
    range: 1..=1,
};

static WORD_AUTT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AUTT_CHILDREN),
    value: None,
};

pub static WORD_AUTT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("oatack")],
    values: &[&["autoattack"]],
    range: 6..=6,
};

static WORD_AUTS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AUTS_CHILDREN),
    value: None,
};

pub static WORD_AUTS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("itic")],
    values: &[&["autistic"]],
    range: 4..=4,
};

static WORD_AUTO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_AUTO_CHILDREN),
    value: None,
};

static WORD_AUTO_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_AUTOA_NODE),
    None,
    Some(&WORD_AUTOC_NODE),
    Some(&WORD_AUTOD_NODE),
    Some(&WORD_AUTOE_NODE),
    Some(&WORD_AUTOF_NODE),
    Some(&WORD_AUTOG_NODE),
    Some(&WORD_AUTOH_NODE),
    Some(&WORD_AUTOI_NODE),
    None,
    Some(&WORD_AUTOK_NODE),
    Some(&WORD_AUTOL_NODE),
    Some(&WORD_AUTOM_NODE),
    Some(&WORD_AUTON_NODE),
    Some(&WORD_AUTOO_NODE),
    Some(&WORD_AUTOP_NODE),
    None,
    Some(&WORD_AUTOR_NODE),
    Some(&WORD_AUTOS_NODE),
    Some(&WORD_AUTOT_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_AUTOT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AUTOT_CHILDREN),
    value: None,
};

pub static WORD_AUTOT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("orium"),
        dictgen::InsensitiveStr::Ascii("oriums"),
    ],
    values: &[&["auditorium"], &["auditoriums"]],
    range: 5..=6,
};

static WORD_AUTOS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AUTOS_CHILDREN),
    value: None,
};

pub static WORD_AUTOS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ae"),
        dictgen::InsensitiveStr::Ascii("avegs"),
        dictgen::InsensitiveStr::Ascii("aveperodical"),
        dictgen::InsensitiveStr::Ascii("ence"),
    ],
    values: &[
        &["autosave"],
        &["autosaves"],
        &["autosaveperiodical"],
        &["autosense"],
    ],
    range: 2..=12,
};

static WORD_AUTOR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AUTOR_CHILDREN),
    value: Some(&["author"]),
};

pub static WORD_AUTOR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ealease"),
        dictgen::InsensitiveStr::Ascii("isation"),
        dictgen::InsensitiveStr::Ascii("itative"),
        dictgen::InsensitiveStr::Ascii("itharian"),
        dictgen::InsensitiveStr::Ascii("ity"),
        dictgen::InsensitiveStr::Ascii("ization"),
        dictgen::InsensitiveStr::Ascii("opeat"),
        dictgen::InsensitiveStr::Ascii("s"),
    ],
    values: &[
        &["autorelease"],
        &["authorisation"],
        &["authoritative"],
        &["authoritarian"],
        &["authority"],
        &["authorization"],
        &["autorepeat"],
        &["authors"],
    ],
    range: 1..=8,
};

static WORD_AUTOP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AUTOP_CHILDREN),
    value: None,
};

pub static WORD_AUTOP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("sec")],
    values: &[&["autospec"]],
    range: 3..=3,
};

static WORD_AUTOO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AUTOO_CHILDREN),
    value: None,
};

pub static WORD_AUTOO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("nf")],
    values: &[&["autoconf"]],
    range: 2..=2,
};

static WORD_AUTON_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AUTON_CHILDREN),
    value: None,
};

pub static WORD_AUTON_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("agotiation"),
        dictgen::InsensitiveStr::Ascii("amous"),
        dictgen::InsensitiveStr::Ascii("ation"),
        dictgen::InsensitiveStr::Ascii("egatiotiation"),
        dictgen::InsensitiveStr::Ascii("egatiotiations"),
        dictgen::InsensitiveStr::Ascii("egoatiation"),
        dictgen::InsensitiveStr::Ascii("egoatiations"),
        dictgen::InsensitiveStr::Ascii("egoation"),
        dictgen::InsensitiveStr::Ascii("egoations"),
        dictgen::InsensitiveStr::Ascii("egociated"),
        dictgen::InsensitiveStr::Ascii("egociation"),
        dictgen::InsensitiveStr::Ascii("egociations"),
        dictgen::InsensitiveStr::Ascii("egogtiation"),
        dictgen::InsensitiveStr::Ascii("egogtiations"),
        dictgen::InsensitiveStr::Ascii("egoitation"),
        dictgen::InsensitiveStr::Ascii("egoitations"),
        dictgen::InsensitiveStr::Ascii("egoptionsotiation"),
        dictgen::InsensitiveStr::Ascii("egoptionsotiations"),
        dictgen::InsensitiveStr::Ascii("egosiation"),
        dictgen::InsensitiveStr::Ascii("egosiations"),
        dictgen::InsensitiveStr::Ascii("egotaiation"),
        dictgen::InsensitiveStr::Ascii("egotaiations"),
        dictgen::InsensitiveStr::Ascii("egotaition"),
        dictgen::InsensitiveStr::Ascii("egotaitions"),
        dictgen::InsensitiveStr::Ascii("egotatiation"),
        dictgen::InsensitiveStr::Ascii("egotatiations"),
        dictgen::InsensitiveStr::Ascii("egotation"),
        dictgen::InsensitiveStr::Ascii("egotations"),
        dictgen::InsensitiveStr::Ascii("egothiation"),
        dictgen::InsensitiveStr::Ascii("egothiations"),
        dictgen::InsensitiveStr::Ascii("egotication"),
        dictgen::InsensitiveStr::Ascii("egotications"),
        dictgen::InsensitiveStr::Ascii("egotioation"),
        dictgen::InsensitiveStr::Ascii("egotioations"),
        dictgen::InsensitiveStr::Ascii("egotion"),
        dictgen::InsensitiveStr::Ascii("egotionation"),
        dictgen::InsensitiveStr::Ascii("egotionations"),
        dictgen::InsensitiveStr::Ascii("egotions"),
        dictgen::InsensitiveStr::Ascii("egotiotation"),
        dictgen::InsensitiveStr::Ascii("egotiotations"),
        dictgen::InsensitiveStr::Ascii("egotitaion"),
        dictgen::InsensitiveStr::Ascii("egotitaions"),
        dictgen::InsensitiveStr::Ascii("egotitation"),
        dictgen::InsensitiveStr::Ascii("egotitations"),
        dictgen::InsensitiveStr::Ascii("egotition"),
        dictgen::InsensitiveStr::Ascii("egotitions"),
        dictgen::InsensitiveStr::Ascii("egoziation"),
        dictgen::InsensitiveStr::Ascii("egoziations"),
        dictgen::InsensitiveStr::Ascii("eogotiation"),
        dictgen::InsensitiveStr::Ascii("eotiation"),
        dictgen::InsensitiveStr::Ascii("imous"),
        dictgen::InsensitiveStr::Ascii("ogotiation"),
        dictgen::InsensitiveStr::Ascii("omity"),
        dictgen::InsensitiveStr::Ascii("omos"),
        dictgen::InsensitiveStr::Ascii("onous"),
        dictgen::InsensitiveStr::Ascii("ymous"),
    ],
    values: &[
        &["autonegotiation"],
        &["autonomous"],
        &["automation"],
        &["autonegotiation"],
        &["autonegotiations"],
        &["autonegotiation"],
        &["autonegotiations"],
        &["autonegotiation"],
        &["autonegotiations"],
        &["autonegotiated"],
        &["autonegotiation"],
        &["autonegotiations"],
        &["autonegotiation"],
        &["autonegotiations"],
        &["autonegotiation"],
        &["autonegotiations"],
        &["autonegotiation"],
        &["autonegotiations"],
        &["autonegotiation"],
        &["autonegotiations"],
        &["autonegotiation"],
        &["autonegotiations"],
        &["autonegotiation"],
        &["autonegotiations"],
        &["autonegotiation"],
        &["autonegotiations"],
        &["autonegotiation"],
        &["autonegotiations"],
        &["autonegotiation"],
        &["autonegotiations"],
        &["autonegotiation"],
        &["autonegotiations"],
        &["autonegotiation"],
        &["autonegotiations"],
        &["autonegotiation"],
        &["autonegotiation"],
        &["autonegotiations"],
        &["autonegotiations"],
        &["autonegotiation"],
        &["autonegotiations"],
        &["autonegotiation"],
        &["autonegotiations"],
        &["autonegotiation"],
        &["autonegotiations"],
        &["autonegotiation"],
        &["autonegotiations"],
        &["autonegotiation"],
        &["autonegotiations"],
        &["autonegotiation"],
        &["autonegotiation"],
        &["autonomous"],
        &["autonegotiation"],
        &["autonomy"],
        &["autonomous"],
        &["autonomous"],
        &["autonomous"],
    ],
    range: 4..=18,
};

static WORD_AUTOM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AUTOM_CHILDREN),
    value: None,
};

pub static WORD_AUTOM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aatically"),
        dictgen::InsensitiveStr::Ascii("agicaly"),
        dictgen::InsensitiveStr::Ascii("aitc"),
        dictgen::InsensitiveStr::Ascii("aitcally"),
        dictgen::InsensitiveStr::Ascii("anifactured"),
        dictgen::InsensitiveStr::Ascii("atcally"),
        dictgen::InsensitiveStr::Ascii("atcially"),
        dictgen::InsensitiveStr::Ascii("atially"),
        dictgen::InsensitiveStr::Ascii("atical"),
        dictgen::InsensitiveStr::Ascii("aticall"),
        dictgen::InsensitiveStr::Ascii("aticallly"),
        dictgen::InsensitiveStr::Ascii("aticaly"),
        dictgen::InsensitiveStr::Ascii("aticalyl"),
        dictgen::InsensitiveStr::Ascii("aticalyy"),
        dictgen::InsensitiveStr::Ascii("atice"),
        dictgen::InsensitiveStr::Ascii("aticlly"),
        dictgen::InsensitiveStr::Ascii("aticly"),
        dictgen::InsensitiveStr::Ascii("atico"),
        dictgen::InsensitiveStr::Ascii("atied"),
        dictgen::InsensitiveStr::Ascii("atiek"),
        dictgen::InsensitiveStr::Ascii("ato"),
        dictgen::InsensitiveStr::Ascii("atonic"),
        dictgen::InsensitiveStr::Ascii("atron"),
        dictgen::InsensitiveStr::Ascii("atted"),
        dictgen::InsensitiveStr::Ascii("atycally"),
        dictgen::InsensitiveStr::Ascii("etic"),
        dictgen::InsensitiveStr::Ascii("etically"),
        dictgen::InsensitiveStr::Ascii("ibile"),
        dictgen::InsensitiveStr::Ascii("ic"),
        dictgen::InsensitiveStr::Ascii("ical"),
        dictgen::InsensitiveStr::Ascii("ically"),
        dictgen::InsensitiveStr::Ascii("icaly"),
        dictgen::InsensitiveStr::Ascii("icatilly"),
        dictgen::InsensitiveStr::Ascii("iclly"),
        dictgen::InsensitiveStr::Ascii("icly"),
        dictgen::InsensitiveStr::Ascii("itive"),
        dictgen::InsensitiveStr::Ascii("obilies"),
        dictgen::InsensitiveStr::Ascii("oblie"),
        dictgen::InsensitiveStr::Ascii("oblies"),
        dictgen::InsensitiveStr::Ascii("oderador"),
        dictgen::InsensitiveStr::Ascii("oderater"),
        dictgen::InsensitiveStr::Ascii("odertor"),
        dictgen::InsensitiveStr::Ascii("odorator"),
        dictgen::InsensitiveStr::Ascii("omous"),
        dictgen::InsensitiveStr::Ascii("onomous"),
        dictgen::InsensitiveStr::Ascii("onous"),
        dictgen::InsensitiveStr::Ascii("ony"),
        dictgen::InsensitiveStr::Ascii("oterator"),
        dictgen::InsensitiveStr::Ascii("otice"),
        dictgen::InsensitiveStr::Ascii("otion"),
        dictgen::InsensitiveStr::Ascii("otize"),
        dictgen::InsensitiveStr::Ascii("otove"),
        dictgen::InsensitiveStr::Ascii("tic"),
        dictgen::InsensitiveStr::Ascii("tically"),
    ],
    values: &[
        &["automatically"],
        &["automagically"],
        &["automatic"],
        &["automatically"],
        &["automanufactured"],
        &["automatically"],
        &["automatically"],
        &["automatically"],
        &["automatically", "automatic", "automated"],
        &["automatically", "automatic"],
        &["automatically"],
        &["automatically"],
        &["automatically"],
        &["automatically"],
        &["automate"],
        &["automatically"],
        &["automatically"],
        &["automation"],
        &["automate"],
        &["automate"],
        &["automation"],
        &["automation"],
        &["automation"],
        &["automate"],
        &["automatically"],
        &["automatic"],
        &["automatically"],
        &["automobile"],
        &["atomic", "automatic"],
        &["automatic"],
        &["automatically"],
        &["automatically"],
        &["automatically"],
        &["automatically"],
        &["automatically"],
        &["automotive"],
        &["automobile"],
        &["automobile"],
        &["automobile"],
        &["automoderator"],
        &["automoderator"],
        &["automoderator"],
        &["automoderator"],
        &["autonomous"],
        &["autonomous"],
        &["autonomous"],
        &["autonomy"],
        &["automoderator"],
        &["automotive"],
        &["automation"],
        &["automotive"],
        &["automotive"],
        &["automatic"],
        &["automatically"],
    ],
    range: 2..=11,
};

static WORD_AUTOL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AUTOL_CHILDREN),
    value: None,
};

pub static WORD_AUTOL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("aod")],
    values: &[&["autoload"]],
    range: 3..=3,
};

static WORD_AUTOK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AUTOK_CHILDREN),
    value: None,
};

pub static WORD_AUTOK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("orrect")],
    values: &[&["autocorrect"]],
    range: 6..=6,
};

static WORD_AUTOI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AUTOI_CHILDREN),
    value: None,
};

pub static WORD_AUTOI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ncrememnt"),
        dictgen::InsensitiveStr::Ascii("ncrementive"),
    ],
    values: &[&["autoincrement"], &["autoincrement"]],
    range: 9..=11,
};

static WORD_AUTOH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AUTOH_CHILDREN),
    value: None,
};

pub static WORD_AUTOH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("orized")],
    values: &[&["authorized"]],
    range: 6..=6,
};

static WORD_AUTOG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AUTOG_CHILDREN),
    value: None,
};

pub static WORD_AUTOG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("enrated"),
        dictgen::InsensitiveStr::Ascii("enratet"),
        dictgen::InsensitiveStr::Ascii("enration"),
        dictgen::InsensitiveStr::Ascii("rah"),
        dictgen::InsensitiveStr::Ascii("rapgh"),
        dictgen::InsensitiveStr::Ascii("roping"),
        dictgen::InsensitiveStr::Ascii("rpah"),
    ],
    values: &[
        &["autogenerated"],
        &["autogenerated"],
        &["autogeneration"],
        &["autograph"],
        &["autograph"],
        &["autogrouping"],
        &["autograph"],
    ],
    range: 3..=8,
};

static WORD_AUTOF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AUTOF_CHILDREN),
    value: None,
};

pub static WORD_AUTOF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ilt"),
        dictgen::InsensitiveStr::Ascii("omat"),
        dictgen::InsensitiveStr::Ascii("ormating"),
    ],
    values: &[&["autofilter"], &["autoformat"], &["autoformatting"]],
    range: 3..=8,
};

static WORD_AUTOE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AUTOE_CHILDREN),
    value: None,
};

pub static WORD_AUTOE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("select")],
    values: &[&["autoselect"]],
    range: 6..=6,
};

static WORD_AUTOD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AUTOD_CHILDREN),
    value: None,
};

pub static WORD_AUTOD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ected"),
        dictgen::InsensitiveStr::Ascii("ection"),
    ],
    values: &[&["autodetected"], &["autodetection"]],
    range: 5..=6,
};

static WORD_AUTOC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AUTOC_CHILDREN),
    value: None,
};

pub static WORD_AUTOC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("htonous"),
        dictgen::InsensitiveStr::Ascii("mplete"),
        dictgen::InsensitiveStr::Ascii("mpleted"),
        dictgen::InsensitiveStr::Ascii("mpletes"),
        dictgen::InsensitiveStr::Ascii("mpleting"),
        dictgen::InsensitiveStr::Ascii("ommiting"),
        dictgen::InsensitiveStr::Ascii("onplete"),
        dictgen::InsensitiveStr::Ascii("onpleted"),
        dictgen::InsensitiveStr::Ascii("onpletes"),
        dictgen::InsensitiveStr::Ascii("onpleting"),
        dictgen::InsensitiveStr::Ascii("onpletion"),
        dictgen::InsensitiveStr::Ascii("oomit"),
        dictgen::InsensitiveStr::Ascii("oplete"),
        dictgen::InsensitiveStr::Ascii("orect"),
        dictgen::InsensitiveStr::Ascii("oreect"),
        dictgen::InsensitiveStr::Ascii("orrct"),
        dictgen::InsensitiveStr::Ascii("orrekt"),
        dictgen::InsensitiveStr::Ascii("orrent"),
        dictgen::InsensitiveStr::Ascii("orret"),
        dictgen::InsensitiveStr::Ascii("orrext"),
        dictgen::InsensitiveStr::Ascii("orrrect"),
        dictgen::InsensitiveStr::Ascii("tonous"),
    ],
    values: &[
        &["autochthonous"],
        &["autocomplete"],
        &["autocompleted"],
        &["autocompletes"],
        &["autocompleting"],
        &["autocommitting"],
        &["autocomplete"],
        &["autocompleted"],
        &["autocompletes"],
        &["autocompleting"],
        &["autocompletion"],
        &["autocommit"],
        &["autocomplete"],
        &["autocorrect"],
        &["autocorrect"],
        &["autocorrect"],
        &["autocorrect"],
        &["autocorrect"],
        &["autocorrect"],
        &["autocorrect"],
        &["autocorrect"],
        &["autochthonous"],
    ],
    range: 5..=9,
};

static WORD_AUTOA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AUTOA_CHILDREN),
    value: None,
};

pub static WORD_AUTOA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("mtically"),
        dictgen::InsensitiveStr::Ascii("ttak"),
        dictgen::InsensitiveStr::Ascii("ttaks"),
        dictgen::InsensitiveStr::Ascii("ttk"),
        dictgen::InsensitiveStr::Ascii("tttack"),
    ],
    values: &[
        &["automatically"],
        &["autoattack"],
        &["autoattack"],
        &["autoattack"],
        &["autoattack"],
    ],
    range: 3..=8,
};

static WORD_AUTM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AUTM_CHILDREN),
    value: None,
};

pub static WORD_AUTM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("atically")],
    values: &[&["automatically"]],
    range: 8..=8,
};

static WORD_AUTI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AUTI_CHILDREN),
    value: None,
};

pub static WORD_AUTI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("matic"),
        dictgen::InsensitiveStr::Ascii("matically"),
        dictgen::InsensitiveStr::Ascii("o"),
        dictgen::InsensitiveStr::Ascii("sitc"),
        dictgen::InsensitiveStr::Ascii("stc"),
        dictgen::InsensitiveStr::Ascii("stisch"),
    ],
    values: &[
        &["automatic"],
        &["automatically"],
        &["audio"],
        &["autistic"],
        &["autistic"],
        &["autistic"],
    ],
    range: 1..=9,
};

static WORD_AUTH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_AUTH_CHILDREN),
    value: None,
};

static WORD_AUTH_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    None,
    None,
    Some(&WORD_AUTHE_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_AUTHO_NODE),
    None,
    None,
    Some(&WORD_AUTHR_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_AUTHR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AUTHR_CHILDREN),
    value: None,
};

pub static WORD_AUTHR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("oity"),
        dictgen::InsensitiveStr::Ascii("oization"),
        dictgen::InsensitiveStr::Ascii("oized"),
        dictgen::InsensitiveStr::Ascii("or"),
        dictgen::InsensitiveStr::Ascii("ored"),
        dictgen::InsensitiveStr::Ascii("orisation"),
        dictgen::InsensitiveStr::Ascii("orities"),
        dictgen::InsensitiveStr::Ascii("orization"),
        dictgen::InsensitiveStr::Ascii("ors"),
    ],
    values: &[
        &["authority"],
        &["authorization"],
        &["authorized"],
        &["author"],
        &["authored"],
        &["authorisation"],
        &["authorities"],
        &["authorization"],
        &["authors"],
    ],
    range: 2..=9,
};

static WORD_AUTHO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AUTHO_CHILDREN),
    value: None,
};

pub static WORD_AUTHO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("biographic"),
        dictgen::InsensitiveStr::Ascii("biography"),
        dictgen::InsensitiveStr::Ascii("er"),
        dictgen::InsensitiveStr::Ascii("ratative"),
        dictgen::InsensitiveStr::Ascii("ratatively"),
        dictgen::InsensitiveStr::Ascii("ratitative"),
        dictgen::InsensitiveStr::Ascii("ratitatively"),
        dictgen::InsensitiveStr::Ascii("ratitive"),
        dictgen::InsensitiveStr::Ascii("rative"),
        dictgen::InsensitiveStr::Ascii("rded"),
        dictgen::InsensitiveStr::Ascii("ritate"),
        dictgen::InsensitiveStr::Ascii("ritatian"),
        dictgen::InsensitiveStr::Ascii("ritation"),
        dictgen::InsensitiveStr::Ascii("ritay"),
        dictgen::InsensitiveStr::Ascii("rites"),
        dictgen::InsensitiveStr::Ascii("rithies"),
        dictgen::InsensitiveStr::Ascii("rithy"),
        dictgen::InsensitiveStr::Ascii("ritiers"),
        dictgen::InsensitiveStr::Ascii("rititive"),
        dictgen::InsensitiveStr::Ascii("ritive"),
        dictgen::InsensitiveStr::Ascii("ritorian"),
        dictgen::InsensitiveStr::Ascii("rizatoin"),
        dictgen::InsensitiveStr::Ascii("rizaton"),
        dictgen::InsensitiveStr::Ascii("rizeed"),
        dictgen::InsensitiveStr::Ascii("rotative"),
        dictgen::InsensitiveStr::Ascii("roties"),
        dictgen::InsensitiveStr::Ascii("s"),
    ],
    values: &[
        &["autobiographic"],
        &["autobiography"],
        &["author"],
        &["authoritative"],
        &["authoritatively"],
        &["authoritative"],
        &["authoritatively"],
        &["authoritative"],
        &["authoritative"],
        &["authored"],
        &["authoritative"],
        &["authoritarian"],
        &["authorization"],
        &["authority"],
        &["authorities"],
        &["authorities"],
        &["authority"],
        &["authorities"],
        &["authoritative"],
        &["authoritative"],
        &["authoritarian"],
        &["authorization"],
        &["authorization"],
        &["authorized"],
        &["authoritative"],
        &["authorities"],
        &["authors", "autos"],
    ],
    range: 1..=12,
};

static WORD_AUTHE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_AUTHE_CHILDREN),
    value: None,
};

static WORD_AUTHE_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    Some(&WORD_AUTHEC_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_AUTHEN_NODE),
    None,
    None,
    None,
    Some(&WORD_AUTHER_NODE),
    None,
    Some(&WORD_AUTHET_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_AUTHET_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AUTHET_CHILDREN),
    value: None,
};

pub static WORD_AUTHET_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("henticate"),
        dictgen::InsensitiveStr::Ascii("henticated"),
        dictgen::InsensitiveStr::Ascii("henticates"),
        dictgen::InsensitiveStr::Ascii("henticating"),
        dictgen::InsensitiveStr::Ascii("hentication"),
        dictgen::InsensitiveStr::Ascii("henticator"),
        dictgen::InsensitiveStr::Ascii("henticators"),
        dictgen::InsensitiveStr::Ascii("hicate"),
        dictgen::InsensitiveStr::Ascii("hicated"),
        dictgen::InsensitiveStr::Ascii("hicates"),
        dictgen::InsensitiveStr::Ascii("hicating"),
        dictgen::InsensitiveStr::Ascii("hication"),
        dictgen::InsensitiveStr::Ascii("hicator"),
        dictgen::InsensitiveStr::Ascii("hicators"),
        dictgen::InsensitiveStr::Ascii("icate"),
        dictgen::InsensitiveStr::Ascii("icated"),
        dictgen::InsensitiveStr::Ascii("icates"),
        dictgen::InsensitiveStr::Ascii("icating"),
        dictgen::InsensitiveStr::Ascii("ication"),
        dictgen::InsensitiveStr::Ascii("icator"),
        dictgen::InsensitiveStr::Ascii("icators"),
        dictgen::InsensitiveStr::Ascii("nicate"),
        dictgen::InsensitiveStr::Ascii("nicated"),
        dictgen::InsensitiveStr::Ascii("nicates"),
        dictgen::InsensitiveStr::Ascii("nicating"),
        dictgen::InsensitiveStr::Ascii("nication"),
        dictgen::InsensitiveStr::Ascii("nicator"),
        dictgen::InsensitiveStr::Ascii("nicators"),
        dictgen::InsensitiveStr::Ascii("nticate"),
        dictgen::InsensitiveStr::Ascii("nticated"),
        dictgen::InsensitiveStr::Ascii("nticates"),
        dictgen::InsensitiveStr::Ascii("nticating"),
        dictgen::InsensitiveStr::Ascii("ntication"),
        dictgen::InsensitiveStr::Ascii("nticator"),
        dictgen::InsensitiveStr::Ascii("nticators"),
    ],
    values: &[
        &["authenticate"],
        &["authenticated"],
        &["authenticates"],
        &["authenticating"],
        &["authentication"],
        &["authenticator"],
        &["authenticators"],
        &["authenticate"],
        &["authenticated"],
        &["authenticates"],
        &["authenticating"],
        &["authentication"],
        &["authenticator"],
        &["authenticators"],
        &["authenticate"],
        &["authenticated"],
        &["authenticates"],
        &["authenticating"],
        &["authentication"],
        &["authenticator"],
        &["authenticators"],
        &["authenticate"],
        &["authenticated"],
        &["authenticates"],
        &["authenticating"],
        &["authentication"],
        &["authenticator"],
        &["authenticators"],
        &["authenticate"],
        &["authenticated"],
        &["authenticates"],
        &["authenticating"],
        &["authentication"],
        &["authenticator"],
        &["authenticators"],
    ],
    range: 5..=11,
};

static WORD_AUTHER_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AUTHER_CHILDREN),
    value: Some(&["author"]),
};

pub static WORD_AUTHER_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("isation"),
        dictgen::InsensitiveStr::Ascii("ise"),
        dictgen::InsensitiveStr::Ascii("ization"),
        dictgen::InsensitiveStr::Ascii("ize"),
        dictgen::InsensitiveStr::Ascii("ized"),
        dictgen::InsensitiveStr::Ascii("s"),
    ],
    values: &[
        &["authorisation"],
        &["authorise"],
        &["authorization"],
        &["authorize"],
        &["authorized"],
        &["authors"],
    ],
    range: 1..=7,
};

static WORD_AUTHEN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_AUTHEN_CHILDREN),
    value: None,
};

static WORD_AUTHEN_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_AUTHENA_NODE),
    None,
    Some(&WORD_AUTHENC_NODE),
    Some(&WORD_AUTHEND_NODE),
    Some(&WORD_AUTHENE_NODE),
    Some(&WORD_AUTHENF_NODE),
    None,
    None,
    Some(&WORD_AUTHENI_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_AUTHENR_NODE),
    None,
    Some(&WORD_AUTHENT_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_AUTHENT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AUTHENT_CHILDREN),
    value: None,
};

pub static WORD_AUTHENT_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("ation"),
            dictgen::InsensitiveStr::Ascii("cated"),
            dictgen::InsensitiveStr::Ascii("ciate"),
            dictgen::InsensitiveStr::Ascii("ciated"),
            dictgen::InsensitiveStr::Ascii("ciates"),
            dictgen::InsensitiveStr::Ascii("ciating"),
            dictgen::InsensitiveStr::Ascii("ciation"),
            dictgen::InsensitiveStr::Ascii("ciator"),
            dictgen::InsensitiveStr::Ascii("ciators"),
            dictgen::InsensitiveStr::Ascii("iation"),
            dictgen::InsensitiveStr::Ascii("icaion"),
            dictgen::InsensitiveStr::Ascii("icaiton"),
            dictgen::InsensitiveStr::Ascii("icateion"),
            dictgen::InsensitiveStr::Ascii("icaton"),
            dictgen::InsensitiveStr::Ascii("iciy"),
            dictgen::InsensitiveStr::Ascii("icor"),
            dictgen::InsensitiveStr::Ascii("iction"),
            dictgen::InsensitiveStr::Ascii("icty"),
            dictgen::InsensitiveStr::Ascii("icy"),
            dictgen::InsensitiveStr::Ascii("ification"),
            dictgen::InsensitiveStr::Ascii("isity"),
        ],
        values: &[
            &["authentication"],
            &["authenticated"],
            &["authenticate"],
            &["authenticated"],
            &["authenticates"],
            &["authenticating"],
            &["authentication"],
            &["authenticator"],
            &["authenticators"],
            &["authentication"],
            &["authentication"],
            &["authentication"],
            &["authentication"],
            &["authentication"],
            &["authenticity"],
            &["authenticator"],
            &["authentication"],
            &["authenticity"],
            &["authenticity"],
            &["authentication"],
            &["authenticity"],
        ],
        range: 3..=9,
    };

static WORD_AUTHENR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AUTHENR_CHILDREN),
    value: None,
};

pub static WORD_AUTHENR_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("icate"),
            dictgen::InsensitiveStr::Ascii("icated"),
            dictgen::InsensitiveStr::Ascii("icates"),
            dictgen::InsensitiveStr::Ascii("icating"),
            dictgen::InsensitiveStr::Ascii("ication"),
            dictgen::InsensitiveStr::Ascii("icator"),
            dictgen::InsensitiveStr::Ascii("icators"),
        ],
        values: &[
            &["authenticate"],
            &["authenticated"],
            &["authenticates"],
            &["authenticating"],
            &["authentication"],
            &["authenticator"],
            &["authenticators"],
        ],
        range: 5..=7,
    };

static WORD_AUTHENI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AUTHENI_CHILDREN),
    value: None,
};

pub static WORD_AUTHENI_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("cae"),
            dictgen::InsensitiveStr::Ascii("caed"),
            dictgen::InsensitiveStr::Ascii("caes"),
            dictgen::InsensitiveStr::Ascii("caing"),
            dictgen::InsensitiveStr::Ascii("caion"),
            dictgen::InsensitiveStr::Ascii("caor"),
            dictgen::InsensitiveStr::Ascii("caors"),
            dictgen::InsensitiveStr::Ascii("cate"),
            dictgen::InsensitiveStr::Ascii("cated"),
            dictgen::InsensitiveStr::Ascii("cates"),
            dictgen::InsensitiveStr::Ascii("cating"),
            dictgen::InsensitiveStr::Ascii("cation"),
            dictgen::InsensitiveStr::Ascii("cator"),
            dictgen::InsensitiveStr::Ascii("cators"),
            dictgen::InsensitiveStr::Ascii("ficate"),
            dictgen::InsensitiveStr::Ascii("ficated"),
            dictgen::InsensitiveStr::Ascii("ficates"),
            dictgen::InsensitiveStr::Ascii("ficating"),
            dictgen::InsensitiveStr::Ascii("fication"),
            dictgen::InsensitiveStr::Ascii("ficator"),
            dictgen::InsensitiveStr::Ascii("ficators"),
            dictgen::InsensitiveStr::Ascii("tcate"),
            dictgen::InsensitiveStr::Ascii("tcated"),
            dictgen::InsensitiveStr::Ascii("tcates"),
            dictgen::InsensitiveStr::Ascii("tcating"),
            dictgen::InsensitiveStr::Ascii("tcation"),
            dictgen::InsensitiveStr::Ascii("tcator"),
            dictgen::InsensitiveStr::Ascii("tcators"),
            dictgen::InsensitiveStr::Ascii("ticate"),
            dictgen::InsensitiveStr::Ascii("ticated"),
            dictgen::InsensitiveStr::Ascii("ticates"),
            dictgen::InsensitiveStr::Ascii("ticating"),
            dictgen::InsensitiveStr::Ascii("tication"),
            dictgen::InsensitiveStr::Ascii("ticator"),
            dictgen::InsensitiveStr::Ascii("ticators"),
        ],
        values: &[
            &["authenticate"],
            &["authenticated"],
            &["authenticates"],
            &["authenticating"],
            &["authentication"],
            &["authenticator"],
            &["authenticators"],
            &["authenticate"],
            &["authenticated"],
            &["authenticates"],
            &["authenticating"],
            &["authentication"],
            &["authenticator"],
            &["authenticators"],
            &["authenticate"],
            &["authenticated"],
            &["authenticates"],
            &["authenticating"],
            &["authentication"],
            &["authenticator"],
            &["authenticators"],
            &["authenticate"],
            &["authenticated"],
            &["authenticates"],
            &["authenticating"],
            &["authentication"],
            &["authenticator"],
            &["authenticators"],
            &["authenticate"],
            &["authenticated"],
            &["authenticates"],
            &["authenticating"],
            &["authentication"],
            &["authenticator"],
            &["authenticators"],
        ],
        range: 3..=8,
    };

static WORD_AUTHENF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AUTHENF_CHILDREN),
    value: None,
};

pub static WORD_AUTHENF_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("ie"),
            dictgen::InsensitiveStr::Ascii("ied"),
            dictgen::InsensitiveStr::Ascii("ies"),
            dictgen::InsensitiveStr::Ascii("iing"),
            dictgen::InsensitiveStr::Ascii("iion"),
            dictgen::InsensitiveStr::Ascii("ior"),
            dictgen::InsensitiveStr::Ascii("iors"),
        ],
        values: &[
            &["authenticate"],
            &["authenticated"],
            &["authenticates"],
            &["authenticating"],
            &["authentication"],
            &["authenticator"],
            &["authenticators"],
        ],
        range: 2..=4,
    };

static WORD_AUTHENE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AUTHENE_CHILDREN),
    value: None,
};

pub static WORD_AUTHENE_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("nticate"),
            dictgen::InsensitiveStr::Ascii("nticated"),
            dictgen::InsensitiveStr::Ascii("nticates"),
            dictgen::InsensitiveStr::Ascii("nticating"),
            dictgen::InsensitiveStr::Ascii("ntication"),
            dictgen::InsensitiveStr::Ascii("nticator"),
            dictgen::InsensitiveStr::Ascii("nticators"),
        ],
        values: &[
            &["authenticate"],
            &["authenticated"],
            &["authenticates"],
            &["authenticating"],
            &["authentication"],
            &["authenticator"],
            &["authenticators"],
        ],
        range: 7..=9,
    };

static WORD_AUTHEND_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AUTHEND_CHILDREN),
    value: None,
};

pub static WORD_AUTHEND_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("icate"),
            dictgen::InsensitiveStr::Ascii("icated"),
            dictgen::InsensitiveStr::Ascii("icates"),
            dictgen::InsensitiveStr::Ascii("icating"),
            dictgen::InsensitiveStr::Ascii("ication"),
            dictgen::InsensitiveStr::Ascii("icator"),
            dictgen::InsensitiveStr::Ascii("icators"),
        ],
        values: &[
            &["authenticate"],
            &["authenticated"],
            &["authenticates"],
            &["authenticating"],
            &["authentication"],
            &["authenticator"],
            &["authenticators"],
        ],
        range: 5..=7,
    };

static WORD_AUTHENC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AUTHENC_CHILDREN),
    value: None,
};

pub static WORD_AUTHENC_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("ate"),
            dictgen::InsensitiveStr::Ascii("ated"),
            dictgen::InsensitiveStr::Ascii("ates"),
            dictgen::InsensitiveStr::Ascii("ating"),
            dictgen::InsensitiveStr::Ascii("ation"),
            dictgen::InsensitiveStr::Ascii("ator"),
            dictgen::InsensitiveStr::Ascii("ators"),
            dictgen::InsensitiveStr::Ascii("iate"),
            dictgen::InsensitiveStr::Ascii("iated"),
            dictgen::InsensitiveStr::Ascii("iates"),
            dictgen::InsensitiveStr::Ascii("iating"),
            dictgen::InsensitiveStr::Ascii("iation"),
            dictgen::InsensitiveStr::Ascii("iator"),
            dictgen::InsensitiveStr::Ascii("iators"),
            dictgen::InsensitiveStr::Ascii("icate"),
            dictgen::InsensitiveStr::Ascii("icated"),
            dictgen::InsensitiveStr::Ascii("icates"),
            dictgen::InsensitiveStr::Ascii("icating"),
            dictgen::InsensitiveStr::Ascii("ication"),
            dictgen::InsensitiveStr::Ascii("icator"),
            dictgen::InsensitiveStr::Ascii("icators"),
            dictgen::InsensitiveStr::Ascii("ity"),
            dictgen::InsensitiveStr::Ascii("ticate"),
            dictgen::InsensitiveStr::Ascii("ticated"),
            dictgen::InsensitiveStr::Ascii("ticates"),
            dictgen::InsensitiveStr::Ascii("ticating"),
            dictgen::InsensitiveStr::Ascii("tication"),
            dictgen::InsensitiveStr::Ascii("ticator"),
            dictgen::InsensitiveStr::Ascii("ticators"),
        ],
        values: &[
            &["authenticate"],
            &["authenticated"],
            &["authenticates"],
            &["authenticating"],
            &["authentication"],
            &["authenticator"],
            &["authenticators"],
            &["authenticate"],
            &["authenticated"],
            &["authenticates"],
            &["authenticating"],
            &["authentication"],
            &["authenticator"],
            &["authenticators"],
            &["authenticate"],
            &["authenticated"],
            &["authenticates"],
            &["authenticating"],
            &["authentication"],
            &["authenticator"],
            &["authenticators"],
            &["authenticity"],
            &["authenticate"],
            &["authenticated"],
            &["authenticates"],
            &["authenticating"],
            &["authentication"],
            &["authenticator"],
            &["authenticators"],
        ],
        range: 3..=8,
    };

static WORD_AUTHENA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AUTHENA_CHILDREN),
    value: None,
};

pub static WORD_AUTHENA_CHILDREN: dictgen::DictTable<&'static [&'static str]> =
    dictgen::DictTable {
        keys: &[
            dictgen::InsensitiveStr::Ascii("ticate"),
            dictgen::InsensitiveStr::Ascii("ticated"),
            dictgen::InsensitiveStr::Ascii("ticates"),
            dictgen::InsensitiveStr::Ascii("ticating"),
            dictgen::InsensitiveStr::Ascii("tication"),
            dictgen::InsensitiveStr::Ascii("ticator"),
            dictgen::InsensitiveStr::Ascii("ticators"),
        ],
        values: &[
            &["authenticate"],
            &["authenticated"],
            &["authenticates"],
            &["authenticating"],
            &["authentication"],
            &["authenticator"],
            &["authenticators"],
        ],
        range: 6..=8,
    };

static WORD_AUTHEC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AUTHEC_CHILDREN),
    value: None,
};

pub static WORD_AUTHEC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ate"),
        dictgen::InsensitiveStr::Ascii("ated"),
        dictgen::InsensitiveStr::Ascii("ates"),
        dictgen::InsensitiveStr::Ascii("ating"),
        dictgen::InsensitiveStr::Ascii("ation"),
        dictgen::InsensitiveStr::Ascii("ator"),
        dictgen::InsensitiveStr::Ascii("ators"),
    ],
    values: &[
        &["authenticate"],
        &["authenticated"],
        &["authenticates"],
        &["authenticating"],
        &["authentication"],
        &["authenticator"],
        &["authenticators"],
    ],
    range: 3..=5,
};

static WORD_AUTE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AUTE_CHILDREN),
    value: None,
};

pub static WORD_AUTE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("nticate"),
        dictgen::InsensitiveStr::Ascii("nticated"),
        dictgen::InsensitiveStr::Ascii("nticates"),
        dictgen::InsensitiveStr::Ascii("nticating"),
        dictgen::InsensitiveStr::Ascii("ntication"),
        dictgen::InsensitiveStr::Ascii("nticator"),
        dictgen::InsensitiveStr::Ascii("nticators"),
    ],
    values: &[
        &["authenticate"],
        &["authenticated"],
        &["authenticates"],
        &["authenticating"],
        &["authentication"],
        &["authenticator"],
        &["authenticators"],
    ],
    range: 7..=9,
};

static WORD_AUTC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AUTC_CHILDREN),
    value: None,
};

pub static WORD_AUTC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("omplete")],
    values: &[&["autocomplete"]],
    range: 7..=7,
};

static WORD_AUTA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AUTA_CHILDREN),
    value: None,
};

pub static WORD_AUTA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("save"),
        dictgen::InsensitiveStr::Ascii("saves"),
    ],
    values: &[&["autosave"], &["autosaves"]],
    range: 4..=5,
};

static WORD_AUS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AUS_CHILDREN),
    value: None,
};

pub static WORD_AUS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("sian"),
        dictgen::InsensitiveStr::Ascii("tair"),
        dictgen::InsensitiveStr::Ascii("teer"),
        dictgen::InsensitiveStr::Ascii("tensible"),
        dictgen::InsensitiveStr::Ascii("tensibly"),
        dictgen::InsensitiveStr::Ascii("teriy"),
        dictgen::InsensitiveStr::Ascii("tira"),
        dictgen::InsensitiveStr::Ascii("tiran"),
        dictgen::InsensitiveStr::Ascii("titic"),
        dictgen::InsensitiveStr::Ascii("trai"),
        dictgen::InsensitiveStr::Ascii("trailan"),
        dictgen::InsensitiveStr::Ascii("trailans"),
        dictgen::InsensitiveStr::Ascii("trailia"),
        dictgen::InsensitiveStr::Ascii("trailian"),
        dictgen::InsensitiveStr::Ascii("train"),
        dictgen::InsensitiveStr::Ascii("trala"),
        dictgen::InsensitiveStr::Ascii("tralain"),
        dictgen::InsensitiveStr::Ascii("traliaan"),
        dictgen::InsensitiveStr::Ascii("traliams"),
        dictgen::InsensitiveStr::Ascii("tralianas"),
        dictgen::InsensitiveStr::Ascii("tralianess"),
        dictgen::InsensitiveStr::Ascii("tralianos"),
        dictgen::InsensitiveStr::Ascii("tralien"),
        dictgen::InsensitiveStr::Ascii("traliens"),
        dictgen::InsensitiveStr::Ascii("tralin"),
        dictgen::InsensitiveStr::Ascii("tralina"),
        dictgen::InsensitiveStr::Ascii("trallian"),
        dictgen::InsensitiveStr::Ascii("trija"),
        dictgen::InsensitiveStr::Ascii("trila"),
        dictgen::InsensitiveStr::Ascii("trlaian"),
    ],
    values: &[
        &["gaussian", "russian", "austrian"],
        &["austere"],
        &["austere"],
        &["ostensible"],
        &["ostensibly"],
        &["austerity"],
        &["austria"],
        &["austrian"],
        &["autistic"],
        &["austria"],
        &["australian"],
        &["australians"],
        &["australia"],
        &["australian"],
        &["austrian"],
        &["australian"],
        &["australians"],
        &["australians"],
        &["australians"],
        &["australians"],
        &["australians"],
        &["australians"],
        &["australian"],
        &["australians"],
        &["australians"],
        &["australians"],
        &["australian"],
        &["austria"],
        &["austria"],
        &["australians", "australian"],
    ],
    range: 4..=10,
};

static WORD_AUR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AUR_CHILDREN),
    value: None,
};

pub static WORD_AUR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("omated")],
    values: &[&["automated"]],
    range: 6..=6,
};

static WORD_AUO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AUO_CHILDREN),
    value: None,
};

pub static WORD_AUO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("spacing"),
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("tattack"),
        dictgen::InsensitiveStr::Ascii("tcorrect"),
        dictgen::InsensitiveStr::Ascii("tmatic"),
    ],
    values: &[
        &["autospacing"],
        &["auto"],
        &["autoattack"],
        &["autocorrect"],
        &["automatic"],
    ],
    range: 1..=8,
};

static WORD_AUN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AUN_CHILDREN),
    value: None,
};

pub static WORD_AUN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("thenticate"),
        dictgen::InsensitiveStr::Ascii("thenticated"),
        dictgen::InsensitiveStr::Ascii("thenticates"),
        dictgen::InsensitiveStr::Ascii("thenticating"),
        dictgen::InsensitiveStr::Ascii("thentication"),
        dictgen::InsensitiveStr::Ascii("thenticator"),
        dictgen::InsensitiveStr::Ascii("thenticators"),
    ],
    values: &[
        &["authenticate"],
        &["authenticated"],
        &["authenticates"],
        &["authenticating"],
        &["authentication"],
        &["authenticator"],
        &["authenticators"],
    ],
    range: 10..=12,
};

static WORD_AUI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AUI_CHILDREN),
    value: None,
};

pub static WORD_AUI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("dobook"),
        dictgen::InsensitiveStr::Ascii("dobooks"),
    ],
    values: &[&["audiobook"], &["audiobooks"]],
    range: 6..=7,
};

static WORD_AUH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AUH_CHILDREN),
    value: None,
};

pub static WORD_AUH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("tenticate"),
        dictgen::InsensitiveStr::Ascii("tentication"),
        dictgen::InsensitiveStr::Ascii("tor"),
        dictgen::InsensitiveStr::Ascii("tors"),
    ],
    values: &[
        &["authenticate"],
        &["authentication"],
        &["author"],
        &["authors"],
    ],
    range: 3..=11,
};

static WORD_AUG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AUG_CHILDREN),
    value: None,
};

pub static WORD_AUG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("est"),
        dictgen::InsensitiveStr::Ascii("mnet"),
        dictgen::InsensitiveStr::Ascii("mnetation"),
        dictgen::InsensitiveStr::Ascii("mneted"),
        dictgen::InsensitiveStr::Ascii("mneter"),
        dictgen::InsensitiveStr::Ascii("mneters"),
        dictgen::InsensitiveStr::Ascii("mnetes"),
        dictgen::InsensitiveStr::Ascii("mneting"),
        dictgen::InsensitiveStr::Ascii("mnets"),
        dictgen::InsensitiveStr::Ascii("uest"),
        dictgen::InsensitiveStr::Ascii("ument"),
    ],
    values: &[
        &["august"],
        &["augment"],
        &["augmentation"],
        &["augmented"],
        &["augmenter"],
        &["augmenters"],
        &["augments"],
        &["augmenting"],
        &["augments"],
        &["august"],
        &["argument", "augment"],
    ],
    range: 3..=9,
};

static WORD_AUF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AUF_CHILDREN),
    value: None,
};

pub static WORD_AUF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ter")],
    values: &[&["after"]],
    range: 3..=3,
};

static WORD_AUD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AUD_CHILDREN),
    value: None,
};

pub static WORD_AUD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("actiy"),
        dictgen::InsensitiveStr::Ascii("bile"),
        dictgen::InsensitiveStr::Ascii("caity"),
        dictgen::InsensitiveStr::Ascii("eince"),
        dictgen::InsensitiveStr::Ascii("iance"),
        dictgen::InsensitiveStr::Ascii("ibel"),
        dictgen::InsensitiveStr::Ascii("iobok"),
        dictgen::InsensitiveStr::Ascii("iobookas"),
        dictgen::InsensitiveStr::Ascii("iobookmrs"),
        dictgen::InsensitiveStr::Ascii("ioboook"),
        dictgen::InsensitiveStr::Ascii("ioboooks"),
        dictgen::InsensitiveStr::Ascii("ioboost"),
        dictgen::InsensitiveStr::Ascii("omoderator"),
        dictgen::InsensitiveStr::Ascii("ovisual"),
    ],
    values: &[
        &["audacity"],
        &["audible"],
        &["audacity"],
        &["audience"],
        &["audience"],
        &["audible"],
        &["audiobook"],
        &["audiobooks"],
        &["audiobooks"],
        &["audiobook"],
        &["audiobook"],
        &["audiobooks"],
        &["automoderator"],
        &["audiovisual"],
    ],
    range: 4..=10,
};

static WORD_AUC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AUC_CHILDREN),
    value: None,
};

pub static WORD_AUC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cess"),
        dictgen::InsensitiveStr::Ascii("cessive"),
        dictgen::InsensitiveStr::Ascii("itons"),
        dictgen::InsensitiveStr::Ascii("tioners"),
        dictgen::InsensitiveStr::Ascii("tionrs"),
    ],
    values: &[
        &["success"],
        &["successive"],
        &["auctions"],
        &["auctions"],
        &["auctions"],
    ],
    range: 4..=7,
};

static WORD_AT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_AT_CHILDREN),
    value: None,
};

static WORD_AT_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_ATA_NODE),
    None,
    Some(&WORD_ATC_NODE),
    None,
    Some(&WORD_ATE_NODE),
    None,
    None,
    Some(&WORD_ATH_NODE),
    Some(&WORD_ATI_NODE),
    None,
    None,
    Some(&WORD_ATL_NODE),
    Some(&WORD_ATM_NODE),
    None,
    Some(&WORD_ATO_NODE),
    None,
    Some(&WORD_ATQ_NODE),
    Some(&WORD_ATR_NODE),
    None,
    Some(&WORD_ATT_NODE),
    Some(&WORD_ATU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_ATU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ATU_CHILDREN),
    value: None,
};

pub static WORD_ATU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("henticate"),
        dictgen::InsensitiveStr::Ascii("henticated"),
        dictgen::InsensitiveStr::Ascii("henticates"),
        dictgen::InsensitiveStr::Ascii("henticating"),
        dictgen::InsensitiveStr::Ascii("hentication"),
        dictgen::InsensitiveStr::Ascii("henticator"),
        dictgen::InsensitiveStr::Ascii("henticators"),
    ],
    values: &[
        &["authenticate"],
        &["authenticated"],
        &["authenticates"],
        &["authenticating"],
        &["authentication"],
        &["authenticator"],
        &["authenticators"],
    ],
    range: 9..=11,
};

static WORD_ATT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_ATT_CHILDREN),
    value: None,
};

static WORD_ATT_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_ATTA_NODE),
    None,
    Some(&WORD_ATTC_NODE),
    None,
    Some(&WORD_ATTE_NODE),
    None,
    None,
    None,
    Some(&WORD_ATTI_NODE),
    None,
    None,
    None,
    Some(&WORD_ATTM_NODE),
    Some(&WORD_ATTN_NODE),
    Some(&WORD_ATTO_NODE),
    None,
    None,
    Some(&WORD_ATTR_NODE),
    None,
    Some(&WORD_ATTT_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_ATTT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ATTT_CHILDREN),
    value: None,
};

pub static WORD_ATTT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ached"),
        dictgen::InsensitiveStr::Ascii("ribute"),
        dictgen::InsensitiveStr::Ascii("ributes"),
    ],
    values: &[&["attached"], &["attribute"], &["attributes"]],
    range: 5..=7,
};

static WORD_ATTR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_ATTR_CHILDREN),
    value: None,
};

static WORD_ATTR_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_ATTRA_NODE),
    Some(&WORD_ATTRB_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_ATTRI_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_ATTRO_NODE),
    None,
    None,
    Some(&WORD_ATTRR_NODE),
    None,
    None,
    Some(&WORD_ATTRU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_ATTRU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ATTRU_CHILDREN),
    value: None,
};

pub static WORD_ATTRU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("bite"),
        dictgen::InsensitiveStr::Ascii("bites"),
        dictgen::InsensitiveStr::Ascii("bte"),
        dictgen::InsensitiveStr::Ascii("btes"),
        dictgen::InsensitiveStr::Ascii("bure"),
        dictgen::InsensitiveStr::Ascii("bures"),
        dictgen::InsensitiveStr::Ascii("bute"),
        dictgen::InsensitiveStr::Ascii("butes"),
        dictgen::InsensitiveStr::Ascii("byte"),
        dictgen::InsensitiveStr::Ascii("bytes"),
        dictgen::InsensitiveStr::Ascii("ibute"),
        dictgen::InsensitiveStr::Ascii("ibutes"),
    ],
    values: &[
        &["attribute"],
        &["attributes"],
        &["attribute"],
        &["attributes"],
        &["attribute"],
        &["attributes"],
        &["attribute"],
        &["attributes"],
        &["attribute"],
        &["attributes"],
        &["attribute"],
        &["attributes"],
    ],
    range: 3..=6,
};

static WORD_ATTRR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ATTRR_CHILDREN),
    value: None,
};

pub static WORD_ATTRR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ibute"),
        dictgen::InsensitiveStr::Ascii("ibuted"),
        dictgen::InsensitiveStr::Ascii("ibutes"),
        dictgen::InsensitiveStr::Ascii("ibution"),
    ],
    values: &[
        &["attribute"],
        &["attributed"],
        &["attributes"],
        &["attribution"],
    ],
    range: 5..=7,
};

static WORD_ATTRO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ATTRO_CHILDREN),
    value: None,
};

pub static WORD_ATTRO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("cities")],
    values: &[&["atrocities"]],
    range: 6..=6,
};

static WORD_ATTRI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ATTRI_CHILDREN),
    value: None,
};

pub static WORD_ATTRI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("bbute"),
        dictgen::InsensitiveStr::Ascii("biute"),
        dictgen::InsensitiveStr::Ascii("biutes"),
        dictgen::InsensitiveStr::Ascii("bte"),
        dictgen::InsensitiveStr::Ascii("bted"),
        dictgen::InsensitiveStr::Ascii("btes"),
        dictgen::InsensitiveStr::Ascii("bting"),
        dictgen::InsensitiveStr::Ascii("btue"),
        dictgen::InsensitiveStr::Ascii("btues"),
        dictgen::InsensitiveStr::Ascii("btutes"),
        dictgen::InsensitiveStr::Ascii("bude"),
        dictgen::InsensitiveStr::Ascii("bue"),
        dictgen::InsensitiveStr::Ascii("bues"),
        dictgen::InsensitiveStr::Ascii("buets"),
        dictgen::InsensitiveStr::Ascii("buite"),
        dictgen::InsensitiveStr::Ascii("buites"),
        dictgen::InsensitiveStr::Ascii("buition"),
        dictgen::InsensitiveStr::Ascii("buito"),
        dictgen::InsensitiveStr::Ascii("bure"),
        dictgen::InsensitiveStr::Ascii("bured"),
        dictgen::InsensitiveStr::Ascii("bures"),
        dictgen::InsensitiveStr::Ascii("burte"),
        dictgen::InsensitiveStr::Ascii("burted"),
        dictgen::InsensitiveStr::Ascii("burtes"),
        dictgen::InsensitiveStr::Ascii("burtion"),
        dictgen::InsensitiveStr::Ascii("but"),
        dictgen::InsensitiveStr::Ascii("butei"),
        dictgen::InsensitiveStr::Ascii("buten"),
        dictgen::InsensitiveStr::Ascii("butess"),
        dictgen::InsensitiveStr::Ascii("buto"),
        dictgen::InsensitiveStr::Ascii("butred"),
        dictgen::InsensitiveStr::Ascii("buts"),
        dictgen::InsensitiveStr::Ascii("butted"),
        dictgen::InsensitiveStr::Ascii("bye"),
        dictgen::InsensitiveStr::Ascii("byes"),
        dictgen::InsensitiveStr::Ascii("byte"),
        dictgen::InsensitiveStr::Ascii("bytes"),
        dictgen::InsensitiveStr::Ascii("ebute"),
        dictgen::InsensitiveStr::Ascii("ebuted"),
        dictgen::InsensitiveStr::Ascii("ebutes"),
        dictgen::InsensitiveStr::Ascii("ebuting"),
        dictgen::InsensitiveStr::Ascii("rbute"),
        dictgen::InsensitiveStr::Ascii("rbuted"),
        dictgen::InsensitiveStr::Ascii("rbutes"),
        dictgen::InsensitiveStr::Ascii("rbution"),
        dictgen::InsensitiveStr::Ascii("tube"),
        dictgen::InsensitiveStr::Ascii("tubed"),
        dictgen::InsensitiveStr::Ascii("tubes"),
        dictgen::InsensitiveStr::Ascii("ubtes"),
        dictgen::InsensitiveStr::Ascii("ubute"),
    ],
    values: &[
        &["attribute"],
        &["attribute"],
        &["attributes"],
        &["attribute"],
        &["attributed"],
        &["attributes", "attribute"],
        &["attributing"],
        &["attribute"],
        &["attributes"],
        &["attributes"],
        &["attribute"],
        &["attribute"],
        &["attributes"],
        &["attributes"],
        &["attribute"],
        &["attributes"],
        &["attribution"],
        &["attribution"],
        &["attribute"],
        &["attributed"],
        &["attributes"],
        &["attribute"],
        &["attributed"],
        &["attributes"],
        &["attribution"],
        &["attribute"],
        &["attribute"],
        &["attribute"],
        &["attributes"],
        &["attribution"],
        &["attributed"],
        &["attributes"],
        &["attribute"],
        &["attribute"],
        &["attributes"],
        &["attribute"],
        &["attributes"],
        &["attribute"],
        &["attributed"],
        &["attributes"],
        &["attributing"],
        &["attribute"],
        &["attributed"],
        &["attributes"],
        &["attribution"],
        &["attribute"],
        &["attributed"],
        &["attributes"],
        &["attributes"],
        &["attribute"],
    ],
    range: 3..=7,
};

static WORD_ATTRB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ATTRB_CHILDREN),
    value: None,
};

pub static WORD_ATTRB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("iute"),
        dictgen::InsensitiveStr::Ascii("ute"),
        dictgen::InsensitiveStr::Ascii("uted"),
        dictgen::InsensitiveStr::Ascii("utes"),
        dictgen::InsensitiveStr::Ascii("ution"),
        dictgen::InsensitiveStr::Ascii("utions"),
    ],
    values: &[
        &["attribute"],
        &["attribute"],
        &["attributed"],
        &["attributes"],
        &["attribution"],
        &["attributions"],
    ],
    range: 3..=6,
};

static WORD_ATTRA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ATTRA_CHILDREN),
    value: None,
};

pub static WORD_ATTRA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cs"),
        dictgen::InsensitiveStr::Ascii("cters"),
        dictgen::InsensitiveStr::Ascii("ctes"),
        dictgen::InsensitiveStr::Ascii("ctice"),
        dictgen::InsensitiveStr::Ascii("cties"),
        dictgen::InsensitiveStr::Ascii("ctifs"),
        dictgen::InsensitiveStr::Ascii("ctin"),
        dictgen::InsensitiveStr::Ascii("ktion"),
        dictgen::InsensitiveStr::Ascii("ktive"),
    ],
    values: &[
        &["attracts"],
        &["attracts"],
        &["attracts"],
        &["attractive"],
        &["attracts"],
        &["attracts"],
        &["attraction"],
        &["attraction"],
        &["attractive"],
    ],
    range: 2..=5,
};

static WORD_ATTO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ATTO_CHILDREN),
    value: None,
};

pub static WORD_ATTO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("rnies"),
        dictgen::InsensitiveStr::Ascii("sencond"),
        dictgen::InsensitiveStr::Ascii("senconds"),
    ],
    values: &[&["attorneys"], &["attosecond"], &["attoseconds"]],
    range: 5..=8,
};

static WORD_ATTN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ATTN_CHILDREN),
    value: None,
};

pub static WORD_ATTN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("etion")],
    values: &[&["attention"]],
    range: 5..=5,
};

static WORD_ATTM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ATTM_CHILDREN),
    value: None,
};

pub static WORD_ATTM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ept"),
        dictgen::InsensitiveStr::Ascii("epted"),
        dictgen::InsensitiveStr::Ascii("epting"),
        dictgen::InsensitiveStr::Ascii("pt"),
        dictgen::InsensitiveStr::Ascii("pts"),
    ],
    values: &[
        &["attempt"],
        &["attempted"],
        &["attempting"],
        &["attempt"],
        &["attempts"],
    ],
    range: 2..=6,
};

static WORD_ATTI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ATTI_CHILDREN),
    value: None,
};

pub static WORD_ATTI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("bures"),
        dictgen::InsensitiveStr::Ascii("bute"),
        dictgen::InsensitiveStr::Ascii("buted"),
        dictgen::InsensitiveStr::Ascii("butes"),
        dictgen::InsensitiveStr::Ascii("dute"),
        dictgen::InsensitiveStr::Ascii("rbute"),
        dictgen::InsensitiveStr::Ascii("rbutes"),
        dictgen::InsensitiveStr::Ascii("ribute"),
        dictgen::InsensitiveStr::Ascii("ributes"),
        dictgen::InsensitiveStr::Ascii("rtion"),
        dictgen::InsensitiveStr::Ascii("tide"),
    ],
    values: &[
        &["attributes"],
        &["attribute"],
        &["attributed"],
        &["attributes"],
        &["attitude"],
        &["attribute"],
        &["attributes"],
        &["attribute"],
        &["attributes"],
        &["attrition"],
        &["attitude"],
    ],
    range: 4..=7,
};

static WORD_ATTE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ATTE_CHILDREN),
    value: None,
};

pub static WORD_ATTE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ment"),
        dictgen::InsensitiveStr::Ascii("mented"),
        dictgen::InsensitiveStr::Ascii("menting"),
        dictgen::InsensitiveStr::Ascii("ments"),
        dictgen::InsensitiveStr::Ascii("mp"),
        dictgen::InsensitiveStr::Ascii("mped"),
        dictgen::InsensitiveStr::Ascii("mpeting"),
        dictgen::InsensitiveStr::Ascii("mping"),
        dictgen::InsensitiveStr::Ascii("mppt"),
        dictgen::InsensitiveStr::Ascii("mps"),
        dictgen::InsensitiveStr::Ascii("mptes"),
        dictgen::InsensitiveStr::Ascii("mptting"),
        dictgen::InsensitiveStr::Ascii("mt"),
        dictgen::InsensitiveStr::Ascii("mted"),
        dictgen::InsensitiveStr::Ascii("mting"),
        dictgen::InsensitiveStr::Ascii("mtp"),
        dictgen::InsensitiveStr::Ascii("mtped"),
        dictgen::InsensitiveStr::Ascii("mtping"),
        dictgen::InsensitiveStr::Ascii("mtps"),
        dictgen::InsensitiveStr::Ascii("mtpted"),
        dictgen::InsensitiveStr::Ascii("mtpts"),
        dictgen::InsensitiveStr::Ascii("mts"),
        dictgen::InsensitiveStr::Ascii("ndence"),
        dictgen::InsensitiveStr::Ascii("ndent"),
        dictgen::InsensitiveStr::Ascii("ndents"),
        dictgen::InsensitiveStr::Ascii("ned"),
        dictgen::InsensitiveStr::Ascii("nnuation"),
        dictgen::InsensitiveStr::Ascii("nsion"),
        dictgen::InsensitiveStr::Ascii("nted"),
        dictgen::InsensitiveStr::Ascii("ntuation"),
        dictgen::InsensitiveStr::Ascii("ntuations"),
        dictgen::InsensitiveStr::Ascii("pmpt"),
        dictgen::InsensitiveStr::Ascii("pt"),
        dictgen::InsensitiveStr::Ascii("pts"),
        dictgen::InsensitiveStr::Ascii("tntion"),
    ],
    values: &[
        &["attempt"],
        &["attempted"],
        &["attempting"],
        &["attempts"],
        &["attempt"],
        &["attempted"],
        &["attempting"],
        &["attempting"],
        &["attempt"],
        &["attempts"],
        &["attempts"],
        &["attempting"],
        &["attempt"],
        &["attempted"],
        &["attempting"],
        &["attempt"],
        &["attempted"],
        &["attempting"],
        &["attempts"],
        &["attempted"],
        &["attempts"],
        &["attempts"],
        &["attendance"],
        &["attendant"],
        &["attendants"],
        &["attended"],
        &["attenuation"],
        &["attention"],
        &["attended"],
        &["attenuation"],
        &["attenuations"],
        &["attempt"],
        &["attempt"],
        &["attempts"],
        &["attention"],
    ],
    range: 2..=9,
};

static WORD_ATTC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ATTC_CHILDREN),
    value: None,
};

pub static WORD_ATTC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("h"),
        dictgen::InsensitiveStr::Ascii("hed"),
        dictgen::InsensitiveStr::Ascii("hes"),
        dictgen::InsensitiveStr::Ascii("hing"),
        dictgen::InsensitiveStr::Ascii("hment"),
    ],
    values: &[
        &["attach"],
        &["attached"],
        &["attaches"],
        &["attaching"],
        &["attachment"],
    ],
    range: 1..=5,
};

static WORD_ATTA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ATTA_CHILDREN),
    value: None,
};

pub static WORD_ATTA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ced"),
        dictgen::InsensitiveStr::Ascii("chd"),
        dictgen::InsensitiveStr::Ascii("chement"),
        dictgen::InsensitiveStr::Ascii("chements"),
        dictgen::InsensitiveStr::Ascii("chemnt"),
        dictgen::InsensitiveStr::Ascii("chemnts"),
        dictgen::InsensitiveStr::Ascii("chen"),
        dictgen::InsensitiveStr::Ascii("chged"),
        dictgen::InsensitiveStr::Ascii("chmant"),
        dictgen::InsensitiveStr::Ascii("chmants"),
        dictgen::InsensitiveStr::Ascii("chmet"),
        dictgen::InsensitiveStr::Ascii("chs"),
        dictgen::InsensitiveStr::Ascii("chted"),
        dictgen::InsensitiveStr::Ascii("ckeras"),
        dictgen::InsensitiveStr::Ascii("ckerasu"),
        dictgen::InsensitiveStr::Ascii("ckerats"),
        dictgen::InsensitiveStr::Ascii("ckes"),
        dictgen::InsensitiveStr::Ascii("cs"),
        dictgen::InsensitiveStr::Ascii("cthed"),
        dictgen::InsensitiveStr::Ascii("ctment"),
        dictgen::InsensitiveStr::Ascii("ctments"),
        dictgen::InsensitiveStr::Ascii("indre"),
        dictgen::InsensitiveStr::Ascii("mpt"),
        dictgen::InsensitiveStr::Ascii("tch"),
        dictgen::InsensitiveStr::Ascii("tched"),
        dictgen::InsensitiveStr::Ascii("tches"),
        dictgen::InsensitiveStr::Ascii("tching"),
        dictgen::InsensitiveStr::Ascii("tchment"),
        dictgen::InsensitiveStr::Ascii("tchments"),
    ],
    values: &[
        &["attached"],
        &["attached"],
        &["attachment"],
        &["attachments"],
        &["attachment"],
        &["attachments"],
        &["attach"],
        &["attached"],
        &["attachment"],
        &["attachments"],
        &["attachments"],
        &["attaches"],
        &["attached"],
        &["attackers"],
        &["attackers"],
        &["attackers"],
        &["attackers"],
        &["attacks"],
        &["attached"],
        &["attachment"],
        &["attachments"],
        &["attainder", "attained"],
        &["attempt"],
        &["attach"],
        &["attached"],
        &["attaches"],
        &["attaching"],
        &["attachment"],
        &["attachments"],
    ],
    range: 2..=8,
};

static WORD_ATR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ATR_CHILDREN),
    value: None,
};

pub static WORD_ATR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("emis"),
        dictgen::InsensitiveStr::Ascii("ibs"),
        dictgen::InsensitiveStr::Ascii("ibut"),
        dictgen::InsensitiveStr::Ascii("ibute"),
        dictgen::InsensitiveStr::Ascii("ibuted"),
        dictgen::InsensitiveStr::Ascii("ibutes"),
        dictgen::InsensitiveStr::Ascii("iculate"),
        dictgen::InsensitiveStr::Ascii("ifact"),
        dictgen::InsensitiveStr::Ascii("ifacts"),
        dictgen::InsensitiveStr::Ascii("illery"),
        dictgen::InsensitiveStr::Ascii("ittion"),
        dictgen::InsensitiveStr::Ascii("ocitites"),
        dictgen::InsensitiveStr::Ascii("ocoties"),
        dictgen::InsensitiveStr::Ascii("onomical"),
        dictgen::InsensitiveStr::Ascii("osities"),
        dictgen::InsensitiveStr::Ascii("ribute"),
        dictgen::InsensitiveStr::Ascii("ributes"),
        dictgen::InsensitiveStr::Ascii("tribute"),
        dictgen::InsensitiveStr::Ascii("tributes"),
    ],
    values: &[
        &["artemis"],
        &["attribs"],
        &["attribute"],
        &["attribute"],
        &["attributed"],
        &["attributes"],
        &["articulate"],
        &["artifact"],
        &["artifacts"],
        &["artillery"],
        &["attrition"],
        &["atrocities"],
        &["atrocities"],
        &["agronomical", "astronomical"],
        &["atrocities"],
        &["attribute"],
        &["attributes"],
        &["attribute"],
        &["attributes"],
    ],
    range: 3..=8,
};

static WORD_ATQ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ATQ_CHILDREN),
    value: None,
};

pub static WORD_ATQ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("uired")],
    values: &[&["acquired"]],
    range: 5..=5,
};

static WORD_ATO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ATO_CHILDREN),
    value: None,
};

pub static WORD_ATO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("matically"),
        dictgen::InsensitiveStr::Ascii("mical"),
        dictgen::InsensitiveStr::Ascii("micly"),
        dictgen::InsensitiveStr::Ascii("miticity"),
        dictgen::InsensitiveStr::Ascii("msphere"),
        dictgen::InsensitiveStr::Ascii("mspheric"),
        dictgen::InsensitiveStr::Ascii("mtic"),
        dictgen::InsensitiveStr::Ascii("mtical"),
        dictgen::InsensitiveStr::Ascii("mtically"),
        dictgen::InsensitiveStr::Ascii("mticaly"),
        dictgen::InsensitiveStr::Ascii("mticlly"),
        dictgen::InsensitiveStr::Ascii("mticly"),
        dictgen::InsensitiveStr::Ascii("mzier"),
        dictgen::InsensitiveStr::Ascii("recovery"),
        dictgen::InsensitiveStr::Ascii("rney"),
    ],
    values: &[
        &["automatically"],
        &["atomic"],
        &["atomically"],
        &["atomicity"],
        &["atmosphere"],
        &["atmospheric"],
        &["atomic", "automatic"],
        &["automatic"],
        &["automatically"],
        &["automatically"],
        &["automatically"],
        &["automatically"],
        &["atomizer"],
        &["autorecovery"],
        &["attorney"],
    ],
    range: 4..=9,
};

static WORD_ATM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ATM_CHILDREN),
    value: None,
};

pub static WORD_ATM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("oic"),
        dictgen::InsensitiveStr::Ascii("oically"),
        dictgen::InsensitiveStr::Ascii("oizer"),
        dictgen::InsensitiveStr::Ascii("opshere"),
        dictgen::InsensitiveStr::Ascii("opsheric"),
        dictgen::InsensitiveStr::Ascii("oshpere"),
        dictgen::InsensitiveStr::Ascii("oshperic"),
        dictgen::InsensitiveStr::Ascii("osoheric"),
        dictgen::InsensitiveStr::Ascii("osphereic"),
        dictgen::InsensitiveStr::Ascii("osphir"),
    ],
    values: &[
        &["atomic"],
        &["atomically"],
        &["atomizer"],
        &["atmosphere"],
        &["atmospheric"],
        &["atmosphere"],
        &["atmospheric"],
        &["atmospheric"],
        &["atmospheric"],
        &["atmospheric"],
    ],
    range: 3..=9,
};

static WORD_ATL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ATL_CHILDREN),
    value: None,
};

pub static WORD_ATL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("antc"),
        dictgen::InsensitiveStr::Ascii("antia"),
        dictgen::InsensitiveStr::Ascii("eats"),
        dictgen::InsensitiveStr::Ascii("esat"),
        dictgen::InsensitiveStr::Ascii("l"),
    ],
    values: &[
        &["atlantic"],
        &["atlanta"],
        &["atleast"],
        &["atleast"],
        &["all"],
    ],
    range: 1..=5,
};

static WORD_ATI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ATI_CHILDREN),
    value: None,
};

pub static WORD_ATI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ttude"),
        dictgen::InsensitiveStr::Ascii("ve"),
    ],
    values: &[&["attitude"], &["active", "native"]],
    range: 2..=5,
};

static WORD_ATH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ATH_CHILDREN),
    value: None,
};

pub static WORD_ATH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eisim"),
        dictgen::InsensitiveStr::Ascii("eistc"),
        dictgen::InsensitiveStr::Ascii("eistical"),
        dictgen::InsensitiveStr::Ascii("eistisch"),
        dictgen::InsensitiveStr::Ascii("eltes"),
        dictgen::InsensitiveStr::Ascii("eltic"),
        dictgen::InsensitiveStr::Ascii("elticism"),
        dictgen::InsensitiveStr::Ascii("eltics"),
        dictgen::InsensitiveStr::Ascii("enean"),
        dictgen::InsensitiveStr::Ascii("eneans"),
        dictgen::InsensitiveStr::Ascii("er"),
        dictgen::InsensitiveStr::Ascii("esim"),
        dictgen::InsensitiveStr::Ascii("esitic"),
        dictgen::InsensitiveStr::Ascii("esits"),
        dictgen::InsensitiveStr::Ascii("etlic"),
        dictgen::InsensitiveStr::Ascii("etlics"),
        dictgen::InsensitiveStr::Ascii("ients"),
        dictgen::InsensitiveStr::Ascii("iesm"),
        dictgen::InsensitiveStr::Ascii("iest"),
        dictgen::InsensitiveStr::Ascii("iestic"),
        dictgen::InsensitiveStr::Ascii("iets"),
        dictgen::InsensitiveStr::Ascii("letecism"),
        dictgen::InsensitiveStr::Ascii("leticisim"),
        dictgen::InsensitiveStr::Ascii("leticm"),
        dictgen::InsensitiveStr::Ascii("leticos"),
        dictgen::InsensitiveStr::Ascii("leticsim"),
        dictgen::InsensitiveStr::Ascii("leticsm"),
        dictgen::InsensitiveStr::Ascii("letiscm"),
        dictgen::InsensitiveStr::Ascii("letisicm"),
        dictgen::InsensitiveStr::Ascii("letisim"),
        dictgen::InsensitiveStr::Ascii("letisism"),
        dictgen::InsensitiveStr::Ascii("lets"),
        dictgen::InsensitiveStr::Ascii("orization"),
        dictgen::InsensitiveStr::Ascii("ough"),
        dictgen::InsensitiveStr::Ascii("ron"),
        dictgen::InsensitiveStr::Ascii("ros"),
    ],
    values: &[
        &["atheism"],
        &["atheistic"],
        &["atheistic"],
        &["atheistic"],
        &["athletes"],
        &["athletic"],
        &["athleticism"],
        &["athletics"],
        &["athenian"],
        &["athenians"],
        &["other"],
        &["atheism"],
        &["atheistic"],
        &["atheists"],
        &["athletic"],
        &["athletics"],
        &["atheist"],
        &["atheism"],
        &["atheist"],
        &["atheistic"],
        &["atheist"],
        &["athleticism"],
        &["athleticism"],
        &["athleticism"],
        &["athletics"],
        &["athleticism"],
        &["athleticism"],
        &["athleticism"],
        &["athleticism"],
        &["athleticism"],
        &["athleticism"],
        &["athletes"],
        &["authorization"],
        &["although"],
        &["athlon"],
        &["atheros"],
    ],
    range: 2..=9,
};

static WORD_ATE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ATE_CHILDREN),
    value: None,
};

pub static WORD_ATE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("last"),
        dictgen::InsensitiveStr::Ascii("mpt"),
        dictgen::InsensitiveStr::Ascii("mpting"),
        dictgen::InsensitiveStr::Ascii("mpts"),
        dictgen::InsensitiveStr::Ascii("ndance"),
        dictgen::InsensitiveStr::Ascii("nded"),
        dictgen::InsensitiveStr::Ascii("ndee"),
        dictgen::InsensitiveStr::Ascii("nds"),
        dictgen::InsensitiveStr::Ascii("ntion"),
        dictgen::InsensitiveStr::Ascii("rnies"),
        dictgen::InsensitiveStr::Ascii("rny"),
    ],
    values: &[
        &["atleast"],
        &["attempt"],
        &["attempting"],
        &["attempts"],
        &["attendance"],
        &["attended"],
        &["attendee"],
        &["attends"],
        &["attention"],
        &["attorneys"],
        &["attorney"],
    ],
    range: 3..=6,
};

static WORD_ATC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ATC_CHILDREN),
    value: None,
};

pub static WORD_ATC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ualy")],
    values: &[&["actually"]],
    range: 4..=4,
};

static WORD_ATA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ATA_CHILDREN),
    value: None,
};

pub static WORD_ATA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ch"),
        dictgen::InsensitiveStr::Ascii("ched"),
        dictgen::InsensitiveStr::Ascii("ching"),
        dictgen::InsensitiveStr::Ascii("chment"),
        dictgen::InsensitiveStr::Ascii("chments"),
        dictgen::InsensitiveStr::Ascii("ck"),
        dictgen::InsensitiveStr::Ascii("in"),
        dictgen::InsensitiveStr::Ascii("log"),
        dictgen::InsensitiveStr::Ascii("tch"),
        dictgen::InsensitiveStr::Ascii("tchable"),
        dictgen::InsensitiveStr::Ascii("tched"),
        dictgen::InsensitiveStr::Ascii("tches"),
        dictgen::InsensitiveStr::Ascii("tching"),
        dictgen::InsensitiveStr::Ascii("tchment"),
        dictgen::InsensitiveStr::Ascii("tchments"),
    ],
    values: &[
        &["attach"],
        &["attached"],
        &["attaching"],
        &["attachment"],
        &["attachments"],
        &["attack"],
        &["attain"],
        &["catalog"],
        &["attach"],
        &["attachable"],
        &["attached"],
        &["attaches"],
        &["attaching"],
        &["attachment"],
        &["attachments"],
    ],
    range: 2..=8,
};

static WORD_AS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_AS_CHILDREN),
    value: None,
};

static WORD_AS_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_ASA_NODE),
    Some(&WORD_ASB_NODE),
    Some(&WORD_ASC_NODE),
    Some(&WORD_ASD_NODE),
    Some(&WORD_ASE_NODE),
    None,
    None,
    Some(&WORD_ASH_NODE),
    Some(&WORD_ASI_NODE),
    None,
    Some(&WORD_ASK_NODE),
    Some(&WORD_ASL_NODE),
    None,
    Some(&WORD_ASN_NODE),
    Some(&WORD_ASO_NODE),
    Some(&WORD_ASP_NODE),
    None,
    None,
    Some(&WORD_ASS_NODE),
    Some(&WORD_AST_NODE),
    Some(&WORD_ASU_NODE),
    None,
    Some(&WORD_ASW_NODE),
    None,
    Some(&WORD_ASY_NODE),
    None,
];

static WORD_ASY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ASY_CHILDREN),
    value: None,
};

pub static WORD_ASY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("chronize"),
        dictgen::InsensitiveStr::Ascii("chronized"),
        dictgen::InsensitiveStr::Ascii("chronous"),
        dictgen::InsensitiveStr::Ascii("chronously"),
        dictgen::InsensitiveStr::Ascii("cn"),
        dictgen::InsensitiveStr::Ascii("cnhronous"),
        dictgen::InsensitiveStr::Ascii("cnhronously"),
        dictgen::InsensitiveStr::Ascii("cronous"),
        dictgen::InsensitiveStr::Ascii("metic"),
        dictgen::InsensitiveStr::Ascii("metri"),
        dictgen::InsensitiveStr::Ascii("metric"),
        dictgen::InsensitiveStr::Ascii("metrical"),
        dictgen::InsensitiveStr::Ascii("metricaly"),
        dictgen::InsensitiveStr::Ascii("mmeric"),
        dictgen::InsensitiveStr::Ascii("mmetri"),
        dictgen::InsensitiveStr::Ascii("nchnous"),
        dictgen::InsensitiveStr::Ascii("nchonous"),
        dictgen::InsensitiveStr::Ascii("nchonously"),
        dictgen::InsensitiveStr::Ascii("nchornous"),
        dictgen::InsensitiveStr::Ascii("nchornously"),
        dictgen::InsensitiveStr::Ascii("nchoronous"),
        dictgen::InsensitiveStr::Ascii("nchrnous"),
        dictgen::InsensitiveStr::Ascii("nchrnously"),
        dictgen::InsensitiveStr::Ascii("nchromous"),
        dictgen::InsensitiveStr::Ascii("nchron"),
        dictgen::InsensitiveStr::Ascii("nchroneously"),
        dictgen::InsensitiveStr::Ascii("nchronious"),
        dictgen::InsensitiveStr::Ascii("nchronlous"),
        dictgen::InsensitiveStr::Ascii("nchrons"),
        dictgen::InsensitiveStr::Ascii("nchronus"),
        dictgen::InsensitiveStr::Ascii("nchroous"),
        dictgen::InsensitiveStr::Ascii("nchrounous"),
        dictgen::InsensitiveStr::Ascii("nchrounsly"),
        dictgen::InsensitiveStr::Ascii("ncronous"),
        dictgen::InsensitiveStr::Ascii("ncronously"),
        dictgen::InsensitiveStr::Ascii("nnc"),
        dictgen::InsensitiveStr::Ascii("nschron"),
    ],
    values: &[
        &["asynchronize"],
        &["asynchronized"],
        &["asynchronous"],
        &["asynchronously"],
        &["async"],
        &["asynchronous"],
        &["asynchronously"],
        &["asynchronous"],
        &["asymmetric"],
        &["asymmetric", "asymmetry"],
        &["asymmetric"],
        &["asymmetrical"],
        &["asymmetrically"],
        &["asymmetric"],
        &["asymmetric", "asymmetry"],
        &["asynchronous"],
        &["asynchronous"],
        &["asynchronously"],
        &["asynchronous"],
        &["asynchronously"],
        &["asynchronous"],
        &["asynchronous"],
        &["asynchronously"],
        &["asynchronous"],
        &["asynchronous"],
        &["asynchronously"],
        &["asynchronous"],
        &["asynchronous"],
        &["asynchronous"],
        &["asynchronous"],
        &["asynchronous"],
        &["asynchronous"],
        &["asynchronously"],
        &["asynchronous"],
        &["asynchronously"],
        &["async"],
        &["asynchronous"],
    ],
    range: 2..=12,
};

static WORD_ASW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ASW_CHILDREN),
    value: None,
};

pub static WORD_ASW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("age")],
    values: &[&["assuage"]],
    range: 3..=3,
};

static WORD_ASU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ASU_CHILDREN),
    value: None,
};

pub static WORD_ASU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("do"),
        dictgen::InsensitiveStr::Ascii("me"),
        dictgen::InsensitiveStr::Ascii("med"),
        dictgen::InsensitiveStr::Ascii("mes"),
        dictgen::InsensitiveStr::Ascii("ming"),
        dictgen::InsensitiveStr::Ascii("mption"),
        dictgen::InsensitiveStr::Ascii("mtotic"),
        dictgen::InsensitiveStr::Ascii("re"),
        dictgen::InsensitiveStr::Ascii("terity"),
        dictgen::InsensitiveStr::Ascii("tralian"),
        dictgen::InsensitiveStr::Ascii("tria"),
        dictgen::InsensitiveStr::Ascii("trian"),
    ],
    values: &[
        &["sudo"],
        &["assume"],
        &["assumed"],
        &["assumes"],
        &["assuming"],
        &["assumption"],
        &["asymptotic"],
        &["assure"],
        &["austerity"],
        &["australian"],
        &["austria"],
        &["austrian"],
    ],
    range: 2..=7,
};

static WORD_AST_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AST_CHILDREN),
    value: None,
};

pub static WORD_AST_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("arisk"),
        dictgen::InsensitiveStr::Ascii("arisks"),
        dictgen::InsensitiveStr::Ascii("eorid"),
        dictgen::InsensitiveStr::Ascii("eorids"),
        dictgen::InsensitiveStr::Ascii("erices"),
        dictgen::InsensitiveStr::Ascii("ericks"),
        dictgen::InsensitiveStr::Ascii("erik"),
        dictgen::InsensitiveStr::Ascii("eriks"),
        dictgen::InsensitiveStr::Ascii("eriod"),
        dictgen::InsensitiveStr::Ascii("eriods"),
        dictgen::InsensitiveStr::Ascii("eroides"),
        dictgen::InsensitiveStr::Ascii("erois"),
        dictgen::InsensitiveStr::Ascii("ersik"),
        dictgen::InsensitiveStr::Ascii("ethic"),
        dictgen::InsensitiveStr::Ascii("ethically"),
        dictgen::InsensitiveStr::Ascii("ethicism"),
        dictgen::InsensitiveStr::Ascii("ethics"),
        dictgen::InsensitiveStr::Ascii("hetic"),
        dictgen::InsensitiveStr::Ascii("hetical"),
        dictgen::InsensitiveStr::Ascii("hetically"),
        dictgen::InsensitiveStr::Ascii("hetics"),
        dictgen::InsensitiveStr::Ascii("iimate"),
        dictgen::InsensitiveStr::Ascii("iimation"),
        dictgen::InsensitiveStr::Ascii("onashing"),
        dictgen::InsensitiveStr::Ascii("onising"),
        dictgen::InsensitiveStr::Ascii("onoshing"),
        dictgen::InsensitiveStr::Ascii("ornauts"),
        dictgen::InsensitiveStr::Ascii("ranauts"),
        dictgen::InsensitiveStr::Ascii("ranomical"),
        dictgen::InsensitiveStr::Ascii("rix"),
        dictgen::InsensitiveStr::Ascii("rixes"),
        dictgen::InsensitiveStr::Ascii("rixs"),
        dictgen::InsensitiveStr::Ascii("roanut"),
        dictgen::InsensitiveStr::Ascii("roid"),
        dictgen::InsensitiveStr::Ascii("romonical"),
        dictgen::InsensitiveStr::Ascii("ronat"),
        dictgen::InsensitiveStr::Ascii("ronatus"),
        dictgen::InsensitiveStr::Ascii("ronaught"),
        dictgen::InsensitiveStr::Ascii("ronaunt"),
        dictgen::InsensitiveStr::Ascii("ronaunts"),
        dictgen::InsensitiveStr::Ascii("ronautas"),
        dictgen::InsensitiveStr::Ascii("ronautes"),
        dictgen::InsensitiveStr::Ascii("ronautlis"),
        dictgen::InsensitiveStr::Ascii("ronimical"),
        dictgen::InsensitiveStr::Ascii("ronomia"),
        dictgen::InsensitiveStr::Ascii("ronomicly"),
        dictgen::InsensitiveStr::Ascii("ronouts"),
        dictgen::InsensitiveStr::Ascii("ronuat"),
        dictgen::InsensitiveStr::Ascii("ronuats"),
        dictgen::InsensitiveStr::Ascii("rounat"),
    ],
    values: &[
        &["asterisk"],
        &["asterisks"],
        &["asteroid"],
        &["asteroids"],
        &["asterisks"],
        &["asterisk"],
        &["asterisk"],
        &["asterisk", "asterisks"],
        &["asteroid"],
        &["asteroids"],
        &["asteroids"],
        &["asteroids"],
        &["asterisk"],
        &["aesthetic"],
        &["aesthetically"],
        &["aestheticism"],
        &["aesthetics"],
        &["aesthetic"],
        &["aesthetical"],
        &["aesthetically"],
        &["aesthetics"],
        &["estimate"],
        &["estimation"],
        &["astonishing"],
        &["astonishing"],
        &["astonishing"],
        &["astronauts"],
        &["astronauts"],
        &["astronomical"],
        &["asterisk"],
        &["asterisks"],
        &["asterisks"],
        &["astronaut"],
        &["asteroid"],
        &["astronomical"],
        &["astronaut"],
        &["astronauts"],
        &["astronaut"],
        &["astronaut"],
        &["astronaut"],
        &["astronauts"],
        &["astronauts"],
        &["astronauts"],
        &["astronomical"],
        &["astronomical"],
        &["astronomical"],
        &["astronauts"],
        &["astronaut"],
        &["astronauts"],
        &["astronaut"],
    ],
    range: 3..=9,
};

static WORD_ASS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_ASS_CHILDREN),
    value: None,
};

static WORD_ASS_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_ASSA_NODE),
    None,
    Some(&WORD_ASSC_NODE),
    None,
    Some(&WORD_ASSE_NODE),
    Some(&WORD_ASSF_NODE),
    Some(&WORD_ASSG_NODE),
    Some(&WORD_ASSH_NODE),
    Some(&WORD_ASSI_NODE),
    None,
    None,
    None,
    Some(&WORD_ASSM_NODE),
    Some(&WORD_ASSN_NODE),
    Some(&WORD_ASSO_NODE),
    None,
    None,
    None,
    Some(&WORD_ASSS_NODE),
    None,
    Some(&WORD_ASSU_NODE),
    None,
    None,
    None,
    Some(&WORD_ASSY_NODE),
    None,
];

static WORD_ASSY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ASSY_CHILDREN),
    value: None,
};

pub static WORD_ASSY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("metric"),
        dictgen::InsensitiveStr::Ascii("metrical"),
        dictgen::InsensitiveStr::Ascii("metries"),
        dictgen::InsensitiveStr::Ascii("metry"),
        dictgen::InsensitiveStr::Ascii("mmetric"),
        dictgen::InsensitiveStr::Ascii("mmetrical"),
        dictgen::InsensitiveStr::Ascii("mmetries"),
        dictgen::InsensitiveStr::Ascii("mmetry"),
        dictgen::InsensitiveStr::Ascii("mptote"),
        dictgen::InsensitiveStr::Ascii("mptotes"),
        dictgen::InsensitiveStr::Ascii("mptotic"),
        dictgen::InsensitiveStr::Ascii("mptotically"),
        dictgen::InsensitiveStr::Ascii("mthotic"),
        dictgen::InsensitiveStr::Ascii("mtote"),
        dictgen::InsensitiveStr::Ascii("mtotes"),
        dictgen::InsensitiveStr::Ascii("mtotic"),
        dictgen::InsensitiveStr::Ascii("mtotically"),
    ],
    values: &[
        &["asymmetric"],
        &["asymmetrical"],
        &["asymmetries"],
        &["asymmetry"],
        &["asymmetric"],
        &["asymmetrical"],
        &["asymmetries"],
        &["asymmetry"],
        &["asymptote"],
        &["asymptotes"],
        &["asymptotic"],
        &["asymptotically"],
        &["asymptotic"],
        &["asymptote"],
        &["asymptotes"],
        &["asymptotic"],
        &["asymptotically"],
    ],
    range: 5..=11,
};

static WORD_ASSU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ASSU_CHILDREN),
    value: None,
};

pub static WORD_ASSU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("alt"),
        dictgen::InsensitiveStr::Ascii("alted"),
        dictgen::InsensitiveStr::Ascii("alts"),
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("embly"),
        dictgen::InsensitiveStr::Ascii("lated"),
        dictgen::InsensitiveStr::Ascii("m"),
        dictgen::InsensitiveStr::Ascii("ma"),
        dictgen::InsensitiveStr::Ascii("mad"),
        dictgen::InsensitiveStr::Ascii("mang"),
        dictgen::InsensitiveStr::Ascii("mas"),
        dictgen::InsensitiveStr::Ascii("mbe"),
        dictgen::InsensitiveStr::Ascii("mbed"),
        dictgen::InsensitiveStr::Ascii("mbes"),
        dictgen::InsensitiveStr::Ascii("mbing"),
        dictgen::InsensitiveStr::Ascii("mend"),
        dictgen::InsensitiveStr::Ascii("mimg"),
        dictgen::InsensitiveStr::Ascii("mking"),
        dictgen::InsensitiveStr::Ascii("mme"),
        dictgen::InsensitiveStr::Ascii("mmed"),
        dictgen::InsensitiveStr::Ascii("mmes"),
        dictgen::InsensitiveStr::Ascii("mming"),
        dictgen::InsensitiveStr::Ascii("mne"),
        dictgen::InsensitiveStr::Ascii("mned"),
        dictgen::InsensitiveStr::Ascii("mnes"),
        dictgen::InsensitiveStr::Ascii("mning"),
        dictgen::InsensitiveStr::Ascii("mong"),
        dictgen::InsensitiveStr::Ascii("motion"),
        dictgen::InsensitiveStr::Ascii("motions"),
        dictgen::InsensitiveStr::Ascii("mpation"),
        dictgen::InsensitiveStr::Ascii("mpted"),
        dictgen::InsensitiveStr::Ascii("mptious"),
        dictgen::InsensitiveStr::Ascii("ms"),
        dictgen::InsensitiveStr::Ascii("mse"),
        dictgen::InsensitiveStr::Ascii("mtion"),
        dictgen::InsensitiveStr::Ascii("mtions"),
        dictgen::InsensitiveStr::Ascii("mtpion"),
        dictgen::InsensitiveStr::Ascii("mtpions"),
        dictgen::InsensitiveStr::Ascii("mu"),
        dictgen::InsensitiveStr::Ascii("mud"),
        dictgen::InsensitiveStr::Ascii("mue"),
        dictgen::InsensitiveStr::Ascii("mued"),
        dictgen::InsensitiveStr::Ascii("mues"),
        dictgen::InsensitiveStr::Ascii("muing"),
        dictgen::InsensitiveStr::Ascii("mung"),
        dictgen::InsensitiveStr::Ascii("muption"),
        dictgen::InsensitiveStr::Ascii("muptions"),
        dictgen::InsensitiveStr::Ascii("mus"),
        dictgen::InsensitiveStr::Ascii("pmption"),
        dictgen::InsensitiveStr::Ascii("pmtion"),
        dictgen::InsensitiveStr::Ascii("ption"),
        dictgen::InsensitiveStr::Ascii("ptions"),
        dictgen::InsensitiveStr::Ascii("rred"),
    ],
    values: &[
        &["assault"],
        &["assaulted"],
        &["assaults"],
        &["assume", "assure"],
        &["assumed", "assured"],
        &["assembly"],
        &["assaulted"],
        &["assume"],
        &["assume"],
        &["assumed"],
        &["assuming"],
        &["assumes"],
        &["assume"],
        &["assumed"],
        &["assumes"],
        &["assuming"],
        &["assumed"],
        &["assuming"],
        &["assuming"],
        &["assume"],
        &["assumed"],
        &["assumes"],
        &["assuming"],
        &["assume"],
        &["assumed"],
        &["assumes"],
        &["assuming"],
        &["assuming"],
        &["assumption"],
        &["assumptions"],
        &["assumption"],
        &["assumed"],
        &["assumptions"],
        &["assumes"],
        &["assumes"],
        &["assumption"],
        &["assumptions"],
        &["assumption"],
        &["assumptions"],
        &["assume"],
        &["assumed"],
        &["assume"],
        &["assumed"],
        &["assumes"],
        &["assuming"],
        &["assuming"],
        &["assumption"],
        &["assumptions"],
        &["assumes"],
        &["assumption"],
        &["assumptions"],
        &["assumption"],
        &["assumptions"],
        &["assured"],
    ],
    range: 1..=8,
};

static WORD_ASSS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ASSS_CHILDREN),
    value: None,
};

pub static WORD_ASSS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("asin"),
        dictgen::InsensitiveStr::Ascii("asins"),
        dictgen::InsensitiveStr::Ascii("assans"),
        dictgen::InsensitiveStr::Ascii("embler"),
        dictgen::InsensitiveStr::Ascii("embly"),
        dictgen::InsensitiveStr::Ascii("ert"),
        dictgen::InsensitiveStr::Ascii("ertion"),
        dictgen::InsensitiveStr::Ascii("et"),
        dictgen::InsensitiveStr::Ascii("its"),
        dictgen::InsensitiveStr::Ascii("ociate"),
        dictgen::InsensitiveStr::Ascii("ociated"),
        dictgen::InsensitiveStr::Ascii("ociation"),
        dictgen::InsensitiveStr::Ascii("ume"),
        dictgen::InsensitiveStr::Ascii("umes"),
        dictgen::InsensitiveStr::Ascii("uming"),
    ],
    values: &[
        &["assassin"],
        &["assassins"],
        &["assassins"],
        &["assembler"],
        &["assembly"],
        &["assert"],
        &["assertion"],
        &["asset"],
        &["assists"],
        &["associated"],
        &["associated"],
        &["association"],
        &["assume"],
        &["assumes"],
        &["assuming"],
    ],
    range: 2..=8,
};

static WORD_ASSO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_ASSO_CHILDREN),
    value: None,
};

static WORD_ASSO_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_ASSOA_NODE),
    None,
    Some(&WORD_ASSOC_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_ASSOI_NODE),
    None,
    None,
    None,
    Some(&WORD_ASSOM_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_ASSOS_NODE),
    Some(&WORD_ASSOT_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_ASSOZ_NODE),
];

static WORD_ASSOZ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ASSOZ_CHILDREN),
    value: None,
};

pub static WORD_ASSOZ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("iated"),
        dictgen::InsensitiveStr::Ascii("iation"),
    ],
    values: &[&["associated"], &["association"]],
    range: 5..=6,
};

static WORD_ASSOT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ASSOT_CHILDREN),
    value: None,
};

pub static WORD_ASSOT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("iated"),
        dictgen::InsensitiveStr::Ascii("iation"),
        dictgen::InsensitiveStr::Ascii("iations"),
    ],
    values: &[&["associated"], &["association"], &["associations"]],
    range: 5..=7,
};

static WORD_ASSOS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ASSOS_CHILDREN),
    value: None,
};

pub static WORD_ASSOS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ciate"),
        dictgen::InsensitiveStr::Ascii("ciated"),
        dictgen::InsensitiveStr::Ascii("ciates"),
        dictgen::InsensitiveStr::Ascii("ciating"),
        dictgen::InsensitiveStr::Ascii("iacition"),
        dictgen::InsensitiveStr::Ascii("iacitions"),
        dictgen::InsensitiveStr::Ascii("iacted"),
        dictgen::InsensitiveStr::Ascii("iate"),
        dictgen::InsensitiveStr::Ascii("iated"),
        dictgen::InsensitiveStr::Ascii("iates"),
        dictgen::InsensitiveStr::Ascii("iating"),
        dictgen::InsensitiveStr::Ascii("iation"),
        dictgen::InsensitiveStr::Ascii("iations"),
        dictgen::InsensitiveStr::Ascii("iative"),
        dictgen::InsensitiveStr::Ascii("ication"),
    ],
    values: &[
        &["associate"],
        &["associated"],
        &["associates"],
        &["associating"],
        &["association"],
        &["associations"],
        &["associated"],
        &["associate"],
        &["associated"],
        &["associates"],
        &["associating"],
        &["association"],
        &["associations"],
        &["associative"],
        &["assassination"],
    ],
    range: 4..=9,
};

static WORD_ASSOM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ASSOM_CHILDREN),
    value: None,
};

pub static WORD_ASSOM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ption")],
    values: &[&["assumption"]],
    range: 5..=5,
};

static WORD_ASSOI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ASSOI_CHILDREN),
    value: None,
};

pub static WORD_ASSOI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ated"),
        dictgen::InsensitiveStr::Ascii("cate"),
        dictgen::InsensitiveStr::Ascii("cated"),
        dictgen::InsensitiveStr::Ascii("cates"),
        dictgen::InsensitiveStr::Ascii("cation"),
        dictgen::InsensitiveStr::Ascii("cations"),
        dictgen::InsensitiveStr::Ascii("ciative"),
    ],
    values: &[
        &["associated"],
        &["associate"],
        &["associated"],
        &["associates"],
        &["association"],
        &["associations"],
        &["associative"],
    ],
    range: 4..=7,
};

static WORD_ASSOC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ASSOC_CHILDREN),
    value: None,
};

pub static WORD_ASSOC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aited"),
        dictgen::InsensitiveStr::Ascii("aites"),
        dictgen::InsensitiveStr::Ascii("aition"),
        dictgen::InsensitiveStr::Ascii("ate"),
        dictgen::InsensitiveStr::Ascii("ated"),
        dictgen::InsensitiveStr::Ascii("ates"),
        dictgen::InsensitiveStr::Ascii("ating"),
        dictgen::InsensitiveStr::Ascii("ation"),
        dictgen::InsensitiveStr::Ascii("ations"),
        dictgen::InsensitiveStr::Ascii("ciated"),
        dictgen::InsensitiveStr::Ascii("ciation"),
        dictgen::InsensitiveStr::Ascii("ciations"),
        dictgen::InsensitiveStr::Ascii("ciative"),
        dictgen::InsensitiveStr::Ascii("iaiton"),
        dictgen::InsensitiveStr::Ascii("iatated"),
        dictgen::InsensitiveStr::Ascii("iatd"),
        dictgen::InsensitiveStr::Ascii("iatie"),
        dictgen::InsensitiveStr::Ascii("iatied"),
        dictgen::InsensitiveStr::Ascii("iaties"),
        dictgen::InsensitiveStr::Ascii("iatin"),
        dictgen::InsensitiveStr::Ascii("iationg"),
        dictgen::InsensitiveStr::Ascii("iationthis"),
        dictgen::InsensitiveStr::Ascii("iato"),
        dictgen::InsensitiveStr::Ascii("iaton"),
        dictgen::InsensitiveStr::Ascii("iatons"),
        dictgen::InsensitiveStr::Ascii("icate"),
        dictgen::InsensitiveStr::Ascii("icated"),
        dictgen::InsensitiveStr::Ascii("icates"),
        dictgen::InsensitiveStr::Ascii("icating"),
        dictgen::InsensitiveStr::Ascii("idated"),
        dictgen::InsensitiveStr::Ascii("ieate"),
        dictgen::InsensitiveStr::Ascii("ieated"),
        dictgen::InsensitiveStr::Ascii("ieates"),
        dictgen::InsensitiveStr::Ascii("ieating"),
        dictgen::InsensitiveStr::Ascii("ieation"),
        dictgen::InsensitiveStr::Ascii("ieations"),
        dictgen::InsensitiveStr::Ascii("ieted"),
        dictgen::InsensitiveStr::Ascii("isted"),
        dictgen::InsensitiveStr::Ascii("itated"),
        dictgen::InsensitiveStr::Ascii("ite"),
        dictgen::InsensitiveStr::Ascii("ited"),
        dictgen::InsensitiveStr::Ascii("ites"),
        dictgen::InsensitiveStr::Ascii("iting"),
        dictgen::InsensitiveStr::Ascii("ition"),
        dictgen::InsensitiveStr::Ascii("itions"),
        dictgen::InsensitiveStr::Ascii("itive"),
        dictgen::InsensitiveStr::Ascii("iuated"),
        dictgen::InsensitiveStr::Ascii("tion"),
    ],
    values: &[
        &["associated"],
        &["associates"],
        &["associations"],
        &["associate"],
        &["associated"],
        &["associates"],
        &["associating"],
        &["association"],
        &["associations"],
        &["associated"],
        &["association"],
        &["associations"],
        &["associative"],
        &["associations"],
        &["associated"],
        &["associated"],
        &["associated"],
        &["associated"],
        &["associates"],
        &["associations"],
        &["associating"],
        &["associations"],
        &["association"],
        &["association"],
        &["associations"],
        &["associate"],
        &["associated"],
        &["associates"],
        &["associating"],
        &["associated"],
        &["associate"],
        &["associated"],
        &["associates"],
        &["associating"],
        &["association"],
        &["associations"],
        &["associated"],
        &["associates"],
        &["associated"],
        &["associate"],
        &["associated"],
        &["associates"],
        &["associating"],
        &["association"],
        &["associations"],
        &["associative"],
        &["associated"],
        &["association"],
    ],
    range: 3..=10,
};

static WORD_ASSOA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ASSOA_CHILDREN),
    value: None,
};

pub static WORD_ASSOA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("iate"),
        dictgen::InsensitiveStr::Ascii("iated"),
        dictgen::InsensitiveStr::Ascii("iates"),
        dictgen::InsensitiveStr::Ascii("iating"),
        dictgen::InsensitiveStr::Ascii("iation"),
        dictgen::InsensitiveStr::Ascii("iations"),
        dictgen::InsensitiveStr::Ascii("iative"),
    ],
    values: &[
        &["associate"],
        &["associated"],
        &["associates"],
        &["associating"],
        &["association"],
        &["associations"],
        &["associative"],
    ],
    range: 4..=7,
};

static WORD_ASSN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ASSN_CHILDREN),
    value: None,
};

pub static WORD_ASSN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("age")],
    values: &[&["assange"]],
    range: 3..=3,
};

static WORD_ASSM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ASSM_CHILDREN),
    value: None,
};

pub static WORD_ASSM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("a"),
        dictgen::InsensitiveStr::Ascii("bler"),
        dictgen::InsensitiveStr::Ascii("eble"),
        dictgen::InsensitiveStr::Ascii("ebled"),
        dictgen::InsensitiveStr::Ascii("ebler"),
        dictgen::InsensitiveStr::Ascii("ebles"),
        dictgen::InsensitiveStr::Ascii("ebling"),
        dictgen::InsensitiveStr::Ascii("ebly"),
        dictgen::InsensitiveStr::Ascii("elber"),
        dictgen::InsensitiveStr::Ascii("ption"),
        dictgen::InsensitiveStr::Ascii("ptions"),
        dictgen::InsensitiveStr::Ascii("ume"),
        dictgen::InsensitiveStr::Ascii("umed"),
        dictgen::InsensitiveStr::Ascii("umes"),
        dictgen::InsensitiveStr::Ascii("uming"),
        dictgen::InsensitiveStr::Ascii("umption"),
        dictgen::InsensitiveStr::Ascii("umptions"),
    ],
    values: &[
        &["asthma"],
        &["assembler"],
        &["assemble"],
        &["assembled"],
        &["assembler"],
        &["assembles"],
        &["assembling"],
        &["assembly"],
        &["assembler"],
        &["assumption"],
        &["assumptions"],
        &["assume"],
        &["assumed"],
        &["assumes"],
        &["assuming"],
        &["assumption"],
        &["assumptions"],
    ],
    range: 1..=8,
};

static WORD_ASSI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_ASSI_CHILDREN),
    value: None,
};

static WORD_ASSI_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    Some(&WORD_ASSIC_NODE),
    Some(&WORD_ASSID_NODE),
    None,
    None,
    Some(&WORD_ASSIG_NODE),
    Some(&WORD_ASSIH_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_ASSIM_NODE),
    Some(&WORD_ASSIN_NODE),
    Some(&WORD_ASSIO_NODE),
    None,
    None,
    None,
    Some(&WORD_ASSIS_NODE),
    Some(&WORD_ASSIT_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_ASSIT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ASSIT_CHILDREN),
    value: Some(&["assist"]),
};

pub static WORD_ASSIT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ant"),
        dictgen::InsensitiveStr::Ascii("ion"),
    ],
    values: &[&["assistant"], &["assertion"]],
    range: 3..=3,
};

static WORD_ASSIS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ASSIS_CHILDREN),
    value: None,
};

pub static WORD_ASSIS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ance"),
        dictgen::InsensitiveStr::Ascii("ant"),
        dictgen::InsensitiveStr::Ascii("ants"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("nate"),
        dictgen::InsensitiveStr::Ascii("sinated"),
        dictgen::InsensitiveStr::Ascii("st"),
        dictgen::InsensitiveStr::Ascii("tanat"),
        dictgen::InsensitiveStr::Ascii("tans"),
        dictgen::InsensitiveStr::Ascii("tanse"),
        dictgen::InsensitiveStr::Ascii("tante"),
        dictgen::InsensitiveStr::Ascii("tantes"),
        dictgen::InsensitiveStr::Ascii("tat"),
        dictgen::InsensitiveStr::Ascii("tence"),
        dictgen::InsensitiveStr::Ascii("tendo"),
        dictgen::InsensitiveStr::Ascii("tent"),
        dictgen::InsensitiveStr::Ascii("tents"),
        dictgen::InsensitiveStr::Ascii("tsnt"),
    ],
    values: &[
        &["assistance"],
        &["assistant"],
        &["assistants"],
        &["assisting"],
        &["assassinate"],
        &["assassinated"],
        &["assists", "assist"],
        &["assistants"],
        &["assistants"],
        &["assistants"],
        &["assistance"],
        &["assistants"],
        &["assistants"],
        &["assistance"],
        &["assisted"],
        &["assistant"],
        &["assistants"],
        &["assistants"],
    ],
    range: 2..=7,
};

static WORD_ASSIO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ASSIO_CHILDREN),
    value: None,
};

pub static WORD_ASSIO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cate"),
        dictgen::InsensitiveStr::Ascii("cated"),
        dictgen::InsensitiveStr::Ascii("cates"),
        dictgen::InsensitiveStr::Ascii("cating"),
        dictgen::InsensitiveStr::Ascii("cation"),
        dictgen::InsensitiveStr::Ascii("ciate"),
        dictgen::InsensitiveStr::Ascii("ciated"),
        dictgen::InsensitiveStr::Ascii("ciates"),
        dictgen::InsensitiveStr::Ascii("ciating"),
        dictgen::InsensitiveStr::Ascii("ciation"),
    ],
    values: &[
        &["associate"],
        &["associated"],
        &["associates"],
        &["associating"],
        &["association"],
        &["associate"],
        &["associated"],
        &["associates"],
        &["associating"],
        &["association"],
    ],
    range: 4..=7,
};

static WORD_ASSIN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ASSIN_CHILDREN),
    value: None,
};

pub static WORD_ASSIN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("g"),
        dictgen::InsensitiveStr::Ascii("ged"),
        dictgen::InsensitiveStr::Ascii("ging"),
        dictgen::InsensitiveStr::Ascii("gled"),
        dictgen::InsensitiveStr::Ascii("gment"),
        dictgen::InsensitiveStr::Ascii("gments"),
        dictgen::InsensitiveStr::Ascii("gned"),
        dictgen::InsensitiveStr::Ascii("gnment"),
        dictgen::InsensitiveStr::Ascii("gs"),
        dictgen::InsensitiveStr::Ascii("ment"),
    ],
    values: &[
        &["assigned"],
        &["assign"],
        &["assigned"],
        &["assigning"],
        &["assigned"],
        &["assignment"],
        &["assignments"],
        &["assigned"],
        &["assignment"],
        &["assigns"],
        &["assignment"],
    ],
    range: 1..=6,
};

static WORD_ASSIM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ASSIM_CHILDREN),
    value: None,
};

pub static WORD_ASSIM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("alate"),
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("ialted"),
        dictgen::InsensitiveStr::Ascii("ilant"),
        dictgen::InsensitiveStr::Ascii("ilare"),
        dictgen::InsensitiveStr::Ascii("ilatie"),
        dictgen::InsensitiveStr::Ascii("ile"),
        dictgen::InsensitiveStr::Ascii("ilerat"),
        dictgen::InsensitiveStr::Ascii("iliate"),
        dictgen::InsensitiveStr::Ascii("liate"),
        dictgen::InsensitiveStr::Ascii("liated"),
        dictgen::InsensitiveStr::Ascii("tote"),
        dictgen::InsensitiveStr::Ascii("totes"),
        dictgen::InsensitiveStr::Ascii("ulate"),
    ],
    values: &[
        &["assimilate"],
        &["assume"],
        &["assimilate"],
        &["assimilate"],
        &["assimilate"],
        &["assimilate"],
        &["assimilate"],
        &["assimilate"],
        &["assimilate"],
        &["assimilate"],
        &["assimilate"],
        &["asymptote"],
        &["asymptotes"],
        &["assimilate"],
    ],
    range: 1..=6,
};

static WORD_ASSIH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ASSIH_CHILDREN),
    value: None,
};

pub static WORD_ASSIH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("nment"),
        dictgen::InsensitiveStr::Ascii("nments"),
    ],
    values: &[&["assignment"], &["assignments"]],
    range: 5..=6,
};

static WORD_ASSIG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ASSIG_CHILDREN),
    value: None,
};

pub static WORD_ASSIG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("end"),
        dictgen::InsensitiveStr::Ascii("h"),
        dictgen::InsensitiveStr::Ascii("hed"),
        dictgen::InsensitiveStr::Ascii("hee"),
        dictgen::InsensitiveStr::Ascii("hees"),
        dictgen::InsensitiveStr::Ascii("her"),
        dictgen::InsensitiveStr::Ascii("hers"),
        dictgen::InsensitiveStr::Ascii("hing"),
        dictgen::InsensitiveStr::Ascii("hor"),
        dictgen::InsensitiveStr::Ascii("hors"),
        dictgen::InsensitiveStr::Ascii("hs"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("ment"),
        dictgen::InsensitiveStr::Ascii("ments"),
        dictgen::InsensitiveStr::Ascii("mnent"),
        dictgen::InsensitiveStr::Ascii("nalble"),
        dictgen::InsensitiveStr::Ascii("nanle"),
        dictgen::InsensitiveStr::Ascii("ne"),
        dictgen::InsensitiveStr::Ascii("nement"),
        dictgen::InsensitiveStr::Ascii("nements"),
        dictgen::InsensitiveStr::Ascii("nemnt"),
        dictgen::InsensitiveStr::Ascii("nemnts"),
        dictgen::InsensitiveStr::Ascii("nemtn"),
        dictgen::InsensitiveStr::Ascii("nend"),
        dictgen::InsensitiveStr::Ascii("nenment"),
        dictgen::InsensitiveStr::Ascii("nenmentes"),
        dictgen::InsensitiveStr::Ascii("nenments"),
        dictgen::InsensitiveStr::Ascii("nenmet"),
        dictgen::InsensitiveStr::Ascii("nes"),
        dictgen::InsensitiveStr::Ascii("nmenet"),
        dictgen::InsensitiveStr::Ascii("nmens"),
        dictgen::InsensitiveStr::Ascii("nmet"),
        dictgen::InsensitiveStr::Ascii("nmetns"),
        dictgen::InsensitiveStr::Ascii("nmnet"),
        dictgen::InsensitiveStr::Ascii("nt"),
        dictgen::InsensitiveStr::Ascii("ntment"),
    ],
    values: &[
        &["assigned"],
        &["assigned"],
        &["assign"],
        &["assigned"],
        &["assignee"],
        &["assignees"],
        &["assigner"],
        &["assigners"],
        &["assigning"],
        &["assignor"],
        &["assignors"],
        &["assigns"],
        &["assigning"],
        &["assignment"],
        &["assignments"],
        &["assignment"],
        &["assignable"],
        &["assignable"],
        &["assign", "assigned"],
        &["assignment"],
        &["assignments"],
        &["assignment"],
        &["assignments"],
        &["assignment"],
        &["assigned"],
        &["assignment"],
        &["assignments"],
        &["assignments"],
        &["assignment"],
        &["assigns"],
        &["assignment"],
        &["assignments"],
        &["assignment"],
        &["assignments"],
        &["assignment"],
        &["assign"],
        &["assignment"],
    ],
    range: 1..=9,
};

static WORD_ASSID_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ASSID_CHILDREN),
    value: None,
};

pub static WORD_ASSID_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("e")],
    values: &[&["aside"]],
    range: 1..=1,
};

static WORD_ASSIC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ASSIC_CHILDREN),
    value: None,
};

pub static WORD_ASSIC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ate"),
        dictgen::InsensitiveStr::Ascii("ated"),
        dictgen::InsensitiveStr::Ascii("ates"),
        dictgen::InsensitiveStr::Ascii("ating"),
        dictgen::InsensitiveStr::Ascii("ation"),
        dictgen::InsensitiveStr::Ascii("ations"),
        dictgen::InsensitiveStr::Ascii("iate"),
        dictgen::InsensitiveStr::Ascii("iated"),
        dictgen::InsensitiveStr::Ascii("iates"),
        dictgen::InsensitiveStr::Ascii("iation"),
        dictgen::InsensitiveStr::Ascii("iations"),
        dictgen::InsensitiveStr::Ascii("ieted"),
    ],
    values: &[
        &["associate"],
        &["associated"],
        &["associates"],
        &["associating"],
        &["association"],
        &["associations"],
        &["associate"],
        &["associated"],
        &["associates"],
        &["association"],
        &["associations"],
        &["associated"],
    ],
    range: 3..=7,
};

static WORD_ASSH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ASSH_CHILDREN),
    value: None,
};

pub static WORD_ASSH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ates"),
        dictgen::InsensitiveStr::Ascii("atts"),
    ],
    values: &[&["asshats"], &["asshats"]],
    range: 4..=4,
};

static WORD_ASSG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ASSG_CHILDREN),
    value: None,
};

pub static WORD_ASSG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("in"),
        dictgen::InsensitiveStr::Ascii("ined"),
        dictgen::InsensitiveStr::Ascii("ining"),
        dictgen::InsensitiveStr::Ascii("inment"),
        dictgen::InsensitiveStr::Ascii("inments"),
        dictgen::InsensitiveStr::Ascii("ins"),
    ],
    values: &[
        &["assign"],
        &["assigned"],
        &["assigning"],
        &["assignment"],
        &["assignments"],
        &["assigns"],
    ],
    range: 2..=7,
};

static WORD_ASSF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ASSF_CHILDREN),
    value: None,
};

pub static WORD_ASSF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("alt"),
        dictgen::InsensitiveStr::Ascii("alted"),
        dictgen::InsensitiveStr::Ascii("alting"),
        dictgen::InsensitiveStr::Ascii("alts"),
    ],
    values: &[&["asphalt"], &["asphalted"], &["asphalting"], &["asphalts"]],
    range: 3..=6,
};

static WORD_ASSE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ASSE_CHILDREN),
    value: None,
};

pub static WORD_ASSE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("bly"),
        dictgen::InsensitiveStr::Ascii("bmly"),
        dictgen::InsensitiveStr::Ascii("malate"),
        dictgen::InsensitiveStr::Ascii("malated"),
        dictgen::InsensitiveStr::Ascii("malates"),
        dictgen::InsensitiveStr::Ascii("malating"),
        dictgen::InsensitiveStr::Ascii("mbe"),
        dictgen::InsensitiveStr::Ascii("mbed"),
        dictgen::InsensitiveStr::Ascii("mbeld"),
        dictgen::InsensitiveStr::Ascii("mber"),
        dictgen::InsensitiveStr::Ascii("mblare"),
        dictgen::InsensitiveStr::Ascii("mbleing"),
        dictgen::InsensitiveStr::Ascii("mbley"),
        dictgen::InsensitiveStr::Ascii("mblie"),
        dictgen::InsensitiveStr::Ascii("mblying"),
        dictgen::InsensitiveStr::Ascii("mblys"),
        dictgen::InsensitiveStr::Ascii("mby"),
        dictgen::InsensitiveStr::Ascii("mlies"),
        dictgen::InsensitiveStr::Ascii("mly"),
        dictgen::InsensitiveStr::Ascii("mnly"),
        dictgen::InsensitiveStr::Ascii("mple"),
        dictgen::InsensitiveStr::Ascii("mpling"),
        dictgen::InsensitiveStr::Ascii("nding"),
        dictgen::InsensitiveStr::Ascii("r"),
        dictgen::InsensitiveStr::Ascii("rion"),
        dictgen::InsensitiveStr::Ascii("rsion"),
        dictgen::InsensitiveStr::Ascii("rsions"),
        dictgen::InsensitiveStr::Ascii("rtation"),
        dictgen::InsensitiveStr::Ascii("rtin"),
        dictgen::InsensitiveStr::Ascii("rtino"),
        dictgen::InsensitiveStr::Ascii("rtinos"),
        dictgen::InsensitiveStr::Ascii("rtio"),
        dictgen::InsensitiveStr::Ascii("rtting"),
        dictgen::InsensitiveStr::Ascii("sement"),
        dictgen::InsensitiveStr::Ascii("smenet"),
        dictgen::InsensitiveStr::Ascii("sment"),
        dictgen::InsensitiveStr::Ascii("sments"),
        dictgen::InsensitiveStr::Ascii("ssmant"),
        dictgen::InsensitiveStr::Ascii("ssmants"),
        dictgen::InsensitiveStr::Ascii("stment"),
    ],
    values: &[
        &["assembly"],
        &["assembly"],
        &["assimilate"],
        &["assimilated"],
        &["assimilates"],
        &["assimilating"],
        &["assemble"],
        &["assembled"],
        &["assembled"],
        &["assembler"],
        &["assemble"],
        &["assembling"],
        &["assembly"],
        &["assemble"],
        &["assembling"],
        &["assemblies"],
        &["assembly"],
        &["assemblies"],
        &["assembly"],
        &["assembly"],
        &["assemble"],
        &["assembling"],
        &["ascending"],
        &["assert"],
        &["assertion"],
        &["assertion"],
        &["assertions"],
        &["assertion"],
        &["assertions"],
        &["assertion"],
        &["assertions"],
        &["assertion"],
        &["asserting"],
        &["assessment"],
        &["assessment"],
        &["assessment"],
        &["assessments"],
        &["assessment"],
        &["assessments"],
        &["assessment"],
    ],
    range: 1..=8,
};

static WORD_ASSC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ASSC_CHILDREN),
    value: None,
};

pub static WORD_ASSC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ciated"),
        dictgen::InsensitiveStr::Ascii("iated"),
        dictgen::InsensitiveStr::Ascii("ii"),
        dictgen::InsensitiveStr::Ascii("ociated"),
        dictgen::InsensitiveStr::Ascii("oitaed"),
    ],
    values: &[
        &["associated"],
        &["associated"],
        &["ascii"],
        &["associated"],
        &["associated"],
    ],
    range: 2..=7,
};

static WORD_ASSA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ASSA_CHILDREN),
    value: None,
};

pub static WORD_ASSA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("gne"),
        dictgen::InsensitiveStr::Ascii("mble"),
        dictgen::InsensitiveStr::Ascii("sin"),
        dictgen::InsensitiveStr::Ascii("sinate"),
        dictgen::InsensitiveStr::Ascii("sinated"),
        dictgen::InsensitiveStr::Ascii("sinates"),
        dictgen::InsensitiveStr::Ascii("sination"),
        dictgen::InsensitiveStr::Ascii("sinations"),
        dictgen::InsensitiveStr::Ascii("sined"),
        dictgen::InsensitiveStr::Ascii("sins"),
        dictgen::InsensitiveStr::Ascii("ssian"),
        dictgen::InsensitiveStr::Ascii("ssians"),
        dictgen::InsensitiveStr::Ascii("ssiante"),
        dictgen::InsensitiveStr::Ascii("ssinare"),
        dictgen::InsensitiveStr::Ascii("ssinas"),
        dictgen::InsensitiveStr::Ascii("ssinatd"),
        dictgen::InsensitiveStr::Ascii("ssinatin"),
        dictgen::InsensitiveStr::Ascii("ssinato"),
        dictgen::InsensitiveStr::Ascii("ssinats"),
        dictgen::InsensitiveStr::Ascii("ssine"),
        dictgen::InsensitiveStr::Ascii("ssines"),
        dictgen::InsensitiveStr::Ascii("ssinos"),
        dictgen::InsensitiveStr::Ascii("ssintation"),
        dictgen::InsensitiveStr::Ascii("ssinted"),
        dictgen::InsensitiveStr::Ascii("sssin"),
        dictgen::InsensitiveStr::Ascii("ultes"),
    ],
    values: &[
        &["assange"],
        &["assemble"],
        &["assassin"],
        &["assassinate"],
        &["assassinated"],
        &["assassinates"],
        &["assassination"],
        &["assassinations"],
        &["assassinated"],
        &["assassins"],
        &["assassin"],
        &["assassin"],
        &["assassinate"],
        &["assassinate"],
        &["assassins"],
        &["assassinated"],
        &["assassination"],
        &["assassination"],
        &["assassins"],
        &["assassinate"],
        &["assassins"],
        &["assassins"],
        &["assassination"],
        &["assassinated"],
        &["assassins"],
        &["assaults"],
    ],
    range: 3..=10,
};

static WORD_ASP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ASP_CHILDREN),
    value: None,
};

pub static WORD_ASP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ahlt"),
        dictgen::InsensitiveStr::Ascii("ected"),
        dictgen::InsensitiveStr::Ascii("ectos"),
        dictgen::InsensitiveStr::Ascii("ergerers"),
        dictgen::InsensitiveStr::Ascii("erges"),
        dictgen::InsensitiveStr::Ascii("estus"),
        dictgen::InsensitiveStr::Ascii("hlat"),
        dictgen::InsensitiveStr::Ascii("hyxation"),
        dictgen::InsensitiveStr::Ascii("iratons"),
        dictgen::InsensitiveStr::Ascii("riations"),
        dictgen::InsensitiveStr::Ascii("riin"),
    ],
    values: &[
        &["asphalt"],
        &["expected"],
        &["aspects"],
        &["aspergers"],
        &["aspergers"],
        &["asbestos"],
        &["asphalt"],
        &["asphyxiation"],
        &["aspirations"],
        &["aspirations"],
        &["aspirin"],
    ],
    range: 4..=8,
};

static WORD_ASO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ASO_CHILDREN),
    value: None,
};

pub static WORD_ASO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ciated"),
        dictgen::InsensitiveStr::Ascii("lute"),
        dictgen::InsensitiveStr::Ascii("rbed"),
    ],
    values: &[&["associated"], &["absolute"], &["absorbed"]],
    range: 4..=6,
};

static WORD_ASN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ASN_CHILDREN),
    value: None,
};

pub static WORD_ASN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("wer"),
        dictgen::InsensitiveStr::Ascii("wered"),
        dictgen::InsensitiveStr::Ascii("werer"),
        dictgen::InsensitiveStr::Ascii("werers"),
        dictgen::InsensitiveStr::Ascii("wering"),
        dictgen::InsensitiveStr::Ascii("wers"),
        dictgen::InsensitiveStr::Ascii("y"),
        dictgen::InsensitiveStr::Ascii("ychronoue"),
    ],
    values: &[
        &["answer"],
        &["answered"],
        &["answerer"],
        &["answerers"],
        &["answering"],
        &["answers"],
        &["any"],
        &["asynchronous"],
    ],
    range: 1..=9,
};

static WORD_ASL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ASL_CHILDREN),
    value: None,
};

pub static WORD_ASL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("o")],
    values: &[&["also"]],
    range: 1..=1,
};

static WORD_ASK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ASK_CHILDREN),
    value: None,
};

pub static WORD_ASK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("reddt"),
    ],
    values: &[&["ask"], &["asks"], &["askreddit"]],
    range: 1..=5,
};

static WORD_ASI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ASI_CHILDREN),
    value: None,
};

pub static WORD_ASI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("gn"),
        dictgen::InsensitiveStr::Ascii("gned"),
        dictgen::InsensitiveStr::Ascii("gnee"),
        dictgen::InsensitiveStr::Ascii("gnees"),
        dictgen::InsensitiveStr::Ascii("gning"),
        dictgen::InsensitiveStr::Ascii("gnmend"),
        dictgen::InsensitiveStr::Ascii("gnmends"),
        dictgen::InsensitiveStr::Ascii("gnment"),
        dictgen::InsensitiveStr::Ascii("gnor"),
        dictgen::InsensitiveStr::Ascii("gns"),
        dictgen::InsensitiveStr::Ascii("i"),
        dictgen::InsensitiveStr::Ascii("prin"),
        dictgen::InsensitiveStr::Ascii("sstant"),
        dictgen::InsensitiveStr::Ascii("sstants"),
        dictgen::InsensitiveStr::Ascii("ssted"),
        dictgen::InsensitiveStr::Ascii("ssts"),
        dictgen::InsensitiveStr::Ascii("stance"),
    ],
    values: &[
        &["assign"],
        &["assigned"],
        &["assignee"],
        &["assignees"],
        &["assigning"],
        &["assignment"],
        &["assignments"],
        &["assignment"],
        &["assignor"],
        &["assigns"],
        &["ascii"],
        &["aspirin"],
        &["assistant"],
        &["assistants"],
        &["assisted"],
        &["assists"],
        &["assistance"],
    ],
    range: 1..=7,
};

static WORD_ASH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ASH_CHILDREN),
    value: None,
};

pub static WORD_ASH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("palt")],
    values: &[&["asphalt"]],
    range: 4..=4,
};

static WORD_ASE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ASE_CHILDREN),
    value: None,
};

pub static WORD_ASE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("mble"),
        dictgen::InsensitiveStr::Ascii("mbled"),
        dictgen::InsensitiveStr::Ascii("mbler"),
        dictgen::InsensitiveStr::Ascii("mblers"),
        dictgen::InsensitiveStr::Ascii("mbles"),
        dictgen::InsensitiveStr::Ascii("mblies"),
        dictgen::InsensitiveStr::Ascii("mbling"),
        dictgen::InsensitiveStr::Ascii("mbly"),
        dictgen::InsensitiveStr::Ascii("nd"),
        dictgen::InsensitiveStr::Ascii("ndance"),
        dictgen::InsensitiveStr::Ascii("ndancey"),
        dictgen::InsensitiveStr::Ascii("ndancy"),
        dictgen::InsensitiveStr::Ascii("nded"),
        dictgen::InsensitiveStr::Ascii("ndence"),
        dictgen::InsensitiveStr::Ascii("ndencey"),
        dictgen::InsensitiveStr::Ascii("ndency"),
        dictgen::InsensitiveStr::Ascii("nder"),
        dictgen::InsensitiveStr::Ascii("nding"),
        dictgen::InsensitiveStr::Ascii("nt"),
        dictgen::InsensitiveStr::Ascii("rted"),
        dictgen::InsensitiveStr::Ascii("rtion"),
        dictgen::InsensitiveStr::Ascii("ss"),
        dictgen::InsensitiveStr::Ascii("ssment"),
        dictgen::InsensitiveStr::Ascii("ssments"),
        dictgen::InsensitiveStr::Ascii("thetic"),
        dictgen::InsensitiveStr::Ascii("thetically"),
        dictgen::InsensitiveStr::Ascii("thetics"),
        dictgen::InsensitiveStr::Ascii("tic"),
        dictgen::InsensitiveStr::Ascii("uxal"),
        dictgen::InsensitiveStr::Ascii("xaul"),
    ],
    values: &[
        &["assemble"],
        &["assembled"],
        &["assembler"],
        &["assemblers"],
        &["assembles"],
        &["assemblies"],
        &["assembling"],
        &["assembly"],
        &["ascend"],
        &["ascendance"],
        &["ascendancy"],
        &["ascendancy"],
        &["ascended"],
        &["ascendence"],
        &["ascendency"],
        &["ascendency"],
        &["ascender"],
        &["ascending"],
        &["ascent"],
        &["asserted"],
        &["assertion"],
        &["assess"],
        &["assessment"],
        &["assessments"],
        &["aesthetic"],
        &["aesthetically"],
        &["aesthetics"],
        &["ascetic"],
        &["asexual"],
        &["asexual"],
    ],
    range: 2..=10,
};

static WORD_ASD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ASD_CHILDREN),
    value: None,
};

pub static WORD_ASD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ignment"),
        dictgen::InsensitiveStr::Ascii("ignments"),
    ],
    values: &[&["assignment"], &["assignments"]],
    range: 7..=8,
};

static WORD_ASC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ASC_CHILDREN),
    value: None,
};

pub static WORD_ASC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("conciated"),
        dictgen::InsensitiveStr::Ascii("eding"),
        dictgen::InsensitiveStr::Ascii("endend"),
        dictgen::InsensitiveStr::Ascii("neded"),
        dictgen::InsensitiveStr::Ascii("neding"),
        dictgen::InsensitiveStr::Ascii("nesion"),
        dictgen::InsensitiveStr::Ascii("pect"),
        dictgen::InsensitiveStr::Ascii("pects"),
        dictgen::InsensitiveStr::Ascii("ripts"),
    ],
    values: &[
        &["associated"],
        &["ascending"],
        &["ascended"],
        &["ascended"],
        &["ascending"],
        &["ascension"],
        &["aspect"],
        &["aspects"],
        &["scripts"],
    ],
    range: 4..=9,
};

static WORD_ASB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ASB_CHILDREN),
    value: None,
};

pub static WORD_ASB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("estoast"),
        dictgen::InsensitiveStr::Ascii("estoes"),
        dictgen::InsensitiveStr::Ascii("olute"),
        dictgen::InsensitiveStr::Ascii("olutelly"),
        dictgen::InsensitiveStr::Ascii("olutely"),
        dictgen::InsensitiveStr::Ascii("orbed"),
        dictgen::InsensitiveStr::Ascii("orbing"),
        dictgen::InsensitiveStr::Ascii("tract"),
        dictgen::InsensitiveStr::Ascii("tracted"),
        dictgen::InsensitiveStr::Ascii("tracter"),
        dictgen::InsensitiveStr::Ascii("tracting"),
        dictgen::InsensitiveStr::Ascii("traction"),
        dictgen::InsensitiveStr::Ascii("tractions"),
        dictgen::InsensitiveStr::Ascii("tractly"),
        dictgen::InsensitiveStr::Ascii("tractness"),
        dictgen::InsensitiveStr::Ascii("tractor"),
        dictgen::InsensitiveStr::Ascii("tracts"),
        dictgen::InsensitiveStr::Ascii("urdity"),
        dictgen::InsensitiveStr::Ascii("urdly"),
    ],
    values: &[
        &["asbestos"],
        &["asbestos"],
        &["absolute"],
        &["absolutely"],
        &["absolutely"],
        &["absorbed"],
        &["absorbing"],
        &["abstract"],
        &["abstracted"],
        &["abstracter"],
        &["abstracting"],
        &["abstraction"],
        &["abstractions"],
        &["abstractly"],
        &["abstractness"],
        &["abstractor"],
        &["abstracts"],
        &["absurdity"],
        &["absurdly"],
    ],
    range: 5..=9,
};

static WORD_ASA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ASA_CHILDREN),
    value: None,
};

pub static WORD_ASA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("i"),
        dictgen::InsensitiveStr::Ascii("in"),
        dictgen::InsensitiveStr::Ascii("pragus"),
    ],
    values: &[&["asia"], &["asian"], &["asparagus"]],
    range: 1..=6,
};

static WORD_AR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_AR_CHILDREN),
    value: None,
};

static WORD_AR_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_ARA_NODE),
    Some(&WORD_ARB_NODE),
    Some(&WORD_ARC_NODE),
    Some(&WORD_ARD_NODE),
    Some(&WORD_ARE_NODE),
    None,
    Some(&WORD_ARG_NODE),
    Some(&WORD_ARH_NODE),
    Some(&WORD_ARI_NODE),
    None,
    Some(&WORD_ARK_NODE),
    Some(&WORD_ARL_NODE),
    Some(&WORD_ARM_NODE),
    None,
    Some(&WORD_ARO_NODE),
    Some(&WORD_ARP_NODE),
    Some(&WORD_ARQ_NODE),
    Some(&WORD_ARR_NODE),
    Some(&WORD_ARS_NODE),
    Some(&WORD_ART_NODE),
    Some(&WORD_ARU_NODE),
    Some(&WORD_ARV_NODE),
    None,
    None,
    None,
    None,
];

static WORD_ARV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ARV_CHILDREN),
    value: None,
};

pub static WORD_ARV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("g")],
    values: &[&["argv"]],
    range: 1..=1,
};

static WORD_ARU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ARU_CHILDREN),
    value: None,
};

pub static WORD_ARU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("gable"),
        dictgen::InsensitiveStr::Ascii("gably"),
        dictgen::InsensitiveStr::Ascii("gement"),
        dictgen::InsensitiveStr::Ascii("ging"),
        dictgen::InsensitiveStr::Ascii("gment"),
        dictgen::InsensitiveStr::Ascii("gmentative"),
        dictgen::InsensitiveStr::Ascii("gments"),
        dictgen::InsensitiveStr::Ascii("ment"),
        dictgen::InsensitiveStr::Ascii("ments"),
        dictgen::InsensitiveStr::Ascii("nd"),
    ],
    values: &[
        &["arguable"],
        &["arguably"],
        &["argument"],
        &["arguing"],
        &["argument"],
        &["argumentative"],
        &["arguments"],
        &["argument"],
        &["arguments"],
        &["around"],
    ],
    range: 2..=10,
};

static WORD_ART_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ART_CHILDREN),
    value: None,
};

pub static WORD_ART_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cile"),
        dictgen::InsensitiveStr::Ascii("emios"),
        dictgen::InsensitiveStr::Ascii("emius"),
        dictgen::InsensitiveStr::Ascii("himetic"),
        dictgen::InsensitiveStr::Ascii("hirtis"),
        dictgen::InsensitiveStr::Ascii("hrits"),
        dictgen::InsensitiveStr::Ascii("ic"),
        dictgen::InsensitiveStr::Ascii("icaft"),
        dictgen::InsensitiveStr::Ascii("icafts"),
        dictgen::InsensitiveStr::Ascii("ical"),
        dictgen::InsensitiveStr::Ascii("icals"),
        dictgen::InsensitiveStr::Ascii("icat"),
        dictgen::InsensitiveStr::Ascii("icats"),
        dictgen::InsensitiveStr::Ascii("ice"),
        dictgen::InsensitiveStr::Ascii("icel"),
        dictgen::InsensitiveStr::Ascii("icels"),
        dictgen::InsensitiveStr::Ascii("icifial"),
        dictgen::InsensitiveStr::Ascii("icifially"),
        dictgen::InsensitiveStr::Ascii("icluate"),
        dictgen::InsensitiveStr::Ascii("icluated"),
        dictgen::InsensitiveStr::Ascii("icualte"),
        dictgen::InsensitiveStr::Ascii("icualted"),
        dictgen::InsensitiveStr::Ascii("icule"),
        dictgen::InsensitiveStr::Ascii("iculted"),
        dictgen::InsensitiveStr::Ascii("ifac"),
        dictgen::InsensitiveStr::Ascii("ifacs"),
        dictgen::InsensitiveStr::Ascii("ifactos"),
        dictgen::InsensitiveStr::Ascii("ifcat"),
        dictgen::InsensitiveStr::Ascii("ifcats"),
        dictgen::InsensitiveStr::Ascii("ificailly"),
        dictgen::InsensitiveStr::Ascii("ifical"),
        dictgen::InsensitiveStr::Ascii("ifically"),
        dictgen::InsensitiveStr::Ascii("ificialy"),
        dictgen::InsensitiveStr::Ascii("ificiel"),
        dictgen::InsensitiveStr::Ascii("ificiella"),
        dictgen::InsensitiveStr::Ascii("ifict"),
        dictgen::InsensitiveStr::Ascii("ificually"),
        dictgen::InsensitiveStr::Ascii("ifiically"),
        dictgen::InsensitiveStr::Ascii("ihmetic"),
        dictgen::InsensitiveStr::Ascii("ilce"),
        dictgen::InsensitiveStr::Ascii("illary"),
        dictgen::InsensitiveStr::Ascii("illerly"),
        dictgen::InsensitiveStr::Ascii("illey"),
        dictgen::InsensitiveStr::Ascii("isitc"),
        dictgen::InsensitiveStr::Ascii("istas"),
        dictgen::InsensitiveStr::Ascii("istc"),
        dictgen::InsensitiveStr::Ascii("meis"),
        dictgen::InsensitiveStr::Ascii("sits"),
        dictgen::InsensitiveStr::Ascii("uments"),
    ],
    values: &[
        &["article"],
        &["artemis"],
        &["artemis"],
        &["arithmetic"],
        &["arthritis"],
        &["arthritis"],
        &["arctic"],
        &["artifact"],
        &["artifacts"],
        &["article"],
        &["articles"],
        &["artifact"],
        &["artifacts"],
        &["article"],
        &["article"],
        &["articles"],
        &["artificial"],
        &["artificially"],
        &["articulate"],
        &["articulated"],
        &["articulate"],
        &["articulated"],
        &["articulate"],
        &["articulated"],
        &["artifact"],
        &["artifacts"],
        &["artifacts"],
        &["artifact"],
        &["artifacts"],
        &["artificially"],
        &["artificial"],
        &["artificially"],
        &["artificially"],
        &["artificial"],
        &["artificial"],
        &["artifact"],
        &["artificially"],
        &["artificially"],
        &["arithmetic"],
        &["article"],
        &["artillery"],
        &["artillery"],
        &["artillery"],
        &["artistic"],
        &["artists"],
        &["artistic"],
        &["artemis"],
        &["artists"],
        &["arguments"],
    ],
    range: 2..=9,
};

static WORD_ARS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ARS_CHILDREN),
    value: None,
};

pub static WORD_ARS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("enaal"),
        dictgen::InsensitiveStr::Ascii("neal"),
        dictgen::InsensitiveStr::Ascii("nic"),
    ],
    values: &[&["arsenal"], &["arsenal"], &["arsenic"]],
    range: 3..=5,
};

static WORD_ARR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_ARR_CHILDREN),
    value: None,
};

static WORD_ARR_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_ARRA_NODE),
    None,
    None,
    None,
    Some(&WORD_ARRE_NODE),
    None,
    None,
    None,
    Some(&WORD_ARRI_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_ARRO_NODE),
    None,
    None,
    Some(&WORD_ARRR_NODE),
    None,
    Some(&WORD_ARRT_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_ARRY_NODE),
    None,
];

static WORD_ARRY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ARRY_CHILDREN),
    value: Some(&["array", "carry"]),
};

pub static WORD_ARRY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("a"),
        dictgen::InsensitiveStr::Ascii("as"),
        dictgen::InsensitiveStr::Ascii("s"),
    ],
    values: &[&["array"], &["arrays"], &["arrays"]],
    range: 1..=2,
};

static WORD_ARRT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ARRT_CHILDREN),
    value: None,
};

pub static WORD_ARRT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ibute")],
    values: &[&["attribute"]],
    range: 5..=5,
};

static WORD_ARRR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ARRR_CHILDREN),
    value: None,
};

pub static WORD_ARRR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ay"),
        dictgen::InsensitiveStr::Ascii("ays"),
        dictgen::InsensitiveStr::Ascii("ive"),
        dictgen::InsensitiveStr::Ascii("ived"),
        dictgen::InsensitiveStr::Ascii("ives"),
    ],
    values: &[
        &["array"],
        &["arrays"],
        &["arrive"],
        &["arrived"],
        &["arrives"],
    ],
    range: 2..=4,
};

static WORD_ARRO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ARRO_CHILDREN),
    value: Some(&["arrow"]),
};

pub static WORD_ARRO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("s"),
        dictgen::InsensitiveStr::Ascii("und"),
    ],
    values: &[&["arrows"], &["around"]],
    range: 1..=3,
};

static WORD_ARRI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ARRI_CHILDREN),
    value: None,
};

pub static WORD_ARRI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ses"),
        dictgen::InsensitiveStr::Ascii("ty"),
        dictgen::InsensitiveStr::Ascii("veis"),
        dictgen::InsensitiveStr::Ascii("vial"),
    ],
    values: &[
        &["arises"],
        &["arity", "parity"],
        &["arrives"],
        &["arrival"],
    ],
    range: 2..=4,
};

static WORD_ARRE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ARRE_CHILDREN),
    value: Some(&["are"]),
};

pub static WORD_ARRE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ay"),
        dictgen::InsensitiveStr::Ascii("ngement"),
        dictgen::InsensitiveStr::Ascii("ngements"),
        dictgen::InsensitiveStr::Ascii("sst"),
        dictgen::InsensitiveStr::Ascii("stes"),
        dictgen::InsensitiveStr::Ascii("stos"),
    ],
    values: &[
        &["array"],
        &["arrangement"],
        &["arrangements"],
        &["arrests"],
        &["arrests"],
        &["arrests"],
    ],
    range: 2..=8,
};

static WORD_ARRA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ARRA_CHILDREN),
    value: None,
};

pub static WORD_ARRA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ay"),
        dictgen::InsensitiveStr::Ascii("gement"),
        dictgen::InsensitiveStr::Ascii("gned"),
        dictgen::InsensitiveStr::Ascii("ies"),
        dictgen::InsensitiveStr::Ascii("ival"),
        dictgen::InsensitiveStr::Ascii("l"),
        dictgen::InsensitiveStr::Ascii("nable"),
        dictgen::InsensitiveStr::Ascii("nce"),
        dictgen::InsensitiveStr::Ascii("ne"),
        dictgen::InsensitiveStr::Ascii("ned"),
        dictgen::InsensitiveStr::Ascii("nement"),
        dictgen::InsensitiveStr::Ascii("nements"),
        dictgen::InsensitiveStr::Ascii("nent"),
        dictgen::InsensitiveStr::Ascii("nents"),
        dictgen::InsensitiveStr::Ascii("nes"),
        dictgen::InsensitiveStr::Ascii("ng"),
        dictgen::InsensitiveStr::Ascii("ngable"),
        dictgen::InsensitiveStr::Ascii("ngaeble"),
        dictgen::InsensitiveStr::Ascii("ngaelbe"),
        dictgen::InsensitiveStr::Ascii("ngd"),
        dictgen::InsensitiveStr::Ascii("ngde"),
        dictgen::InsensitiveStr::Ascii("ngemenet"),
        dictgen::InsensitiveStr::Ascii("ngemenets"),
        dictgen::InsensitiveStr::Ascii("ngent"),
        dictgen::InsensitiveStr::Ascii("ngents"),
        dictgen::InsensitiveStr::Ascii("ngerad"),
        dictgen::InsensitiveStr::Ascii("ngmeent"),
        dictgen::InsensitiveStr::Ascii("ngmeents"),
        dictgen::InsensitiveStr::Ascii("ngmenet"),
        dictgen::InsensitiveStr::Ascii("ngmenets"),
        dictgen::InsensitiveStr::Ascii("ngment"),
        dictgen::InsensitiveStr::Ascii("ngments"),
        dictgen::InsensitiveStr::Ascii("ngnig"),
        dictgen::InsensitiveStr::Ascii("ngs"),
        dictgen::InsensitiveStr::Ascii("ngse"),
        dictgen::InsensitiveStr::Ascii("ngt"),
        dictgen::InsensitiveStr::Ascii("ngte"),
        dictgen::InsensitiveStr::Ascii("ngteable"),
        dictgen::InsensitiveStr::Ascii("ngted"),
        dictgen::InsensitiveStr::Ascii("ngtement"),
        dictgen::InsensitiveStr::Ascii("ngtements"),
        dictgen::InsensitiveStr::Ascii("ngtes"),
        dictgen::InsensitiveStr::Ascii("ngting"),
        dictgen::InsensitiveStr::Ascii("ngts"),
        dictgen::InsensitiveStr::Ascii("ning"),
        dictgen::InsensitiveStr::Ascii("nment"),
        dictgen::InsensitiveStr::Ascii("nments"),
        dictgen::InsensitiveStr::Ascii("nts"),
        dictgen::InsensitiveStr::Ascii("ows"),
        dictgen::InsensitiveStr::Ascii("ry"),
        dictgen::InsensitiveStr::Ascii("yes"),
    ],
    values: &[
        &["array"],
        &["arrangement"],
        &["arranged"],
        &["arrays"],
        &["arrival"],
        &["array"],
        &["arrangeable"],
        &["arrange"],
        &["arrange"],
        &["arranged"],
        &["arrangement"],
        &["arrangements"],
        &["arrangement"],
        &["arrangements"],
        &["arranges"],
        &["arrange"],
        &["arrangeable"],
        &["arrangeable"],
        &["arrangeable"],
        &["arranged"],
        &["arranged"],
        &["arrangement"],
        &["arrangements"],
        &["arrangement"],
        &["arrangements"],
        &["arranged"],
        &["arrangement"],
        &["arrangements"],
        &["arrangement"],
        &["arrangements"],
        &["arrangement"],
        &["arrangements"],
        &["arranging"],
        &["arranges"],
        &["arranges"],
        &["arrangement"],
        &["arrange"],
        &["arrangeable"],
        &["arranged"],
        &["arrangement"],
        &["arrangements"],
        &["arranges"],
        &["arranging"],
        &["arrangements"],
        &["arranging"],
        &["arrangement"],
        &["arrangements"],
        &["arrangements"],
        &["arrows"],
        &["array"],
        &["arrays"],
    ],
    range: 1..=9,
};

static WORD_ARQ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ARQ_CHILDREN),
    value: None,
};

pub static WORD_ARQ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("uitecture"),
        dictgen::InsensitiveStr::Ascii("uitectures"),
    ],
    values: &[&["architecture"], &["architectures"]],
    range: 9..=10,
};

static WORD_ARP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ARP_CHILDREN),
    value: None,
};

pub static WORD_ARP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("anoid"),
        dictgen::InsensitiveStr::Ascii("atheid"),
        dictgen::InsensitiveStr::Ascii("eture"),
    ],
    values: &[&["paranoid"], &["apartheid"], &["aperture"]],
    range: 5..=6,
};

static WORD_ARO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ARO_CHILDREN),
    value: None,
};

pub static WORD_ARO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ara"),
        dictgen::InsensitiveStr::Ascii("aras"),
        dictgen::InsensitiveStr::Ascii("gant"),
        dictgen::InsensitiveStr::Ascii("gent"),
        dictgen::InsensitiveStr::Ascii("nud"),
        dictgen::InsensitiveStr::Ascii("ud"),
        dictgen::InsensitiveStr::Ascii("udn"),
        dictgen::InsensitiveStr::Ascii("uind"),
        dictgen::InsensitiveStr::Ascii("unf"),
        dictgen::InsensitiveStr::Ascii("ung"),
        dictgen::InsensitiveStr::Ascii("unt"),
    ],
    values: &[
        &["aurora"],
        &["auroras"],
        &["arrogant"],
        &["arrogant"],
        &["around"],
        &["around"],
        &["around"],
        &["around"],
        &["around"],
        &["around"],
        &["around"],
    ],
    range: 2..=4,
};

static WORD_ARM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ARM_CHILDREN),
    value: None,
};

pub static WORD_ARM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("agaddon"),
        dictgen::InsensitiveStr::Ascii("ageddan"),
        dictgen::InsensitiveStr::Ascii("agedddon"),
        dictgen::InsensitiveStr::Ascii("agedden"),
        dictgen::InsensitiveStr::Ascii("ageddeon"),
        dictgen::InsensitiveStr::Ascii("ageddin"),
        dictgen::InsensitiveStr::Ascii("ageddomon"),
        dictgen::InsensitiveStr::Ascii("agedeon"),
        dictgen::InsensitiveStr::Ascii("agedon"),
        dictgen::InsensitiveStr::Ascii("agedons"),
        dictgen::InsensitiveStr::Ascii("ageedon"),
        dictgen::InsensitiveStr::Ascii("agideon"),
        dictgen::InsensitiveStr::Ascii("amant"),
        dictgen::InsensitiveStr::Ascii("char"),
        dictgen::InsensitiveStr::Ascii("egaddon"),
        dictgen::InsensitiveStr::Ascii("enain"),
        dictgen::InsensitiveStr::Ascii("enina"),
        dictgen::InsensitiveStr::Ascii("istace"),
        dictgen::InsensitiveStr::Ascii("istis"),
        dictgen::InsensitiveStr::Ascii("istises"),
        dictgen::InsensitiveStr::Ascii("onic"),
        dictgen::InsensitiveStr::Ascii("orment"),
        dictgen::InsensitiveStr::Ascii("orments"),
        dictgen::InsensitiveStr::Ascii("pitts"),
        dictgen::InsensitiveStr::Ascii("storng"),
        dictgen::InsensitiveStr::Ascii("strog"),
    ],
    values: &[
        &["armageddon"],
        &["armageddon"],
        &["armageddon"],
        &["armageddon"],
        &["armageddon"],
        &["armageddon"],
        &["armageddon"],
        &["armageddon"],
        &["armageddon"],
        &["armageddons"],
        &["armageddon"],
        &["armageddon"],
        &["armament"],
        &["armchair"],
        &["armageddon"],
        &["armenian"],
        &["armenian"],
        &["armistice"],
        &["armistice"],
        &["armistices"],
        &["harmonic"],
        &["armament"],
        &["armaments"],
        &["armpits"],
        &["armstrong"],
        &["armstrong"],
    ],
    range: 4..=9,
};

static WORD_ARL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ARL_CHILDREN),
    value: None,
};

pub static WORD_ARL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eady"),
        dictgen::InsensitiveStr::Ascii("ighty"),
        dictgen::InsensitiveStr::Ascii("ignton"),
        dictgen::InsensitiveStr::Ascii("ingotn"),
        dictgen::InsensitiveStr::Ascii("ready"),
    ],
    values: &[
        &["already"],
        &["alrighty"],
        &["arlington"],
        &["arlington"],
        &["already"],
    ],
    range: 4..=6,
};

static WORD_ARK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ARK_CHILDREN),
    value: None,
};

pub static WORD_ARK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("asnas")],
    values: &[&["arkansas"]],
    range: 5..=5,
};

static WORD_ARI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ARI_CHILDREN),
    value: None,
};

pub static WORD_ARI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("bitary"),
        dictgen::InsensitiveStr::Ascii("biter"),
        dictgen::InsensitiveStr::Ascii("borne"),
        dictgen::InsensitiveStr::Ascii("brary"),
        dictgen::InsensitiveStr::Ascii("bter"),
        dictgen::InsensitiveStr::Ascii("btrarily"),
        dictgen::InsensitiveStr::Ascii("btrary"),
        dictgen::InsensitiveStr::Ascii("btration"),
        dictgen::InsensitiveStr::Ascii("craft"),
        dictgen::InsensitiveStr::Ascii("flow"),
        dictgen::InsensitiveStr::Ascii("plane"),
        dictgen::InsensitiveStr::Ascii("planes"),
        dictgen::InsensitiveStr::Ascii("ports"),
        dictgen::InsensitiveStr::Ascii("sed"),
        dictgen::InsensitiveStr::Ascii("soft"),
        dictgen::InsensitiveStr::Ascii("space"),
        dictgen::InsensitiveStr::Ascii("stolte"),
        dictgen::InsensitiveStr::Ascii("stote"),
        dictgen::InsensitiveStr::Ascii("stotel"),
        dictgen::InsensitiveStr::Ascii("tfact"),
        dictgen::InsensitiveStr::Ascii("tfacts"),
        dictgen::InsensitiveStr::Ascii("themetic"),
        dictgen::InsensitiveStr::Ascii("themtic"),
        dictgen::InsensitiveStr::Ascii("thmatic"),
        dictgen::InsensitiveStr::Ascii("thmentic"),
        dictgen::InsensitiveStr::Ascii("thmetc"),
        dictgen::InsensitiveStr::Ascii("thmethic"),
        dictgen::InsensitiveStr::Ascii("thmetisch"),
        dictgen::InsensitiveStr::Ascii("thmetric"),
        dictgen::InsensitiveStr::Ascii("thmitic"),
        dictgen::InsensitiveStr::Ascii("tmethic"),
        dictgen::InsensitiveStr::Ascii("tmetic"),
        dictgen::InsensitiveStr::Ascii("trary"),
        dictgen::InsensitiveStr::Ascii("tst"),
        dictgen::InsensitiveStr::Ascii("tsts"),
        dictgen::InsensitiveStr::Ascii("val"),
        dictgen::InsensitiveStr::Ascii("ve"),
        dictgen::InsensitiveStr::Ascii("zonia"),
    ],
    values: &[
        &["arbitrary"],
        &["arbiter"],
        &["airborne"],
        &["arbitrary"],
        &["arbiter"],
        &["arbitrarily"],
        &["arbitrary"],
        &["arbitration"],
        &["aircraft"],
        &["airflow"],
        &["airplane"],
        &["airplanes"],
        &["airports"],
        &["arose"],
        &["airsoft"],
        &["airspace"],
        &["aristotle"],
        &["aristotle"],
        &["aristotle"],
        &["artifact"],
        &["artifacts"],
        &["arithmetic"],
        &["arithmetic"],
        &["arithmetic"],
        &["arithmetic"],
        &["arithmetic"],
        &["arithmetic"],
        &["arithmetic"],
        &["arithmetic"],
        &["arithmetic"],
        &["arithmetic"],
        &["arithmetic"],
        &["arbitrary"],
        &["artist"],
        &["artists"],
        &["arrival"],
        &["arrive"],
        &["arizona"],
    ],
    range: 2..=9,
};

static WORD_ARH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ARH_CHILDREN),
    value: None,
};

pub static WORD_ARH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ive"),
        dictgen::InsensitiveStr::Ascii("ives"),
        dictgen::InsensitiveStr::Ascii("tritis"),
    ],
    values: &[&["archive"], &["archives"], &["arthritis"]],
    range: 3..=6,
};

static WORD_ARG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ARG_CHILDREN),
    value: None,
};

pub static WORD_ARG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ement"),
        dictgen::InsensitiveStr::Ascii("ements"),
        dictgen::InsensitiveStr::Ascii("emnt"),
        dictgen::InsensitiveStr::Ascii("emnts"),
        dictgen::InsensitiveStr::Ascii("entia"),
        dictgen::InsensitiveStr::Ascii("entinia"),
        dictgen::InsensitiveStr::Ascii("essive"),
        dictgen::InsensitiveStr::Ascii("eument"),
        dictgen::InsensitiveStr::Ascii("icultural"),
        dictgen::InsensitiveStr::Ascii("iculture"),
        dictgen::InsensitiveStr::Ascii("ment"),
        dictgen::InsensitiveStr::Ascii("ments"),
        dictgen::InsensitiveStr::Ascii("mument"),
        dictgen::InsensitiveStr::Ascii("muments"),
        dictgen::InsensitiveStr::Ascii("reement"),
        dictgen::InsensitiveStr::Ascii("reements"),
        dictgen::InsensitiveStr::Ascii("uabley"),
        dictgen::InsensitiveStr::Ascii("uablly"),
        dictgen::InsensitiveStr::Ascii("ubaly"),
        dictgen::InsensitiveStr::Ascii("ubly"),
        dictgen::InsensitiveStr::Ascii("uement"),
        dictgen::InsensitiveStr::Ascii("uements"),
        dictgen::InsensitiveStr::Ascii("uemet"),
        dictgen::InsensitiveStr::Ascii("uemnet"),
        dictgen::InsensitiveStr::Ascii("uemnt"),
        dictgen::InsensitiveStr::Ascii("uemnts"),
        dictgen::InsensitiveStr::Ascii("uemtn"),
        dictgen::InsensitiveStr::Ascii("uemtns"),
        dictgen::InsensitiveStr::Ascii("uents"),
        dictgen::InsensitiveStr::Ascii("umant"),
        dictgen::InsensitiveStr::Ascii("umants"),
        dictgen::InsensitiveStr::Ascii("umeent"),
        dictgen::InsensitiveStr::Ascii("umeents"),
        dictgen::InsensitiveStr::Ascii("umement"),
        dictgen::InsensitiveStr::Ascii("umements"),
        dictgen::InsensitiveStr::Ascii("umemnt"),
        dictgen::InsensitiveStr::Ascii("umemnts"),
        dictgen::InsensitiveStr::Ascii("umeng"),
        dictgen::InsensitiveStr::Ascii("umengs"),
        dictgen::InsensitiveStr::Ascii("umens"),
        dictgen::InsensitiveStr::Ascii("umenst"),
        dictgen::InsensitiveStr::Ascii("umentas"),
        dictgen::InsensitiveStr::Ascii("umentate"),
        dictgen::InsensitiveStr::Ascii("umentatie"),
        dictgen::InsensitiveStr::Ascii("umentents"),
        dictgen::InsensitiveStr::Ascii("umentitive"),
        dictgen::InsensitiveStr::Ascii("umentos"),
        dictgen::InsensitiveStr::Ascii("umeny"),
        dictgen::InsensitiveStr::Ascii("umernts"),
        dictgen::InsensitiveStr::Ascii("umet"),
        dictgen::InsensitiveStr::Ascii("umetn"),
        dictgen::InsensitiveStr::Ascii("umetns"),
        dictgen::InsensitiveStr::Ascii("umets"),
        dictgen::InsensitiveStr::Ascii("umnet"),
        dictgen::InsensitiveStr::Ascii("umnets"),
        dictgen::InsensitiveStr::Ascii("umnt"),
        dictgen::InsensitiveStr::Ascii("umnts"),
    ],
    values: &[
        &["argument"],
        &["arguments"],
        &["argument"],
        &["arguments"],
        &["argentina"],
        &["argentina"],
        &["aggressive"],
        &["argument"],
        &["agricultural"],
        &["agriculture"],
        &["argument"],
        &["arguments"],
        &["argument"],
        &["arguments"],
        &["agreement"],
        &["agreements"],
        &["arguably"],
        &["arguably"],
        &["arguably"],
        &["arguably"],
        &["argument"],
        &["arguments"],
        &["argument"],
        &["argument"],
        &["argument"],
        &["arguments"],
        &["argument"],
        &["arguments"],
        &["arguments"],
        &["argument"],
        &["arguments"],
        &["argument"],
        &["arguments"],
        &["argument"],
        &["arguments"],
        &["argument"],
        &["arguments"],
        &["argument"],
        &["arguments"],
        &["arguments"],
        &["arguments"],
        &["arguments"],
        &["argumentative"],
        &["argumentative"],
        &["arguments"],
        &["argumentative"],
        &["arguments"],
        &["argument"],
        &["arguments"],
        &["argument"],
        &["argument"],
        &["arguments"],
        &["arguments"],
        &["argument"],
        &["arguments"],
        &["argument"],
        &["arguments"],
    ],
    range: 4..=10,
};

static WORD_ARE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ARE_CHILDREN),
    value: None,
};

pub static WORD_ARE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ady"),
        dictgen::InsensitiveStr::Ascii("ea"),
        dictgen::InsensitiveStr::Ascii("gument"),
        dictgen::InsensitiveStr::Ascii("mnian"),
        dictgen::InsensitiveStr::Ascii("odynamics"),
        dictgen::InsensitiveStr::Ascii("ospace"),
        dictgen::InsensitiveStr::Ascii("snal"),
        dictgen::InsensitiveStr::Ascii("tmis"),
    ],
    values: &[
        &["already"],
        &["area"],
        &["argument"],
        &["armenian"],
        &["aerodynamics"],
        &["aerospace"],
        &["arsenal"],
        &["artemis"],
    ],
    range: 2..=9,
};

static WORD_ARD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ARD_CHILDREN),
    value: None,
};

pub static WORD_ARD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("iuno"),
        dictgen::InsensitiveStr::Ascii("vark"),
        dictgen::InsensitiveStr::Ascii("varks"),
    ],
    values: &[&["arduino"], &["aardvark"], &["aardvarks"]],
    range: 4..=5,
};

static WORD_ARC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_ARC_CHILDREN),
    value: None,
};

static WORD_ARC_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_ARCA_NODE),
    None,
    None,
    None,
    Some(&WORD_ARCE_NODE),
    None,
    None,
    Some(&WORD_ARCH_NODE),
    Some(&WORD_ARCI_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_ARCT_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_ARCY_NODE),
    None,
];

static WORD_ARCY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ARCY_CHILDREN),
    value: None,
};

pub static WORD_ARCY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("lic")],
    values: &[&["acrylic"]],
    range: 3..=3,
};

static WORD_ARCT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ARCT_CHILDREN),
    value: None,
};

pub static WORD_ARCT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("icle")],
    values: &[&["article"]],
    range: 4..=4,
};

static WORD_ARCI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ARCI_CHILDREN),
    value: None,
};

pub static WORD_ARCI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("techture"),
        dictgen::InsensitiveStr::Ascii("tecture"),
        dictgen::InsensitiveStr::Ascii("tectures"),
        dictgen::InsensitiveStr::Ascii("ve"),
        dictgen::InsensitiveStr::Ascii("ved"),
        dictgen::InsensitiveStr::Ascii("ver"),
        dictgen::InsensitiveStr::Ascii("ves"),
        dictgen::InsensitiveStr::Ascii("ving"),
    ],
    values: &[
        &["architecture"],
        &["architecture"],
        &["architectures"],
        &["archive"],
        &["archived"],
        &["archiver"],
        &["archives"],
        &["archiving"],
    ],
    range: 2..=8,
};

static WORD_ARCH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_ARCH_CHILDREN),
    value: None,
};

static WORD_ARCH_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_ARCHA_NODE),
    None,
    None,
    None,
    Some(&WORD_ARCHE_NODE),
    None,
    None,
    None,
    Some(&WORD_ARCHI_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_ARCHO_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_ARCHT_NODE),
    None,
    Some(&WORD_ARCHV_NODE),
    None,
    None,
    Some(&WORD_ARCHY_NODE),
    None,
];

static WORD_ARCHY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ARCHY_CHILDREN),
    value: None,
};

pub static WORD_ARCHY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("types")],
    values: &[&["archetypes"]],
    range: 5..=5,
};

static WORD_ARCHV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ARCHV_CHILDREN),
    value: None,
};

pub static WORD_ARCHV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ie"),
        dictgen::InsensitiveStr::Ascii("ies"),
        dictgen::InsensitiveStr::Ascii("ing"),
    ],
    values: &[&["archive"], &["archives"], &["archiving"]],
    range: 2..=3,
};

static WORD_ARCHT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ARCHT_CHILDREN),
    value: None,
};

pub static WORD_ARCHT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ecture"),
        dictgen::InsensitiveStr::Ascii("ectures"),
        dictgen::InsensitiveStr::Ascii("iects"),
        dictgen::InsensitiveStr::Ascii("iecture"),
        dictgen::InsensitiveStr::Ascii("iectures"),
        dictgen::InsensitiveStr::Ascii("itecture"),
        dictgen::InsensitiveStr::Ascii("itectures"),
        dictgen::InsensitiveStr::Ascii("ype"),
        dictgen::InsensitiveStr::Ascii("ypes"),
    ],
    values: &[
        &["architecture"],
        &["architectures"],
        &["architects"],
        &["architecture"],
        &["architectures"],
        &["architecture"],
        &["architectures"],
        &["archetype"],
        &["archetypes"],
    ],
    range: 3..=9,
};

static WORD_ARCHO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ARCHO_CHILDREN),
    value: None,
};

pub static WORD_ARCHO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("r")],
    values: &[&["anchor"]],
    range: 1..=1,
};

static WORD_ARCHI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ARCHI_CHILDREN),
    value: None,
};

pub static WORD_ARCHI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ac"),
        dictgen::InsensitiveStr::Ascii("ctect"),
        dictgen::InsensitiveStr::Ascii("ctecture"),
        dictgen::InsensitiveStr::Ascii("ctectures"),
        dictgen::InsensitiveStr::Ascii("cture"),
        dictgen::InsensitiveStr::Ascii("ecture"),
        dictgen::InsensitiveStr::Ascii("ectures"),
        dictgen::InsensitiveStr::Ascii("eve"),
        dictgen::InsensitiveStr::Ascii("median"),
        dictgen::InsensitiveStr::Ascii("ne"),
        dictgen::InsensitiveStr::Ascii("nes"),
        dictgen::InsensitiveStr::Ascii("tct"),
        dictgen::InsensitiveStr::Ascii("tcts"),
        dictgen::InsensitiveStr::Ascii("tcture"),
        dictgen::InsensitiveStr::Ascii("tctures"),
        dictgen::InsensitiveStr::Ascii("techs"),
        dictgen::InsensitiveStr::Ascii("techt"),
        dictgen::InsensitiveStr::Ascii("techts"),
        dictgen::InsensitiveStr::Ascii("techturally"),
        dictgen::InsensitiveStr::Ascii("techture"),
        dictgen::InsensitiveStr::Ascii("techtures"),
        dictgen::InsensitiveStr::Ascii("techural"),
        dictgen::InsensitiveStr::Ascii("techure"),
        dictgen::InsensitiveStr::Ascii("tecs"),
        dictgen::InsensitiveStr::Ascii("tecte"),
        dictgen::InsensitiveStr::Ascii("tectes"),
        dictgen::InsensitiveStr::Ascii("tectrual"),
        dictgen::InsensitiveStr::Ascii("tectual"),
        dictgen::InsensitiveStr::Ascii("tectur"),
        dictgen::InsensitiveStr::Ascii("tectureal"),
        dictgen::InsensitiveStr::Ascii("tecturial"),
        dictgen::InsensitiveStr::Ascii("tecturs"),
        dictgen::InsensitiveStr::Ascii("tecturse"),
        dictgen::InsensitiveStr::Ascii("tectuur"),
        dictgen::InsensitiveStr::Ascii("tecure"),
        dictgen::InsensitiveStr::Ascii("tecures"),
        dictgen::InsensitiveStr::Ascii("tecutral"),
        dictgen::InsensitiveStr::Ascii("tecutre"),
        dictgen::InsensitiveStr::Ascii("tecutres"),
        dictgen::InsensitiveStr::Ascii("tecuture"),
        dictgen::InsensitiveStr::Ascii("tecutures"),
        dictgen::InsensitiveStr::Ascii("tet"),
        dictgen::InsensitiveStr::Ascii("tetcure"),
        dictgen::InsensitiveStr::Ascii("tetcures"),
        dictgen::InsensitiveStr::Ascii("teture"),
        dictgen::InsensitiveStr::Ascii("tetures"),
        dictgen::InsensitiveStr::Ascii("texts"),
        dictgen::InsensitiveStr::Ascii("texture"),
        dictgen::InsensitiveStr::Ascii("ture"),
        dictgen::InsensitiveStr::Ascii("tures"),
        dictgen::InsensitiveStr::Ascii("types"),
        dictgen::InsensitiveStr::Ascii("v"),
        dictgen::InsensitiveStr::Ascii("vel"),
    ],
    values: &[
        &["archaic"],
        &["architect"],
        &["architecture"],
        &["architectures"],
        &["architecture"],
        &["architecture"],
        &["architectures"],
        &["achieve", "archive"],
        &["archimedean"],
        &["archive"],
        &["archives"],
        &["architect"],
        &["architects"],
        &["architecture"],
        &["architectures"],
        &["architects"],
        &["architect"],
        &["architect", "architects"],
        &["architecturally"],
        &["architecture"],
        &["architectures"],
        &["architectural"],
        &["architecture"],
        &["architects"],
        &["architecture"],
        &["architects"],
        &["architectural"],
        &["architectural"],
        &["architecture"],
        &["architectural"],
        &["architectural"],
        &["architectures"],
        &["architectures"],
        &["architecture"],
        &["architecture"],
        &["architectures"],
        &["architectural"],
        &["architecture"],
        &["architectures"],
        &["architecture"],
        &["architectures"],
        &["architect"],
        &["architecture"],
        &["architectures"],
        &["architecture"],
        &["architectures"],
        &["architects"],
        &["architecture"],
        &["architecture"],
        &["architectures"],
        &["archetypes"],
        &["archive"],
        &["archival"],
    ],
    range: 1..=11,
};

static WORD_ARCHE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ARCHE_CHILDREN),
    value: None,
};

pub static WORD_ARCHE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aologist"),
        dictgen::InsensitiveStr::Ascii("aologists"),
        dictgen::InsensitiveStr::Ascii("aology"),
        dictgen::InsensitiveStr::Ascii("tect"),
        dictgen::InsensitiveStr::Ascii("tects"),
        dictgen::InsensitiveStr::Ascii("tectural"),
        dictgen::InsensitiveStr::Ascii("tecturally"),
        dictgen::InsensitiveStr::Ascii("tecture"),
        dictgen::InsensitiveStr::Ascii("tipes"),
        dictgen::InsensitiveStr::Ascii("tpye"),
        dictgen::InsensitiveStr::Ascii("tpyes"),
        dictgen::InsensitiveStr::Ascii("typs"),
        dictgen::InsensitiveStr::Ascii("typus"),
        dictgen::InsensitiveStr::Ascii("ytpes"),
    ],
    values: &[
        &["archeologist"],
        &["archeologists"],
        &["archeology"],
        &["architect"],
        &["architects"],
        &["architectural"],
        &["architecturally"],
        &["architecture"],
        &["archetypes"],
        &["archetype"],
        &["archetypes"],
        &["archetypes"],
        &["archetypes"],
        &["archetypes"],
    ],
    range: 4..=10,
};

static WORD_ARCHA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ARCHA_CHILDREN),
    value: None,
};

pub static WORD_ARCHA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("elogical"),
        dictgen::InsensitiveStr::Ascii("elogists"),
        dictgen::InsensitiveStr::Ascii("elogy"),
        dictgen::InsensitiveStr::Ascii("eolgy"),
        dictgen::InsensitiveStr::Ascii("oelogy"),
        dictgen::InsensitiveStr::Ascii("ology"),
        dictgen::InsensitiveStr::Ascii("types"),
    ],
    values: &[
        &["archaeological"],
        &["archaeologists"],
        &["archaeology"],
        &["archaeology"],
        &["archaeology", "archeology"],
        &["archeology", "archaeology"],
        &["archetypes"],
    ],
    range: 5..=8,
};

static WORD_ARCE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ARCE_CHILDREN),
    value: None,
};

pub static WORD_ARCE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("htype"),
        dictgen::InsensitiveStr::Ascii("htypes"),
    ],
    values: &[&["archetype"], &["archetypes"]],
    range: 5..=6,
};

static WORD_ARCA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ARCA_CHILDREN),
    value: None,
};

pub static WORD_ARCA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("heology"),
        dictgen::InsensitiveStr::Ascii("hic"),
    ],
    values: &[&["archeology"], &["archaic"]],
    range: 3..=7,
};

static WORD_ARB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_ARB_CHILDREN),
    value: None,
};

static WORD_ARB_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_ARBA_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_ARBI_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_ARBO_NODE),
    None,
    None,
    Some(&WORD_ARBR_NODE),
    None,
    Some(&WORD_ARBT_NODE),
    Some(&WORD_ARBU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_ARBU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ARBU_CHILDREN),
    value: None,
};

pub static WORD_ARBU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("trarily"),
        dictgen::InsensitiveStr::Ascii("trary"),
    ],
    values: &[&["arbitrarily"], &["arbitrary"]],
    range: 5..=7,
};

static WORD_ARBT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ARBT_CHILDREN),
    value: None,
};

pub static WORD_ARBT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("irarily"),
        dictgen::InsensitiveStr::Ascii("irary"),
        dictgen::InsensitiveStr::Ascii("rarily"),
        dictgen::InsensitiveStr::Ascii("rary"),
    ],
    values: &[
        &["arbitrarily"],
        &["arbitrary"],
        &["arbitrarily"],
        &["arbitrary"],
    ],
    range: 4..=7,
};

static WORD_ARBR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ARBR_CHILDREN),
    value: None,
};

pub static WORD_ARBR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("itarily"),
        dictgen::InsensitiveStr::Ascii("itary"),
        dictgen::InsensitiveStr::Ascii("itation"),
        dictgen::InsensitiveStr::Ascii("itrarily"),
        dictgen::InsensitiveStr::Ascii("itrary"),
    ],
    values: &[
        &["arbitrarily"],
        &["arbitrary"],
        &["arbitration"],
        &["arbitrarily"],
        &["arbitrary"],
    ],
    range: 5..=8,
};

static WORD_ARBO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ARBO_CHILDREN),
    value: None,
};

pub static WORD_ARBO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("rt"),
        dictgen::InsensitiveStr::Ascii("rted"),
        dictgen::InsensitiveStr::Ascii("rting"),
        dictgen::InsensitiveStr::Ascii("rts"),
    ],
    values: &[&["abort"], &["aborted"], &["aborting"], &["aborts"]],
    range: 2..=5,
};

static WORD_ARBI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_ARBI_CHILDREN),
    value: None,
};

static WORD_ARBI_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_ARBIA_NODE),
    Some(&WORD_ARBIB_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_ARBII_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_ARBIR_NODE),
    None,
    Some(&WORD_ARBIT_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_ARBIT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ARBIT_CHILDREN),
    value: None,
};

pub static WORD_ARBIT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("arary"),
        dictgen::InsensitiveStr::Ascii("arily"),
        dictgen::InsensitiveStr::Ascii("ary"),
        dictgen::InsensitiveStr::Ascii("iarily"),
        dictgen::InsensitiveStr::Ascii("iary"),
        dictgen::InsensitiveStr::Ascii("iraly"),
        dictgen::InsensitiveStr::Ascii("iray"),
        dictgen::InsensitiveStr::Ascii("or"),
        dictgen::InsensitiveStr::Ascii("ors"),
        dictgen::InsensitiveStr::Ascii("railly"),
        dictgen::InsensitiveStr::Ascii("raily"),
        dictgen::InsensitiveStr::Ascii("raion"),
        dictgen::InsensitiveStr::Ascii("rairly"),
        dictgen::InsensitiveStr::Ascii("rairy"),
        dictgen::InsensitiveStr::Ascii("ral"),
        dictgen::InsensitiveStr::Ascii("ralily"),
        dictgen::InsensitiveStr::Ascii("rally"),
        dictgen::InsensitiveStr::Ascii("ralrily"),
        dictgen::InsensitiveStr::Ascii("ralry"),
        dictgen::InsensitiveStr::Ascii("raly"),
        dictgen::InsensitiveStr::Ascii("rarely"),
        dictgen::InsensitiveStr::Ascii("rariliy"),
        dictgen::InsensitiveStr::Ascii("rarilly"),
        dictgen::InsensitiveStr::Ascii("rarion"),
        dictgen::InsensitiveStr::Ascii("rarity"),
        dictgen::InsensitiveStr::Ascii("rariy"),
        dictgen::InsensitiveStr::Ascii("rarly"),
        dictgen::InsensitiveStr::Ascii("raryily"),
        dictgen::InsensitiveStr::Ascii("raryly"),
        dictgen::InsensitiveStr::Ascii("ratily"),
        dictgen::InsensitiveStr::Ascii("ratiojn"),
        dictgen::InsensitiveStr::Ascii("raton"),
        dictgen::InsensitiveStr::Ascii("ratrily"),
        dictgen::InsensitiveStr::Ascii("ratrion"),
        dictgen::InsensitiveStr::Ascii("ratry"),
        dictgen::InsensitiveStr::Ascii("raty"),
        dictgen::InsensitiveStr::Ascii("ray"),
        dictgen::InsensitiveStr::Ascii("re"),
        dictgen::InsensitiveStr::Ascii("rer"),
        dictgen::InsensitiveStr::Ascii("rers"),
        dictgen::InsensitiveStr::Ascii("riarily"),
        dictgen::InsensitiveStr::Ascii("riary"),
        dictgen::InsensitiveStr::Ascii("rily"),
        dictgen::InsensitiveStr::Ascii("rion"),
        dictgen::InsensitiveStr::Ascii("riraly"),
        dictgen::InsensitiveStr::Ascii("riray"),
        dictgen::InsensitiveStr::Ascii("rition"),
        dictgen::InsensitiveStr::Ascii("ror"),
        dictgen::InsensitiveStr::Ascii("rors"),
        dictgen::InsensitiveStr::Ascii("rtily"),
        dictgen::InsensitiveStr::Ascii("rty"),
        dictgen::InsensitiveStr::Ascii("ry"),
        dictgen::InsensitiveStr::Ascii("ryarily"),
        dictgen::InsensitiveStr::Ascii("ryary"),
        dictgen::InsensitiveStr::Ascii("ual"),
        dictgen::InsensitiveStr::Ascii("ually"),
        dictgen::InsensitiveStr::Ascii("ualy"),
        dictgen::InsensitiveStr::Ascii("uarily"),
        dictgen::InsensitiveStr::Ascii("uary"),
        dictgen::InsensitiveStr::Ascii("urarily"),
        dictgen::InsensitiveStr::Ascii("urary"),
        dictgen::InsensitiveStr::Ascii("ure"),
    ],
    values: &[
        &["arbitrary"],
        &["arbitrarily"],
        &["arbitrary"],
        &["arbitrarily"],
        &["arbitrary"],
        &["arbitrarily"],
        &["arbitrary"],
        &["arbiter", "arbitrator"],
        &["arbiters", "arbitrators"],
        &["arbitrarily"],
        &["arbitrarily"],
        &["arbitration"],
        &["arbitrarily"],
        &["arbitrarily", "arbitrary"],
        &["arbitrary"],
        &["arbitrarily"],
        &["arbitrarily"],
        &["arbitrarily"],
        &["arbitrary"],
        &["arbitrary"],
        &["arbitrarily"],
        &["arbitrarily"],
        &["arbitrarily"],
        &["arbitration"],
        &["arbitrarily"],
        &["arbitrarily", "arbitrary"],
        &["arbitrary", "arbitrarily"],
        &["arbitrarily"],
        &["arbitrary"],
        &["arbitrarily"],
        &["arbitration"],
        &["arbitration"],
        &["arbitrarily"],
        &["arbitration"],
        &["arbitrary"],
        &["arbitrary"],
        &["arbitrary"],
        &["arbiter"],
        &["arbiter", "arbitrator"],
        &["arbiters", "arbitrators"],
        &["arbitrarily"],
        &["arbitrary"],
        &["arbitrarily"],
        &["arbitration"],
        &["arbitrarily"],
        &["arbitrary"],
        &["arbitration"],
        &["arbiter", "arbitrator"],
        &["arbiters", "arbitrators"],
        &["arbitrarily"],
        &["arbitrary"],
        &["arbitrary"],
        &["arbitrarily"],
        &["arbitrary"],
        &["arbitrary"],
        &["arbitrarily"],
        &["arbitrary"],
        &["arbitrarily"],
        &["arbitrary"],
        &["arbitrarily"],
        &["arbitrary"],
        &["arbiter"],
    ],
    range: 2..=7,
};

static WORD_ARBIR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ARBIR_CHILDREN),
    value: None,
};

pub static WORD_ARBIR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("arily"),
        dictgen::InsensitiveStr::Ascii("ary"),
        dictgen::InsensitiveStr::Ascii("atily"),
        dictgen::InsensitiveStr::Ascii("aty"),
        dictgen::InsensitiveStr::Ascii("tarily"),
        dictgen::InsensitiveStr::Ascii("tary"),
        dictgen::InsensitiveStr::Ascii("trarily"),
        dictgen::InsensitiveStr::Ascii("trary"),
    ],
    values: &[
        &["arbitrarily"],
        &["arbitrary"],
        &["arbitrarily"],
        &["arbitrary"],
        &["arbitrarily"],
        &["arbitrary"],
        &["arbitrarily"],
        &["arbitrary"],
    ],
    range: 3..=7,
};

static WORD_ARBII_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ARBII_CHILDREN),
    value: None,
};

pub static WORD_ARBII_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("trarily"),
        dictgen::InsensitiveStr::Ascii("trary"),
    ],
    values: &[&["arbitrarily"], &["arbitrary"]],
    range: 5..=7,
};

static WORD_ARBIB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ARBIB_CHILDREN),
    value: None,
};

pub static WORD_ARBIB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("tarily"),
        dictgen::InsensitiveStr::Ascii("tary"),
        dictgen::InsensitiveStr::Ascii("trarily"),
        dictgen::InsensitiveStr::Ascii("trary"),
    ],
    values: &[
        &["arbitrarily"],
        &["arbitrary"],
        &["arbitrarily"],
        &["arbitrary"],
    ],
    range: 4..=7,
};

static WORD_ARBIA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ARBIA_CHILDREN),
    value: None,
};

pub static WORD_ARBIA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("traily"),
        dictgen::InsensitiveStr::Ascii("tray"),
    ],
    values: &[&["arbitrarily"], &["arbitrary"]],
    range: 4..=6,
};

static WORD_ARBA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ARBA_CHILDREN),
    value: None,
};

pub static WORD_ARBA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("trary")],
    values: &[&["arbitrary"]],
    range: 5..=5,
};

static WORD_ARA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ARA_CHILDREN),
    value: None,
};

pub static WORD_ARA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cnid"),
        dictgen::InsensitiveStr::Ascii("cnids"),
        dictgen::InsensitiveStr::Ascii("meters"),
        dictgen::InsensitiveStr::Ascii("mgeddon"),
        dictgen::InsensitiveStr::Ascii("nged"),
        dictgen::InsensitiveStr::Ascii("ngement"),
        dictgen::InsensitiveStr::Ascii("ound"),
        dictgen::InsensitiveStr::Ascii("rbic"),
        dictgen::InsensitiveStr::Ascii("y"),
        dictgen::InsensitiveStr::Ascii("ys"),
    ],
    values: &[
        &["arachnid"],
        &["arachnids"],
        &["parameters"],
        &["armageddon"],
        &["arranged"],
        &["arrangement"],
        &["around"],
        &["arabic"],
        &["array"],
        &["arrays"],
    ],
    range: 1..=7,
};

static WORD_AQ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AQ_CHILDREN),
    value: None,
};

pub static WORD_AQ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ain"),
        dictgen::InsensitiveStr::Ascii("aurium"),
        dictgen::InsensitiveStr::Ascii("cuaintance"),
        dictgen::InsensitiveStr::Ascii("cuaintances"),
        dictgen::InsensitiveStr::Ascii("cuainted"),
        dictgen::InsensitiveStr::Ascii("cuire"),
        dictgen::InsensitiveStr::Ascii("cuired"),
        dictgen::InsensitiveStr::Ascii("cuires"),
        dictgen::InsensitiveStr::Ascii("cuiring"),
        dictgen::InsensitiveStr::Ascii("cuisition"),
        dictgen::InsensitiveStr::Ascii("quaintance"),
        dictgen::InsensitiveStr::Ascii("quaintances"),
        dictgen::InsensitiveStr::Ascii("uaduct"),
        dictgen::InsensitiveStr::Ascii("uaint"),
        dictgen::InsensitiveStr::Ascii("uaintance"),
        dictgen::InsensitiveStr::Ascii("uainted"),
        dictgen::InsensitiveStr::Ascii("uainting"),
        dictgen::InsensitiveStr::Ascii("uaints"),
        dictgen::InsensitiveStr::Ascii("uairum"),
        dictgen::InsensitiveStr::Ascii("uarim"),
        dictgen::InsensitiveStr::Ascii("uaruim"),
        dictgen::InsensitiveStr::Ascii("ueus"),
        dictgen::InsensitiveStr::Ascii("uiantance"),
        dictgen::InsensitiveStr::Ascii("uiess"),
        dictgen::InsensitiveStr::Ascii("uiessed"),
        dictgen::InsensitiveStr::Ascii("uiesses"),
        dictgen::InsensitiveStr::Ascii("uiessing"),
        dictgen::InsensitiveStr::Ascii("uire"),
        dictgen::InsensitiveStr::Ascii("uired"),
        dictgen::InsensitiveStr::Ascii("uires"),
        dictgen::InsensitiveStr::Ascii("uiring"),
        dictgen::InsensitiveStr::Ascii("uisition"),
        dictgen::InsensitiveStr::Ascii("uisitions"),
        dictgen::InsensitiveStr::Ascii("uit"),
        dictgen::InsensitiveStr::Ascii("uitted"),
        dictgen::InsensitiveStr::Ascii("uries"),
    ],
    values: &[
        &["again"],
        &["aquarium"],
        &["acquaintance"],
        &["acquaintances"],
        &["acquainted"],
        &["acquire"],
        &["acquired"],
        &["acquires"],
        &["acquiring"],
        &["acquisition"],
        &["acquaintance"],
        &["acquaintances"],
        &["aqueduct"],
        &["acquaint"],
        &["acquaintance"],
        &["acquainted"],
        &["acquainting"],
        &["acquaints"],
        &["aquarium"],
        &["aquarium"],
        &["aquarium"],
        &["aqueous"],
        &["acquaintance"],
        &["acquiesce"],
        &["acquiesced"],
        &["acquiesces"],
        &["acquiescing"],
        &["acquire"],
        &["acquired"],
        &["acquires"],
        &["acquiring"],
        &["acquisition"],
        &["acquisitions"],
        &["acquit"],
        &["acquitted"],
        &["acquires", "equerries"],
    ],
    range: 3..=11,
};

static WORD_AP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_AP_CHILDREN),
    value: None,
};

static WORD_AP_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_APA_NODE),
    None,
    None,
    Some(&WORD_APD_NODE),
    Some(&WORD_APE_NODE),
    None,
    None,
    None,
    Some(&WORD_API_NODE),
    None,
    None,
    Some(&WORD_APL_NODE),
    None,
    None,
    Some(&WORD_APO_NODE),
    Some(&WORD_APP_NODE),
    None,
    Some(&WORD_APR_NODE),
    Some(&WORD_APS_NODE),
    Some(&WORD_APT_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_APY_NODE),
    None,
];

static WORD_APY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_APY_CHILDREN),
    value: None,
};

pub static WORD_APY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("oon"),
        dictgen::InsensitiveStr::Ascii("ooned"),
        dictgen::InsensitiveStr::Ascii("ooning"),
        dictgen::InsensitiveStr::Ascii("oons"),
    ],
    values: &[&["oppugn"], &["oppugned"], &["oppugning"], &["oppugns"]],
    range: 3..=6,
};

static WORD_APT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_APT_CHILDREN),
    value: None,
};

pub static WORD_APT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("itudine")],
    values: &[&["aptitude"]],
    range: 7..=7,
};

static WORD_APS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_APS_CHILDREN),
    value: None,
};

pub static WORD_APS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aragus"),
        dictgen::InsensitiveStr::Ascii("ects"),
        dictgen::InsensitiveStr::Ascii("ergers"),
        dictgen::InsensitiveStr::Ascii("halt"),
        dictgen::InsensitiveStr::Ascii("irations"),
        dictgen::InsensitiveStr::Ascii("irin"),
        dictgen::InsensitiveStr::Ascii("otles"),
        dictgen::InsensitiveStr::Ascii("otrophe"),
    ],
    values: &[
        &["asparagus"],
        &["aspects"],
        &["aspergers"],
        &["asphalt"],
        &["aspirations"],
        &["aspirin"],
        &["apostles"],
        &["apostrophe"],
    ],
    range: 4..=8,
};

static WORD_APR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_APR_CHILDREN),
    value: None,
};

pub static WORD_APR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("atheid"),
        dictgen::InsensitiveStr::Ascii("eciate"),
        dictgen::InsensitiveStr::Ascii("eciated"),
        dictgen::InsensitiveStr::Ascii("eciates"),
        dictgen::InsensitiveStr::Ascii("eciating"),
        dictgen::InsensitiveStr::Ascii("eciation"),
        dictgen::InsensitiveStr::Ascii("eciative"),
        dictgen::InsensitiveStr::Ascii("ehensive"),
        dictgen::InsensitiveStr::Ascii("esheation"),
        dictgen::InsensitiveStr::Ascii("eteate"),
        dictgen::InsensitiveStr::Ascii("eteated"),
        dictgen::InsensitiveStr::Ascii("eteating"),
        dictgen::InsensitiveStr::Ascii("etiate"),
        dictgen::InsensitiveStr::Ascii("etiated"),
        dictgen::InsensitiveStr::Ascii("etiates"),
        dictgen::InsensitiveStr::Ascii("etiating"),
        dictgen::InsensitiveStr::Ascii("etiation"),
        dictgen::InsensitiveStr::Ascii("etiative"),
        dictgen::InsensitiveStr::Ascii("eture"),
        dictgen::InsensitiveStr::Ascii("oach"),
        dictgen::InsensitiveStr::Ascii("oached"),
        dictgen::InsensitiveStr::Ascii("oaches"),
        dictgen::InsensitiveStr::Ascii("oaching"),
        dictgen::InsensitiveStr::Ascii("och"),
        dictgen::InsensitiveStr::Ascii("oched"),
        dictgen::InsensitiveStr::Ascii("oches"),
        dictgen::InsensitiveStr::Ascii("oching"),
        dictgen::InsensitiveStr::Ascii("oove"),
        dictgen::InsensitiveStr::Ascii("ooved"),
        dictgen::InsensitiveStr::Ascii("opiate"),
        dictgen::InsensitiveStr::Ascii("opiately"),
        dictgen::InsensitiveStr::Ascii("opriate"),
        dictgen::InsensitiveStr::Ascii("opriately"),
        dictgen::InsensitiveStr::Ascii("oval"),
        dictgen::InsensitiveStr::Ascii("ove"),
        dictgen::InsensitiveStr::Ascii("oximate"),
        dictgen::InsensitiveStr::Ascii("oximately"),
        dictgen::InsensitiveStr::Ascii("oximates"),
        dictgen::InsensitiveStr::Ascii("oximation"),
        dictgen::InsensitiveStr::Ascii("oximations"),
        dictgen::InsensitiveStr::Ascii("rovement"),
        dictgen::InsensitiveStr::Ascii("roximate"),
        dictgen::InsensitiveStr::Ascii("roximately"),
        dictgen::InsensitiveStr::Ascii("roximates"),
        dictgen::InsensitiveStr::Ascii("roximation"),
        dictgen::InsensitiveStr::Ascii("roximations"),
        dictgen::InsensitiveStr::Ascii("tment"),
    ],
    values: &[
        &["apartheid"],
        &["appreciate"],
        &["appreciated"],
        &["appreciates"],
        &["appreciating"],
        &["appreciation"],
        &["appreciative"],
        &["apprehensive"],
        &["appreciation"],
        &["appreciate"],
        &["appreciated"],
        &["appreciating"],
        &["appreciate"],
        &["appreciated"],
        &["appreciates"],
        &["appreciating"],
        &["appreciation"],
        &["appreciative"],
        &["aperture"],
        &["approach"],
        &["approached"],
        &["approaches"],
        &["approaching"],
        &["approach"],
        &["approached"],
        &["approaches"],
        &["approaching"],
        &["approve"],
        &["approved"],
        &["appropriate"],
        &["appropriately"],
        &["appropriate"],
        &["appropriately"],
        &["approval"],
        &["approve"],
        &["approximate"],
        &["approximately"],
        &["approximates"],
        &["approximation"],
        &["approximations"],
        &["approval"],
        &["approximate"],
        &["approximately"],
        &["approximates"],
        &["approximation"],
        &["approximations"],
        &["apartment"],
    ],
    range: 3..=11,
};

static WORD_APP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_APP_CHILDREN),
    value: None,
};

static WORD_APP_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_APPA_NODE),
    None,
    None,
    None,
    Some(&WORD_APPE_NODE),
    None,
    None,
    None,
    Some(&WORD_APPI_NODE),
    None,
    None,
    Some(&WORD_APPL_NODE),
    None,
    Some(&WORD_APPN_NODE),
    Some(&WORD_APPO_NODE),
    Some(&WORD_APPP_NODE),
    None,
    Some(&WORD_APPR_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_APPY_NODE),
    None,
];

static WORD_APPY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_APPY_CHILDREN),
    value: Some(&["apply"]),
};

pub static WORD_APPY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ing")],
    values: &[&["applying"]],
    range: 3..=3,
};

static WORD_APPR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_APPR_CHILDREN),
    value: None,
};

static WORD_APPR_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_APPRA_NODE),
    None,
    None,
    None,
    Some(&WORD_APPRE_NODE),
    None,
    None,
    None,
    Some(&WORD_APPRI_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_APPRO_NODE),
    Some(&WORD_APPRP_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_APPRP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_APPRP_CHILDREN),
    value: None,
};

pub static WORD_APPRP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("riate"),
        dictgen::InsensitiveStr::Ascii("riately"),
    ],
    values: &[&["appropriate"], &["appropriately"]],
    range: 5..=7,
};

static WORD_APPRO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_APPRO_CHILDREN),
    value: None,
};

static WORD_APPRO_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_APPROA_NODE),
    Some(&WORD_APPROB_NODE),
    Some(&WORD_APPROC_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_APPROI_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_APPROO_NODE),
    Some(&WORD_APPROP_NODE),
    None,
    Some(&WORD_APPROR_NODE),
    Some(&WORD_APPROS_NODE),
    None,
    Some(&WORD_APPROU_NODE),
    Some(&WORD_APPROV_NODE),
    None,
    Some(&WORD_APPROX_NODE),
    None,
    None,
];

static WORD_APPROX_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_APPROX_CHILDREN),
    value: None,
};

pub static WORD_APPROX_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("amate"),
        dictgen::InsensitiveStr::Ascii("amately"),
        dictgen::InsensitiveStr::Ascii("amates"),
        dictgen::InsensitiveStr::Ascii("amation"),
        dictgen::InsensitiveStr::Ascii("amations"),
        dictgen::InsensitiveStr::Ascii("amatly"),
        dictgen::InsensitiveStr::Ascii("ametely"),
        dictgen::InsensitiveStr::Ascii("iamte"),
        dictgen::InsensitiveStr::Ascii("iamtely"),
        dictgen::InsensitiveStr::Ascii("iamtes"),
        dictgen::InsensitiveStr::Ascii("iamtion"),
        dictgen::InsensitiveStr::Ascii("iamtions"),
        dictgen::InsensitiveStr::Ascii("iate"),
        dictgen::InsensitiveStr::Ascii("iately"),
        dictgen::InsensitiveStr::Ascii("iates"),
        dictgen::InsensitiveStr::Ascii("iation"),
        dictgen::InsensitiveStr::Ascii("iations"),
        dictgen::InsensitiveStr::Ascii("imatelly"),
        dictgen::InsensitiveStr::Ascii("imatively"),
        dictgen::InsensitiveStr::Ascii("imatley"),
        dictgen::InsensitiveStr::Ascii("imatly"),
        dictgen::InsensitiveStr::Ascii("imed"),
        dictgen::InsensitiveStr::Ascii("imetely"),
        dictgen::InsensitiveStr::Ascii("imetly"),
        dictgen::InsensitiveStr::Ascii("imitely"),
        dictgen::InsensitiveStr::Ascii("mate"),
        dictgen::InsensitiveStr::Ascii("mately"),
        dictgen::InsensitiveStr::Ascii("mates"),
        dictgen::InsensitiveStr::Ascii("mation"),
        dictgen::InsensitiveStr::Ascii("mations"),
        dictgen::InsensitiveStr::Ascii("miate"),
        dictgen::InsensitiveStr::Ascii("mimation"),
    ],
    values: &[
        &["approximate"],
        &["approximately"],
        &["approximates"],
        &["approximation"],
        &["approximations"],
        &["approximately"],
        &["approximately"],
        &["approximate"],
        &["approximately"],
        &["approximates"],
        &["approximation"],
        &["approximations"],
        &["approximate"],
        &["approximately"],
        &["approximates"],
        &["approximation"],
        &["approximations"],
        &["approximately"],
        &["approximately"],
        &["approximately"],
        &["approximately"],
        &["approximated"],
        &["approximately"],
        &["approximately"],
        &["approximately"],
        &["approximate"],
        &["approximately"],
        &["approximates"],
        &["approximation"],
        &["approximations"],
        &["approximate"],
        &["approximation"],
    ],
    range: 4..=9,
};

static WORD_APPROV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_APPROV_CHILDREN),
    value: None,
};

pub static WORD_APPROV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ement")],
    values: &[&["approval"]],
    range: 5..=5,
};

static WORD_APPROU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_APPROU_CHILDREN),
    value: None,
};

pub static WORD_APPROU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("val"),
        dictgen::InsensitiveStr::Ascii("ve"),
        dictgen::InsensitiveStr::Ascii("ved"),
        dictgen::InsensitiveStr::Ascii("ves"),
        dictgen::InsensitiveStr::Ascii("ving"),
    ],
    values: &[
        &["approval"],
        &["approve"],
        &["approved"],
        &["approves"],
        &["approving"],
    ],
    range: 2..=4,
};

static WORD_APPROS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_APPROS_CHILDREN),
    value: None,
};

pub static WORD_APPROS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("traphe")],
    values: &[&["apostrophe"]],
    range: 6..=6,
};

static WORD_APPROR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_APPROR_CHILDREN),
    value: None,
};

pub static WORD_APPROR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("iate"),
        dictgen::InsensitiveStr::Ascii("iately"),
        dictgen::InsensitiveStr::Ascii("piation"),
        dictgen::InsensitiveStr::Ascii("priate"),
        dictgen::InsensitiveStr::Ascii("priately"),
    ],
    values: &[
        &["appropriate"],
        &["appropriately"],
        &["appropriation"],
        &["appropriate"],
        &["appropriately"],
    ],
    range: 4..=8,
};

static WORD_APPROP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_APPROP_CHILDREN),
    value: None,
};

pub static WORD_APPROP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eriate"),
        dictgen::InsensitiveStr::Ascii("iate"),
        dictgen::InsensitiveStr::Ascii("iately"),
        dictgen::InsensitiveStr::Ascii("irate"),
        dictgen::InsensitiveStr::Ascii("irately"),
        dictgen::InsensitiveStr::Ascii("iration"),
        dictgen::InsensitiveStr::Ascii("priately"),
        dictgen::InsensitiveStr::Ascii("raite"),
        dictgen::InsensitiveStr::Ascii("raitely"),
        dictgen::InsensitiveStr::Ascii("rate"),
        dictgen::InsensitiveStr::Ascii("rated"),
        dictgen::InsensitiveStr::Ascii("rately"),
        dictgen::InsensitiveStr::Ascii("ration"),
        dictgen::InsensitiveStr::Ascii("rations"),
        dictgen::InsensitiveStr::Ascii("reation"),
        dictgen::InsensitiveStr::Ascii("riage"),
        dictgen::InsensitiveStr::Ascii("riatedly"),
        dictgen::InsensitiveStr::Ascii("riatee"),
        dictgen::InsensitiveStr::Ascii("riatin"),
        dictgen::InsensitiveStr::Ascii("riatley"),
        dictgen::InsensitiveStr::Ascii("riatly"),
        dictgen::InsensitiveStr::Ascii("riatness"),
        dictgen::InsensitiveStr::Ascii("riato"),
        dictgen::InsensitiveStr::Ascii("riaton"),
        dictgen::InsensitiveStr::Ascii("riete"),
        dictgen::InsensitiveStr::Ascii("rietly"),
        dictgen::InsensitiveStr::Ascii("ritae"),
        dictgen::InsensitiveStr::Ascii("ritate"),
        dictgen::InsensitiveStr::Ascii("ritately"),
        dictgen::InsensitiveStr::Ascii("rite"),
        dictgen::InsensitiveStr::Ascii("roate"),
        dictgen::InsensitiveStr::Ascii("ropiate"),
        dictgen::InsensitiveStr::Ascii("ropiately"),
        dictgen::InsensitiveStr::Ascii("ropreate"),
        dictgen::InsensitiveStr::Ascii("ropriate"),
        dictgen::InsensitiveStr::Ascii("roximate"),
        dictgen::InsensitiveStr::Ascii("roximately"),
        dictgen::InsensitiveStr::Ascii("roximates"),
        dictgen::InsensitiveStr::Ascii("roximation"),
        dictgen::InsensitiveStr::Ascii("roximations"),
        dictgen::InsensitiveStr::Ascii("rpiate"),
    ],
    values: &[
        &["appropriate"],
        &["appropriate"],
        &["appropriately"],
        &["appropriate"],
        &["appropriately"],
        &["appropriation"],
        &["appropriately"],
        &["appropriate"],
        &["appropriately"],
        &["appropriate"],
        &["appropriated"],
        &["appropriately"],
        &["appropriation"],
        &["appropriations"],
        &["appropriation"],
        &["appropriate"],
        &["appropriately"],
        &["appropriate"],
        &["appropriation"],
        &["appropriately"],
        &["appropriately"],
        &["appropriateness"],
        &["appropriation"],
        &["appropriation"],
        &["appropriate"],
        &["appropriately"],
        &["appropriate"],
        &["appropriate"],
        &["appropriately"],
        &["appropriate"],
        &["appropriate"],
        &["appropriate"],
        &["appropriately"],
        &["appropriate"],
        &["appropriate"],
        &["approximate"],
        &["approximately"],
        &["approximates"],
        &["approximation"],
        &["approximations"],
        &["appropriate"],
    ],
    range: 4..=11,
};

static WORD_APPROO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_APPROO_CHILDREN),
    value: None,
};

pub static WORD_APPROO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("priate"),
        dictgen::InsensitiveStr::Ascii("ximate"),
        dictgen::InsensitiveStr::Ascii("ximately"),
        dictgen::InsensitiveStr::Ascii("ximates"),
        dictgen::InsensitiveStr::Ascii("ximation"),
        dictgen::InsensitiveStr::Ascii("ximations"),
    ],
    values: &[
        &["appropriate"],
        &["approximate"],
        &["approximately"],
        &["approximates"],
        &["approximation"],
        &["approximations"],
    ],
    range: 6..=9,
};

static WORD_APPROI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_APPROI_CHILDREN),
    value: None,
};

pub static WORD_APPROI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ate"),
        dictgen::InsensitiveStr::Ascii("mation"),
    ],
    values: &[&["appropriate"], &["approximation"]],
    range: 3..=6,
};

static WORD_APPROC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_APPROC_CHILDREN),
    value: None,
};

pub static WORD_APPROC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("h"),
        dictgen::InsensitiveStr::Ascii("he"),
        dictgen::InsensitiveStr::Ascii("hed"),
        dictgen::InsensitiveStr::Ascii("hes"),
        dictgen::InsensitiveStr::Ascii("hing"),
    ],
    values: &[
        &["approach"],
        &["approach"],
        &["approached"],
        &["approaches"],
        &["approaching"],
    ],
    range: 1..=4,
};

static WORD_APPROB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_APPROB_CHILDREN),
    value: None,
};

pub static WORD_APPROB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("iate")],
    values: &[&["appropriate"]],
    range: 4..=4,
};

static WORD_APPROA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_APPROA_CHILDREN),
    value: None,
};

pub static WORD_APPROA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("chs"),
        dictgen::InsensitiveStr::Ascii("cing"),
    ],
    values: &[&["approaches"], &["approaching"]],
    range: 3..=4,
};

static WORD_APPRI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_APPRI_CHILDREN),
    value: None,
};

pub static WORD_APPRI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ceate"),
        dictgen::InsensitiveStr::Ascii("ciate"),
        dictgen::InsensitiveStr::Ascii("ciated"),
        dictgen::InsensitiveStr::Ascii("ciates"),
        dictgen::InsensitiveStr::Ascii("ecate"),
        dictgen::InsensitiveStr::Ascii("eciate"),
        dictgen::InsensitiveStr::Ascii("eciated"),
        dictgen::InsensitiveStr::Ascii("eciates"),
        dictgen::InsensitiveStr::Ascii("eciating"),
        dictgen::InsensitiveStr::Ascii("eciation"),
        dictgen::InsensitiveStr::Ascii("eciative"),
        dictgen::InsensitiveStr::Ascii("opriate"),
        dictgen::InsensitiveStr::Ascii("priate"),
        dictgen::InsensitiveStr::Ascii("proate"),
        dictgen::InsensitiveStr::Ascii("xamate"),
        dictgen::InsensitiveStr::Ascii("xamated"),
        dictgen::InsensitiveStr::Ascii("xamately"),
        dictgen::InsensitiveStr::Ascii("xamates"),
        dictgen::InsensitiveStr::Ascii("xamating"),
        dictgen::InsensitiveStr::Ascii("xamation"),
        dictgen::InsensitiveStr::Ascii("xamations"),
        dictgen::InsensitiveStr::Ascii("ximate"),
        dictgen::InsensitiveStr::Ascii("ximated"),
        dictgen::InsensitiveStr::Ascii("ximately"),
        dictgen::InsensitiveStr::Ascii("ximates"),
        dictgen::InsensitiveStr::Ascii("ximating"),
        dictgen::InsensitiveStr::Ascii("ximation"),
        dictgen::InsensitiveStr::Ascii("ximations"),
    ],
    values: &[
        &["appreciates"],
        &["appreciate"],
        &["appreciated"],
        &["appreciates"],
        &["appreciates"],
        &["appreciate"],
        &["appreciated"],
        &["appreciates"],
        &["appreciating"],
        &["appreciation"],
        &["appreciative"],
        &["appropriate"],
        &["appropriate"],
        &["appropriate"],
        &["approximate"],
        &["approximated"],
        &["approximately"],
        &["approximates"],
        &["approximating"],
        &["approximation"],
        &["approximations"],
        &["approximate"],
        &["approximated"],
        &["approximately"],
        &["approximates"],
        &["approximating"],
        &["approximation"],
        &["approximations"],
    ],
    range: 5..=9,
};

static WORD_APPRE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_APPRE_CHILDREN),
    value: None,
};

pub static WORD_APPRE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("arance"),
        dictgen::InsensitiveStr::Ascii("caite"),
        dictgen::InsensitiveStr::Ascii("caited"),
        dictgen::InsensitiveStr::Ascii("caites"),
        dictgen::InsensitiveStr::Ascii("ceating"),
        dictgen::InsensitiveStr::Ascii("ciae"),
        dictgen::InsensitiveStr::Ascii("ciaite"),
        dictgen::InsensitiveStr::Ascii("ciateing"),
        dictgen::InsensitiveStr::Ascii("ciateive"),
        dictgen::InsensitiveStr::Ascii("ciaters"),
        dictgen::InsensitiveStr::Ascii("ciatie"),
        dictgen::InsensitiveStr::Ascii("ciatied"),
        dictgen::InsensitiveStr::Ascii("ciatin"),
        dictgen::InsensitiveStr::Ascii("ciationg"),
        dictgen::InsensitiveStr::Ascii("ciato"),
        dictgen::InsensitiveStr::Ascii("ciaton"),
        dictgen::InsensitiveStr::Ascii("ciatve"),
        dictgen::InsensitiveStr::Ascii("ciste"),
        dictgen::InsensitiveStr::Ascii("citae"),
        dictgen::InsensitiveStr::Ascii("cited"),
        dictgen::InsensitiveStr::Ascii("ctice"),
        dictgen::InsensitiveStr::Ascii("icate"),
        dictgen::InsensitiveStr::Ascii("icated"),
        dictgen::InsensitiveStr::Ascii("icates"),
        dictgen::InsensitiveStr::Ascii("icating"),
        dictgen::InsensitiveStr::Ascii("ication"),
        dictgen::InsensitiveStr::Ascii("nded"),
        dictgen::InsensitiveStr::Ascii("ndice"),
        dictgen::InsensitiveStr::Ascii("ntace"),
        dictgen::InsensitiveStr::Ascii("ntie"),
        dictgen::InsensitiveStr::Ascii("ntince"),
        dictgen::InsensitiveStr::Ascii("ntise"),
        dictgen::InsensitiveStr::Ascii("ntly"),
        dictgen::InsensitiveStr::Ascii("teate"),
        dictgen::InsensitiveStr::Ascii("teated"),
        dictgen::InsensitiveStr::Ascii("tiate"),
        dictgen::InsensitiveStr::Ascii("tiated"),
        dictgen::InsensitiveStr::Ascii("tiates"),
        dictgen::InsensitiveStr::Ascii("tiating"),
        dictgen::InsensitiveStr::Ascii("tiation"),
        dictgen::InsensitiveStr::Ascii("tiative"),
        dictgen::InsensitiveStr::Ascii("tince"),
    ],
    values: &[
        &["appearance"],
        &["appreciate"],
        &["appreciated"],
        &["appreciates"],
        &["appreciating"],
        &["appreciates"],
        &["appreciative"],
        &["appreciating"],
        &["appreciative"],
        &["appreciates"],
        &["appreciative"],
        &["appreciative"],
        &["appreciation"],
        &["appreciating"],
        &["appreciation"],
        &["appreciation"],
        &["appreciative"],
        &["appreciates"],
        &["appreciates"],
        &["appreciated"],
        &["apprentice"],
        &["appreciate"],
        &["appreciated"],
        &["appreciates"],
        &["appreciating"],
        &["appreciation"],
        &["appended", "apprehended"],
        &["apprentice"],
        &["apprentice"],
        &["apprentice"],
        &["apprentice"],
        &["apprentice"],
        &["apparently"],
        &["appreciate"],
        &["appreciated"],
        &["appreciate"],
        &["appreciated"],
        &["appreciates"],
        &["appreciating"],
        &["appreciation"],
        &["appreciative"],
        &["apprentice"],
    ],
    range: 4..=8,
};

static WORD_APPRA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_APPRA_CHILDREN),
    value: None,
};

pub static WORD_APPRA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ent"),
        dictgen::InsensitiveStr::Ascii("ently"),
        dictgen::InsensitiveStr::Ascii("och"),
        dictgen::InsensitiveStr::Ascii("ochable"),
        dictgen::InsensitiveStr::Ascii("oched"),
        dictgen::InsensitiveStr::Ascii("oches"),
        dictgen::InsensitiveStr::Ascii("oching"),
    ],
    values: &[
        &["apparent"],
        &["apparently"],
        &["approach"],
        &["approachable"],
        &["approached"],
        &["approaches"],
        &["approaching"],
    ],
    range: 3..=7,
};

static WORD_APPP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_APPP_CHILDREN),
    value: None,
};

pub static WORD_APPP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ear"),
        dictgen::InsensitiveStr::Ascii("ears"),
        dictgen::InsensitiveStr::Ascii("end"),
        dictgen::InsensitiveStr::Ascii("ends"),
        dictgen::InsensitiveStr::Ascii("let"),
        dictgen::InsensitiveStr::Ascii("lication"),
        dictgen::InsensitiveStr::Ascii("lications"),
        dictgen::InsensitiveStr::Ascii("lying"),
        dictgen::InsensitiveStr::Ascii("riate"),
        dictgen::InsensitiveStr::Ascii("roach"),
        dictgen::InsensitiveStr::Ascii("ropriate"),
    ],
    values: &[
        &["appear"],
        &["appears"],
        &["append"],
        &["appends"],
        &["applet"],
        &["application"],
        &["applications"],
        &["applying"],
        &["appropriate"],
        &["approach"],
        &["appropriate"],
    ],
    range: 3..=9,
};

static WORD_APPO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_APPO_CHILDREN),
    value: None,
};

pub static WORD_APPO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("intmet"),
        dictgen::InsensitiveStr::Ascii("itnment"),
        dictgen::InsensitiveStr::Ascii("itnments"),
        dictgen::InsensitiveStr::Ascii("logies"),
        dictgen::InsensitiveStr::Ascii("logy"),
        dictgen::InsensitiveStr::Ascii("n"),
        dictgen::InsensitiveStr::Ascii("priate"),
        dictgen::InsensitiveStr::Ascii("rach"),
        dictgen::InsensitiveStr::Ascii("rachable"),
        dictgen::InsensitiveStr::Ascii("rached"),
        dictgen::InsensitiveStr::Ascii("raches"),
        dictgen::InsensitiveStr::Ascii("raching"),
        dictgen::InsensitiveStr::Ascii("riate"),
        dictgen::InsensitiveStr::Ascii("roximate"),
        dictgen::InsensitiveStr::Ascii("roximated"),
        dictgen::InsensitiveStr::Ascii("rpiate"),
        dictgen::InsensitiveStr::Ascii("rpriate"),
        dictgen::InsensitiveStr::Ascii("rpriated"),
        dictgen::InsensitiveStr::Ascii("rpriately"),
        dictgen::InsensitiveStr::Ascii("rpriates"),
        dictgen::InsensitiveStr::Ascii("rpriating"),
        dictgen::InsensitiveStr::Ascii("rpriation"),
        dictgen::InsensitiveStr::Ascii("rpriations"),
        dictgen::InsensitiveStr::Ascii("rval"),
        dictgen::InsensitiveStr::Ascii("rve"),
        dictgen::InsensitiveStr::Ascii("rved"),
        dictgen::InsensitiveStr::Ascii("rves"),
        dictgen::InsensitiveStr::Ascii("rving"),
        dictgen::InsensitiveStr::Ascii("rximate"),
        dictgen::InsensitiveStr::Ascii("rximately"),
        dictgen::InsensitiveStr::Ascii("val"),
        dictgen::InsensitiveStr::Ascii("ve"),
        dictgen::InsensitiveStr::Ascii("ved"),
        dictgen::InsensitiveStr::Ascii("ves"),
        dictgen::InsensitiveStr::Ascii("ving"),
        dictgen::InsensitiveStr::Ascii("ximate"),
        dictgen::InsensitiveStr::Ascii("ximately"),
        dictgen::InsensitiveStr::Ascii("ximates"),
        dictgen::InsensitiveStr::Ascii("ximation"),
        dictgen::InsensitiveStr::Ascii("ximations"),
    ],
    values: &[
        &["appointments"],
        &["appointments"],
        &["appointments"],
        &["apologies"],
        &["apology"],
        &["upon"],
        &["appropriate"],
        &["approach"],
        &["approachable"],
        &["approached"],
        &["approaches"],
        &["approaching"],
        &["appropriate"],
        &["approximate"],
        &["approximated"],
        &["appropriate"],
        &["appropriate"],
        &["appropriated"],
        &["appropriately"],
        &["appropriates"],
        &["appropriating"],
        &["appropriation"],
        &["appropriations"],
        &["approval"],
        &["approve"],
        &["approved"],
        &["approves"],
        &["approving"],
        &["approximate"],
        &["approximately"],
        &["approval"],
        &["approve"],
        &["approved"],
        &["approves"],
        &["approving"],
        &["approximate"],
        &["approximately"],
        &["approximates"],
        &["approximation"],
        &["approximations"],
    ],
    range: 1..=10,
};

static WORD_APPN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_APPN_CHILDREN),
    value: None,
};

pub static WORD_APPN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ed")],
    values: &[&["append"]],
    range: 2..=2,
};

static WORD_APPL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_APPL_CHILDREN),
    value: None,
};

pub static WORD_APPL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ainces"),
        dictgen::InsensitiveStr::Ascii("audes"),
        dictgen::InsensitiveStr::Ascii("aued"),
        dictgen::InsensitiveStr::Ascii("ay"),
        dictgen::InsensitiveStr::Ascii("cation"),
        dictgen::InsensitiveStr::Ascii("cations"),
        dictgen::InsensitiveStr::Ascii("ciation"),
        dictgen::InsensitiveStr::Ascii("ciations"),
        dictgen::InsensitiveStr::Ascii("iable"),
        dictgen::InsensitiveStr::Ascii("iacable"),
        dictgen::InsensitiveStr::Ascii("iaction"),
        dictgen::InsensitiveStr::Ascii("iactions"),
        dictgen::InsensitiveStr::Ascii("iation"),
        dictgen::InsensitiveStr::Ascii("iations"),
        dictgen::InsensitiveStr::Ascii("icabel"),
        dictgen::InsensitiveStr::Ascii("icabile"),
        dictgen::InsensitiveStr::Ascii("icaion"),
        dictgen::InsensitiveStr::Ascii("icaions"),
        dictgen::InsensitiveStr::Ascii("icaition"),
        dictgen::InsensitiveStr::Ascii("icaiton"),
        dictgen::InsensitiveStr::Ascii("icaitons"),
        dictgen::InsensitiveStr::Ascii("icalbe"),
        dictgen::InsensitiveStr::Ascii("icance"),
        dictgen::InsensitiveStr::Ascii("icapility"),
        dictgen::InsensitiveStr::Ascii("icaple"),
        dictgen::InsensitiveStr::Ascii("icatable"),
        dictgen::InsensitiveStr::Ascii("icaten"),
        dictgen::InsensitiveStr::Ascii("icatin"),
        dictgen::InsensitiveStr::Ascii("icatino"),
        dictgen::InsensitiveStr::Ascii("icatins"),
        dictgen::InsensitiveStr::Ascii("icatio"),
        dictgen::InsensitiveStr::Ascii("icationb"),
        dictgen::InsensitiveStr::Ascii("icatios"),
        dictgen::InsensitiveStr::Ascii("icatiosn"),
        dictgen::InsensitiveStr::Ascii("icato"),
        dictgen::InsensitiveStr::Ascii("icaton"),
        dictgen::InsensitiveStr::Ascii("icatons"),
        dictgen::InsensitiveStr::Ascii("icible"),
        dictgen::InsensitiveStr::Ascii("iction"),
        dictgen::InsensitiveStr::Ascii("ictions"),
        dictgen::InsensitiveStr::Ascii("ide"),
        dictgen::InsensitiveStr::Ascii("ie"),
        dictgen::InsensitiveStr::Ascii("iences"),
        dictgen::InsensitiveStr::Ascii("ikation"),
        dictgen::InsensitiveStr::Ascii("ikations"),
        dictgen::InsensitiveStr::Ascii("ikay"),
        dictgen::InsensitiveStr::Ascii("ikays"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("izes"),
        dictgen::InsensitiveStr::Ascii("lied"),
        dictgen::InsensitiveStr::Ascii("ly"),
        dictgen::InsensitiveStr::Ascii("uad"),
        dictgen::InsensitiveStr::Ascii("uase"),
        dictgen::InsensitiveStr::Ascii("yable"),
        dictgen::InsensitiveStr::Ascii("ycable"),
        dictgen::InsensitiveStr::Ascii("yed"),
        dictgen::InsensitiveStr::Ascii("yes"),
        dictgen::InsensitiveStr::Ascii("yied"),
        dictgen::InsensitiveStr::Ascii("yig"),
        dictgen::InsensitiveStr::Ascii("ys"),
        dictgen::InsensitiveStr::Ascii("yting"),
    ],
    values: &[
        &["appliances"],
        &["applause"],
        &["applaud"],
        &["apply"],
        &["application"],
        &["applications"],
        &["application"],
        &["applications"],
        &["applicable"],
        &["applicable"],
        &["application"],
        &["applications"],
        &["application"],
        &["applications"],
        &["applicable"],
        &["applicable"],
        &["application"],
        &["applications"],
        &["application"],
        &["application"],
        &["applications"],
        &["applicable"],
        &["appliance"],
        &["applicability"],
        &["applicable"],
        &["applicable"],
        &["application"],
        &["application"],
        &["application"],
        &["applicants", "applications"],
        &["application"],
        &["application"],
        &["applications"],
        &["applications"],
        &["application"],
        &["application"],
        &["applications"],
        &["applicable"],
        &["application"],
        &["applications"],
        &["applied"],
        &["applied", "apply"],
        &["appliances"],
        &["application"],
        &["applications"],
        &["appliqué"],
        &["appliqués"],
        &["applying", "appalling"],
        &["applies"],
        &["applied"],
        &["apply"],
        &["applaud"],
        &["applause"],
        &["applicable"],
        &["applicable"],
        &["applied"],
        &["applies"],
        &["applied"],
        &["applying"],
        &["applies"],
        &["applying"],
    ],
    range: 2..=9,
};

static WORD_APPI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_APPI_CHILDREN),
    value: None,
};

pub static WORD_APPI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cability"),
        dictgen::InsensitiveStr::Ascii("cable"),
        dictgen::InsensitiveStr::Ascii("caliton"),
        dictgen::InsensitiveStr::Ascii("calitons"),
        dictgen::InsensitiveStr::Ascii("cant"),
        dictgen::InsensitiveStr::Ascii("cation"),
        dictgen::InsensitiveStr::Ascii("cations"),
        dictgen::InsensitiveStr::Ascii("cative"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("es"),
    ],
    values: &[
        &["applicability"],
        &["applicable"],
        &["application"],
        &["applications"],
        &["applicant"],
        &["application"],
        &["applications"],
        &["applicative"],
        &["applied"],
        &["applies"],
    ],
    range: 2..=8,
};

static WORD_APPE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_APPE_CHILDREN),
    value: None,
};

pub static WORD_APPE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("alling"),
        dictgen::InsensitiveStr::Ascii("araing"),
        dictgen::InsensitiveStr::Ascii("arane"),
        dictgen::InsensitiveStr::Ascii("arantly"),
        dictgen::InsensitiveStr::Ascii("ard"),
        dictgen::InsensitiveStr::Ascii("areance"),
        dictgen::InsensitiveStr::Ascii("arence"),
        dictgen::InsensitiveStr::Ascii("arences"),
        dictgen::InsensitiveStr::Ascii("arently"),
        dictgen::InsensitiveStr::Ascii("ares"),
        dictgen::InsensitiveStr::Ascii("arnace"),
        dictgen::InsensitiveStr::Ascii("arning"),
        dictgen::InsensitiveStr::Ascii("arrs"),
        dictgen::InsensitiveStr::Ascii("ciate"),
        dictgen::InsensitiveStr::Ascii("ded"),
        dictgen::InsensitiveStr::Ascii("ding"),
        dictgen::InsensitiveStr::Ascii("dn"),
        dictgen::InsensitiveStr::Ascii("n"),
        dictgen::InsensitiveStr::Ascii("ndend"),
        dictgen::InsensitiveStr::Ascii("ndent"),
        dictgen::InsensitiveStr::Ascii("ndex"),
        dictgen::InsensitiveStr::Ascii("ndig"),
        dictgen::InsensitiveStr::Ascii("ndign"),
        dictgen::InsensitiveStr::Ascii("ndt"),
        dictgen::InsensitiveStr::Ascii("ned"),
        dictgen::InsensitiveStr::Ascii("neded"),
        dictgen::InsensitiveStr::Ascii("nging"),
        dictgen::InsensitiveStr::Ascii("nines"),
        dictgen::InsensitiveStr::Ascii("ns"),
        dictgen::InsensitiveStr::Ascii("nt"),
        dictgen::InsensitiveStr::Ascii("rance"),
        dictgen::InsensitiveStr::Ascii("rances"),
        dictgen::InsensitiveStr::Ascii("rant"),
        dictgen::InsensitiveStr::Ascii("rantly"),
        dictgen::InsensitiveStr::Ascii("rar"),
        dictgen::InsensitiveStr::Ascii("rarance"),
        dictgen::InsensitiveStr::Ascii("rarances"),
        dictgen::InsensitiveStr::Ascii("rared"),
        dictgen::InsensitiveStr::Ascii("raring"),
        dictgen::InsensitiveStr::Ascii("rars"),
        dictgen::InsensitiveStr::Ascii("rciate"),
        dictgen::InsensitiveStr::Ascii("rciated"),
        dictgen::InsensitiveStr::Ascii("rciates"),
        dictgen::InsensitiveStr::Ascii("rciation"),
        dictgen::InsensitiveStr::Ascii("read"),
        dictgen::InsensitiveStr::Ascii("reance"),
        dictgen::InsensitiveStr::Ascii("reances"),
        dictgen::InsensitiveStr::Ascii("red"),
        dictgen::InsensitiveStr::Ascii("rent"),
        dictgen::InsensitiveStr::Ascii("rently"),
        dictgen::InsensitiveStr::Ascii("rs"),
        dictgen::InsensitiveStr::Ascii("rture"),
        dictgen::InsensitiveStr::Ascii("titie"),
        dictgen::InsensitiveStr::Ascii("tities"),
        dictgen::InsensitiveStr::Ascii("titite"),
    ],
    values: &[
        &["appealing", "appalling"],
        &["appearing"],
        &["appearances"],
        &["apparently"],
        &["appeared"],
        &["appearance"],
        &["appearance"],
        &["appearances"],
        &["apparently"],
        &["appears"],
        &["appearances"],
        &["appearing"],
        &["appears"],
        &["appreciate"],
        &["appended"],
        &["appending"],
        &["append"],
        &["append"],
        &["appended"],
        &["appended"],
        &["appendix"],
        &["appending"],
        &["appending"],
        &["append"],
        &["append", "appended", "happened"],
        &["appended"],
        &["appending"],
        &["apennines"],
        &["appends"],
        &["append"],
        &["appearance"],
        &["appearances"],
        &["apparent", "aberrant"],
        &["apparently"],
        &["appear"],
        &["appearance"],
        &["appearances"],
        &["appeared"],
        &["appearing"],
        &["appears"],
        &["appreciate"],
        &["appreciated"],
        &["appreciates"],
        &["appreciation"],
        &["appeared"],
        &["appearance"],
        &["appearances"],
        &["appeared"],
        &["apparent"],
        &["apparently"],
        &["appears"],
        &["aperture"],
        &["appetite"],
        &["appetite"],
        &["appetite"],
    ],
    range: 1..=8,
};

static WORD_APPA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_APPA_CHILDREN),
    value: None,
};

pub static WORD_APPA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("er"),
        dictgen::InsensitiveStr::Ascii("ered"),
        dictgen::InsensitiveStr::Ascii("ers"),
        dictgen::InsensitiveStr::Ascii("luse"),
        dictgen::InsensitiveStr::Ascii("r"),
        dictgen::InsensitiveStr::Ascii("rant"),
        dictgen::InsensitiveStr::Ascii("rantely"),
        dictgen::InsensitiveStr::Ascii("rantly"),
        dictgen::InsensitiveStr::Ascii("real"),
        dictgen::InsensitiveStr::Ascii("reance"),
        dictgen::InsensitiveStr::Ascii("reances"),
        dictgen::InsensitiveStr::Ascii("red"),
        dictgen::InsensitiveStr::Ascii("reil"),
        dictgen::InsensitiveStr::Ascii("rence"),
        dictgen::InsensitiveStr::Ascii("renlty"),
        dictgen::InsensitiveStr::Ascii("renly"),
        dictgen::InsensitiveStr::Ascii("rentely"),
        dictgen::InsensitiveStr::Ascii("renty"),
        dictgen::InsensitiveStr::Ascii("res"),
        dictgen::InsensitiveStr::Ascii("roches"),
        dictgen::InsensitiveStr::Ascii("rs"),
        dictgen::InsensitiveStr::Ascii("rt"),
        dictgen::InsensitiveStr::Ascii("rtment"),
        dictgen::InsensitiveStr::Ascii("rtments"),
        dictgen::InsensitiveStr::Ascii("thetic"),
        dictgen::InsensitiveStr::Ascii("ture"),
        dictgen::InsensitiveStr::Ascii("tures"),
    ],
    values: &[
        &["appear"],
        &["appeared"],
        &["appears"],
        &["applause"],
        &["appear"],
        &["apparent"],
        &["apparently"],
        &["apparently"],
        &["apparel"],
        &["appearance"],
        &["appearances"],
        &["appeared"],
        &["apparel"],
        &["appearance"],
        &["apparently"],
        &["apparently"],
        &["apparently"],
        &["apparently"],
        &["appears"],
        &["approaches"],
        &["appears"],
        &["apart"],
        &["apartment"],
        &["apartments"],
        &["apathetic"],
        &["aperture"],
        &["apertures"],
    ],
    range: 1..=7,
};

static WORD_APO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_APO_CHILDREN),
    value: None,
};

pub static WORD_APO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("calipse"),
        dictgen::InsensitiveStr::Ascii("caliptic"),
        dictgen::InsensitiveStr::Ascii("calpyse"),
        dictgen::InsensitiveStr::Ascii("calpytic"),
        dictgen::InsensitiveStr::Ascii("calype"),
        dictgen::InsensitiveStr::Ascii("calypes"),
        dictgen::InsensitiveStr::Ascii("calypic"),
        dictgen::InsensitiveStr::Ascii("calypitic"),
        dictgen::InsensitiveStr::Ascii("calyspe"),
        dictgen::InsensitiveStr::Ascii("calytic"),
        dictgen::InsensitiveStr::Ascii("calytpic"),
        dictgen::InsensitiveStr::Ascii("caplyse"),
        dictgen::InsensitiveStr::Ascii("colapse"),
        dictgen::InsensitiveStr::Ascii("craful"),
        dictgen::InsensitiveStr::Ascii("inted"),
        dictgen::InsensitiveStr::Ascii("inting"),
        dictgen::InsensitiveStr::Ascii("intment"),
        dictgen::InsensitiveStr::Ascii("ints"),
        dictgen::InsensitiveStr::Ascii("lagetic"),
        dictgen::InsensitiveStr::Ascii("lagized"),
        dictgen::InsensitiveStr::Ascii("lagizing"),
        dictgen::InsensitiveStr::Ascii("legetic"),
        dictgen::InsensitiveStr::Ascii("legetics"),
        dictgen::InsensitiveStr::Ascii("ligetic"),
        dictgen::InsensitiveStr::Ascii("ligists"),
        dictgen::InsensitiveStr::Ascii("ligized"),
        dictgen::InsensitiveStr::Ascii("llstree"),
        dictgen::InsensitiveStr::Ascii("loges"),
        dictgen::InsensitiveStr::Ascii("logisms"),
        dictgen::InsensitiveStr::Ascii("logistas"),
        dictgen::InsensitiveStr::Ascii("logiste"),
        dictgen::InsensitiveStr::Ascii("logistes"),
        dictgen::InsensitiveStr::Ascii("logistics"),
        dictgen::InsensitiveStr::Ascii("logitic"),
        dictgen::InsensitiveStr::Ascii("logizeing"),
        dictgen::InsensitiveStr::Ascii("n"),
        dictgen::InsensitiveStr::Ascii("rtionable"),
        dictgen::InsensitiveStr::Ascii("sltes"),
        dictgen::InsensitiveStr::Ascii("stels"),
        dictgen::InsensitiveStr::Ascii("strafes"),
        dictgen::InsensitiveStr::Ascii("strafies"),
        dictgen::InsensitiveStr::Ascii("strafy"),
        dictgen::InsensitiveStr::Ascii("straphe"),
        dictgen::InsensitiveStr::Ascii("strephe"),
        dictgen::InsensitiveStr::Ascii("strohpe"),
        dictgen::InsensitiveStr::Ascii("strope"),
        dictgen::InsensitiveStr::Ascii("stropes"),
        dictgen::InsensitiveStr::Ascii("strophie"),
        dictgen::InsensitiveStr::Ascii("strophied"),
        dictgen::InsensitiveStr::Ascii("strophies"),
    ],
    values: &[
        &["apocalypse"],
        &["apocalyptic"],
        &["apocalypse"],
        &["apocalyptic"],
        &["apocalypse"],
        &["apocalypse"],
        &["apocalyptic"],
        &["apocalyptic"],
        &["apocalypse"],
        &["apocalyptic"],
        &["apocalyptic"],
        &["apocalypse"],
        &["apocalypse"],
        &["apocryphal"],
        &["appointed"],
        &["appointing"],
        &["appointment"],
        &["appoints"],
        &["apologetic"],
        &["apologized"],
        &["apologizing"],
        &["apologetic"],
        &["apologetics"],
        &["apologetic"],
        &["apologists"],
        &["apologized"],
        &["upholstery"],
        &["apologise"],
        &["apologists"],
        &["apologists"],
        &["apologise"],
        &["apologists"],
        &["apologists"],
        &["apologetic"],
        &["apologizing"],
        &["upon", "apron"],
        &["apportionable"],
        &["apostles"],
        &["apostles"],
        &["apostrophes"],
        &["apostrophes"],
        &["apostrophe"],
        &["apostrophe"],
        &["apostrophe"],
        &["apostrophe"],
        &["apostrophe"],
        &["apostrophe"],
        &["apostrophe"],
        &["apostrophe"],
        &["apostrophe", "apostrophes"],
    ],
    range: 1..=9,
};

static WORD_APL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_APL_CHILDREN),
    value: None,
};

pub static WORD_APL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ha"),
        dictgen::InsensitiveStr::Ascii("habet"),
        dictgen::InsensitiveStr::Ascii("icabile"),
        dictgen::InsensitiveStr::Ascii("icability"),
        dictgen::InsensitiveStr::Ascii("icable"),
        dictgen::InsensitiveStr::Ascii("ication"),
        dictgen::InsensitiveStr::Ascii("ications"),
        dictgen::InsensitiveStr::Ascii("ied"),
        dictgen::InsensitiveStr::Ascii("ies"),
        dictgen::InsensitiveStr::Ascii("ikay"),
        dictgen::InsensitiveStr::Ascii("ikays"),
        dictgen::InsensitiveStr::Ascii("itude"),
        dictgen::InsensitiveStr::Ascii("licatin"),
        dictgen::InsensitiveStr::Ascii("licatins"),
        dictgen::InsensitiveStr::Ascii("lication"),
        dictgen::InsensitiveStr::Ascii("lications"),
        dictgen::InsensitiveStr::Ascii("lied"),
        dictgen::InsensitiveStr::Ascii("lies"),
        dictgen::InsensitiveStr::Ascii("ly"),
        dictgen::InsensitiveStr::Ascii("lying"),
        dictgen::InsensitiveStr::Ascii("y"),
        dictgen::InsensitiveStr::Ascii("yed"),
        dictgen::InsensitiveStr::Ascii("ying"),
    ],
    values: &[
        &["alpha"],
        &["alphabet"],
        &["applicable"],
        &["applicability"],
        &["applicable"],
        &["application"],
        &["applications"],
        &["applied"],
        &["applies"],
        &["appliqué"],
        &["appliqués"],
        &["amplitude", "aptitude"],
        &["application"],
        &["applications"],
        &["application"],
        &["applications"],
        &["applied"],
        &["applies"],
        &["apply"],
        &["applying"],
        &["apply"],
        &["applied"],
        &["applying"],
    ],
    range: 1..=9,
};

static WORD_API_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_API_CHILDREN),
    value: None,
};

pub static WORD_API_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("helion"),
        dictgen::InsensitiveStr::Ascii("helions"),
        dictgen::InsensitiveStr::Ascii("logue"),
    ],
    values: &[&["aphelion"], &["aphelions"], &["epilogue"]],
    range: 5..=7,
};

static WORD_APE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_APE_CHILDREN),
    value: None,
};

pub static WORD_APE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("al"),
        dictgen::InsensitiveStr::Ascii("aled"),
        dictgen::InsensitiveStr::Ascii("aling"),
        dictgen::InsensitiveStr::Ascii("als"),
        dictgen::InsensitiveStr::Ascii("ar"),
        dictgen::InsensitiveStr::Ascii("ared"),
        dictgen::InsensitiveStr::Ascii("ars"),
        dictgen::InsensitiveStr::Ascii("ct"),
        dictgen::InsensitiveStr::Ascii("cts"),
        dictgen::InsensitiveStr::Ascii("ends"),
        dictgen::InsensitiveStr::Ascii("nd"),
        dictgen::InsensitiveStr::Ascii("ndage"),
        dictgen::InsensitiveStr::Ascii("nded"),
        dictgen::InsensitiveStr::Ascii("nder"),
        dictgen::InsensitiveStr::Ascii("ndices"),
        dictgen::InsensitiveStr::Ascii("nding"),
        dictgen::InsensitiveStr::Ascii("ndix"),
        dictgen::InsensitiveStr::Ascii("nines"),
        dictgen::InsensitiveStr::Ascii("ratures"),
        dictgen::InsensitiveStr::Ascii("rure"),
        dictgen::InsensitiveStr::Ascii("rures"),
        dictgen::InsensitiveStr::Ascii("rutre"),
        dictgen::InsensitiveStr::Ascii("ture"),
        dictgen::InsensitiveStr::Ascii("tures"),
    ],
    values: &[
        &["appeal"],
        &["appealed"],
        &["appealing"],
        &["appeals"],
        &["appear"],
        &["appeared"],
        &["appears"],
        &["aspect"],
        &["aspects"],
        &["appends"],
        &["append"],
        &["appendage"],
        &["appended"],
        &["appender"],
        &["appendices"],
        &["appending"],
        &["appendix"],
        &["apennines"],
        &["apertures"],
        &["aperture"],
        &["apertures"],
        &["aperture"],
        &["aperture"],
        &["apertures"],
    ],
    range: 2..=7,
};

static WORD_APD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_APD_CHILDREN),
    value: None,
};

pub static WORD_APD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ated")],
    values: &[&["updated"]],
    range: 4..=4,
};

static WORD_APA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_APA_CHILDREN),
    value: None,
};

pub static WORD_APA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ch"),
        dictgen::InsensitiveStr::Ascii("colypse"),
        dictgen::InsensitiveStr::Ascii("colyptic"),
        dictgen::InsensitiveStr::Ascii("pted"),
        dictgen::InsensitiveStr::Ascii("rant"),
        dictgen::InsensitiveStr::Ascii("rantly"),
        dictgen::InsensitiveStr::Ascii("ratus"),
        dictgen::InsensitiveStr::Ascii("ratuses"),
        dictgen::InsensitiveStr::Ascii("rent"),
        dictgen::InsensitiveStr::Ascii("rently"),
        dictgen::InsensitiveStr::Ascii("rment"),
        dictgen::InsensitiveStr::Ascii("rtheied"),
        dictgen::InsensitiveStr::Ascii("rthide"),
        dictgen::InsensitiveStr::Ascii("rthied"),
        dictgen::InsensitiveStr::Ascii("rtide"),
        dictgen::InsensitiveStr::Ascii("rtmens"),
        dictgen::InsensitiveStr::Ascii("rtmet"),
        dictgen::InsensitiveStr::Ascii("ul"),
        dictgen::InsensitiveStr::Ascii("uled"),
        dictgen::InsensitiveStr::Ascii("uling"),
        dictgen::InsensitiveStr::Ascii("uls"),
    ],
    values: &[
        &["apache"],
        &["apocalypse"],
        &["apocalyptic"],
        &["adapted"],
        &["apparent"],
        &["apparently"],
        &["apparatus"],
        &["apparatuses"],
        &["apparent"],
        &["apparently"],
        &["apartment"],
        &["apartheid"],
        &["apartheid"],
        &["apartheid"],
        &["apartheid"],
        &["apartments"],
        &["apartments"],
        &["appall"],
        &["appalled"],
        &["appalling"],
        &["appalls"],
    ],
    range: 2..=8,
};

static WORD_AO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AO_CHILDREN),
    value: None,
};

pub static WORD_AO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ache"),
        dictgen::InsensitiveStr::Ascii("nd"),
        dictgen::InsensitiveStr::Ascii("ther"),
        dictgen::InsensitiveStr::Ascii("to"),
        dictgen::InsensitiveStr::Ascii("tomate"),
        dictgen::InsensitiveStr::Ascii("tomated"),
        dictgen::InsensitiveStr::Ascii("tomatic"),
        dictgen::InsensitiveStr::Ascii("tomatical"),
        dictgen::InsensitiveStr::Ascii("tomaticall"),
        dictgen::InsensitiveStr::Ascii("tomatically"),
        dictgen::InsensitiveStr::Ascii("tomation"),
        dictgen::InsensitiveStr::Ascii("vid"),
    ],
    values: &[
        &["apache"],
        &["and"],
        &["another", "other", "mother"],
        &["auto"],
        &["automate"],
        &["automated"],
        &["automatic"],
        &["automatic"],
        &["automatically"],
        &["automatically"],
        &["automation"],
        &["avoid"],
    ],
    range: 2..=11,
};

static WORD_AN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_AN_CHILDREN),
    value: None,
};

static WORD_AN_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_ANA_NODE),
    Some(&WORD_ANB_NODE),
    Some(&WORD_ANC_NODE),
    Some(&WORD_AND_NODE),
    Some(&WORD_ANE_NODE),
    None,
    Some(&WORD_ANG_NODE),
    Some(&WORD_ANH_NODE),
    Some(&WORD_ANI_NODE),
    Some(&WORD_ANJ_NODE),
    Some(&WORD_ANK_NODE),
    Some(&WORD_ANL_NODE),
    Some(&WORD_ANM_NODE),
    Some(&WORD_ANN_NODE),
    Some(&WORD_ANO_NODE),
    Some(&WORD_ANP_NODE),
    None,
    Some(&WORD_ANR_NODE),
    Some(&WORD_ANS_NODE),
    Some(&WORD_ANT_NODE),
    Some(&WORD_ANU_NODE),
    None,
    Some(&WORD_ANW_NODE),
    Some(&WORD_ANX_NODE),
    Some(&WORD_ANY_NODE),
    None,
];

static WORD_ANY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ANY_CHILDREN),
    value: None,
};

pub static WORD_ANY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("awy"),
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("hing"),
        dictgen::InsensitiveStr::Ascii("hting"),
        dictgen::InsensitiveStr::Ascii("hwere"),
        dictgen::InsensitiveStr::Ascii("lsing"),
        dictgen::InsensitiveStr::Ascii("lzing"),
        dictgen::InsensitiveStr::Ascii("nmore"),
        dictgen::InsensitiveStr::Ascii("nomity"),
        dictgen::InsensitiveStr::Ascii("nomous"),
        dictgen::InsensitiveStr::Ascii("oens"),
        dictgen::InsensitiveStr::Ascii("oneis"),
        dictgen::InsensitiveStr::Ascii("onse"),
        dictgen::InsensitiveStr::Ascii("other"),
        dictgen::InsensitiveStr::Ascii("tghing"),
        dictgen::InsensitiveStr::Ascii("thig"),
        dictgen::InsensitiveStr::Ascii("thign"),
        dictgen::InsensitiveStr::Ascii("thimng"),
        dictgen::InsensitiveStr::Ascii("tiem"),
        dictgen::InsensitiveStr::Ascii("tihng"),
        dictgen::InsensitiveStr::Ascii("ting"),
        dictgen::InsensitiveStr::Ascii("tning"),
        dictgen::InsensitiveStr::Ascii("trhing"),
        dictgen::InsensitiveStr::Ascii("tthing"),
        dictgen::InsensitiveStr::Ascii("tying"),
        dictgen::InsensitiveStr::Ascii("were"),
        dictgen::InsensitiveStr::Ascii("wyas"),
        dictgen::InsensitiveStr::Ascii("y"),
    ],
    values: &[
        &["anyway"],
        &["any"],
        &["anything"],
        &["anything"],
        &["anywhere"],
        &["analysing"],
        &["analyzing"],
        &["anymore"],
        &["anonymity"],
        &["anonymous"],
        &["anyones"],
        &["anyones"],
        &["anyones"],
        &["another"],
        &["anything"],
        &["anything"],
        &["anything"],
        &["anything"],
        &["anytime"],
        &["anything"],
        &["anything"],
        &["anything"],
        &["anything"],
        &["anything"],
        &["anything"],
        &["anywhere"],
        &["anyways"],
        &["any"],
    ],
    range: 1..=6,
};

static WORD_ANX_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ANX_CHILDREN),
    value: None,
};

pub static WORD_ANX_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eity"),
        dictgen::InsensitiveStr::Ascii("ios"),
        dictgen::InsensitiveStr::Ascii("iosly"),
        dictgen::InsensitiveStr::Ascii("iosness"),
        dictgen::InsensitiveStr::Ascii("iuos"),
        dictgen::InsensitiveStr::Ascii("iuosly"),
        dictgen::InsensitiveStr::Ascii("iuosness"),
    ],
    values: &[
        &["anxiety"],
        &["anxious"],
        &["anxiously"],
        &["anxiousness"],
        &["anxious"],
        &["anxiously"],
        &["anxiousness"],
    ],
    range: 3..=8,
};

static WORD_ANW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ANW_CHILDREN),
    value: None,
};

pub static WORD_ANW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ay"),
        dictgen::InsensitiveStr::Ascii("ays"),
        dictgen::InsensitiveStr::Ascii("ee"),
        dictgen::InsensitiveStr::Ascii("here"),
        dictgen::InsensitiveStr::Ascii("ser"),
        dictgen::InsensitiveStr::Ascii("sered"),
        dictgen::InsensitiveStr::Ascii("sering"),
        dictgen::InsensitiveStr::Ascii("sers"),
        dictgen::InsensitiveStr::Ascii("yays"),
    ],
    values: &[
        &["anyway"],
        &["anyway"],
        &["ennui"],
        &["anywhere"],
        &["answer"],
        &["answered"],
        &["answering"],
        &["answers"],
        &["anyways"],
    ],
    range: 2..=6,
};

static WORD_ANU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ANU_CHILDREN),
    value: None,
};

pub static WORD_ANU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("al"),
        dictgen::InsensitiveStr::Ascii("alized"),
        dictgen::InsensitiveStr::Ascii("ally"),
        dictgen::InsensitiveStr::Ascii("glar"),
        dictgen::InsensitiveStr::Ascii("led"),
        dictgen::InsensitiveStr::Ascii("ling"),
        dictgen::InsensitiveStr::Ascii("ll"),
        dictgen::InsensitiveStr::Ascii("lled"),
        dictgen::InsensitiveStr::Ascii("lling"),
        dictgen::InsensitiveStr::Ascii("lls"),
        dictgen::InsensitiveStr::Ascii("ls"),
        dictgen::InsensitiveStr::Ascii("mber"),
        dictgen::InsensitiveStr::Ascii("rism"),
        dictgen::InsensitiveStr::Ascii("where"),
    ],
    values: &[
        &["annual"],
        &["annualized"],
        &["annually"],
        &["angular"],
        &["annulled"],
        &["annulling"],
        &["annul"],
        &["annulled"],
        &["annulling"],
        &["annulled"],
        &["annulls"],
        &["number"],
        &["aneurism"],
        &["anywhere"],
    ],
    range: 2..=6,
};

static WORD_ANT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_ANT_CHILDREN),
    value: None,
};

static WORD_ANT_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_ANTA_NODE),
    None,
    None,
    None,
    Some(&WORD_ANTE_NODE),
    None,
    None,
    Some(&WORD_ANTH_NODE),
    Some(&WORD_ANTI_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_ANTO_NODE),
    None,
    None,
    Some(&WORD_ANTR_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_ANTY_NODE),
    None,
];

static WORD_ANTY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ANTY_CHILDREN),
    value: None,
};

pub static WORD_ANTY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("hing")],
    values: &[&["anything"]],
    range: 4..=4,
};

static WORD_ANTR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ANTR_CHILDREN),
    value: None,
};

pub static WORD_ANTR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("actica"),
        dictgen::InsensitiveStr::Ascii("hopology"),
        dictgen::InsensitiveStr::Ascii("ipanewer"),
        dictgen::InsensitiveStr::Ascii("ipanewers"),
        dictgen::InsensitiveStr::Ascii("ophology"),
        dictgen::InsensitiveStr::Ascii("y"),
    ],
    values: &[
        &["antarctica"],
        &["anthropology"],
        &["entrepreneur"],
        &["entrepreneurs"],
        &["anthropology"],
        &["entry"],
    ],
    range: 1..=9,
};

static WORD_ANTO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ANTO_CHILDREN),
    value: None,
};

pub static WORD_ANTO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ganist"),
        dictgen::InsensitiveStr::Ascii("gonistic"),
    ],
    values: &[&["antagonist"], &["antagonistic"]],
    range: 6..=8,
};

static WORD_ANTI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ANTI_CHILDREN),
    value: None,
};

pub static WORD_ANTI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("alialised"),
        dictgen::InsensitiveStr::Ascii("alising"),
        dictgen::InsensitiveStr::Ascii("biodic"),
        dictgen::InsensitiveStr::Ascii("biodics"),
        dictgen::InsensitiveStr::Ascii("bioitcs"),
        dictgen::InsensitiveStr::Ascii("bioitic"),
        dictgen::InsensitiveStr::Ascii("biotcs"),
        dictgen::InsensitiveStr::Ascii("bioticos"),
        dictgen::InsensitiveStr::Ascii("bitoic"),
        dictgen::InsensitiveStr::Ascii("bitoics"),
        dictgen::InsensitiveStr::Ascii("boitic"),
        dictgen::InsensitiveStr::Ascii("boitics"),
        dictgen::InsensitiveStr::Ascii("capate"),
        dictgen::InsensitiveStr::Ascii("capated"),
        dictgen::InsensitiveStr::Ascii("cdote"),
        dictgen::InsensitiveStr::Ascii("cdotes"),
        dictgen::InsensitiveStr::Ascii("ciapte"),
        dictgen::InsensitiveStr::Ascii("ciapted"),
        dictgen::InsensitiveStr::Ascii("ciaption"),
        dictgen::InsensitiveStr::Ascii("cipacion"),
        dictgen::InsensitiveStr::Ascii("cipare"),
        dictgen::InsensitiveStr::Ascii("cipatin"),
        dictgen::InsensitiveStr::Ascii("cipato"),
        dictgen::InsensitiveStr::Ascii("cipe"),
        dictgen::InsensitiveStr::Ascii("cpate"),
        dictgen::InsensitiveStr::Ascii("cuated"),
        dictgen::InsensitiveStr::Ascii("depressents"),
        dictgen::InsensitiveStr::Ascii("depresssants"),
        dictgen::InsensitiveStr::Ascii("obitics"),
        dictgen::InsensitiveStr::Ascii("quae"),
        dictgen::InsensitiveStr::Ascii("quaited"),
        dictgen::InsensitiveStr::Ascii("quited"),
        dictgen::InsensitiveStr::Ascii("qvated"),
        dictgen::InsensitiveStr::Ascii("sipate"),
        dictgen::InsensitiveStr::Ascii("sipated"),
        dictgen::InsensitiveStr::Ascii("sipation"),
        dictgen::InsensitiveStr::Ascii("socail"),
        dictgen::InsensitiveStr::Ascii("sosial"),
        dictgen::InsensitiveStr::Ascii("virs"),
        dictgen::InsensitiveStr::Ascii("viurs"),
        dictgen::InsensitiveStr::Ascii("vrius"),
        dictgen::InsensitiveStr::Ascii("vuris"),
    ],
    values: &[
        &["antialiased"],
        &["antialiasing"],
        &["antibiotic"],
        &["antibiotics"],
        &["antibiotic"],
        &["antibiotic"],
        &["antibiotics"],
        &["antibiotics"],
        &["antibiotic"],
        &["antibiotics"],
        &["antibiotics"],
        &["antibiotics"],
        &["anticipate"],
        &["anticipated"],
        &["anecdote", "antidote"],
        &["anecdotes", "antidotes"],
        &["anticipate"],
        &["anticipated"],
        &["anticipation"],
        &["anticipation"],
        &["anticipate"],
        &["anticipation"],
        &["anticipation"],
        &["anticipate"],
        &["anticipate"],
        &["antiquated"],
        &["antidepressants"],
        &["antidepressants"],
        &["antibiotic"],
        &["antique"],
        &["antiquated"],
        &["antiquated"],
        &["antiquated"],
        &["anticipate"],
        &["anticipated"],
        &["anticipation"],
        &["antisocial"],
        &["antisocial"],
        &["antivirus"],
        &["antivirus"],
        &["antivirus"],
        &["antivirus"],
    ],
    range: 4..=12,
};

static WORD_ANTH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ANTH_CHILDREN),
    value: None,
};

pub static WORD_ANTH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("ings"),
        dictgen::InsensitiveStr::Ascii("or"),
        dictgen::InsensitiveStr::Ascii("romorphization"),
        dictgen::InsensitiveStr::Ascii("ropolgist"),
        dictgen::InsensitiveStr::Ascii("ropolgy"),
        dictgen::InsensitiveStr::Ascii("ropoloy"),
        dictgen::InsensitiveStr::Ascii("ropoly"),
    ],
    values: &[
        &["anything"],
        &["anythings"],
        &["another"],
        &["anthropomorphization"],
        &["anthropologist"],
        &["anthropology"],
        &["anthropology"],
        &["anthropology"],
    ],
    range: 2..=14,
};

static WORD_ANTE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ANTE_CHILDREN),
    value: None,
};

pub static WORD_ANTE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cedant"),
        dictgen::InsensitiveStr::Ascii("ena"),
        dictgen::InsensitiveStr::Ascii("enas"),
        dictgen::InsensitiveStr::Ascii("nnaes"),
        dictgen::InsensitiveStr::Ascii("nnea"),
        dictgen::InsensitiveStr::Ascii("nnna"),
    ],
    values: &[
        &["antecedent"],
        &["antenna"],
        &["antennas"],
        &["antennas"],
        &["antenna"],
        &["antenna"],
    ],
    range: 3..=6,
};

static WORD_ANTA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ANTA_CHILDREN),
    value: None,
};

pub static WORD_ANTA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ganist"),
        dictgen::InsensitiveStr::Ascii("ganistic"),
        dictgen::InsensitiveStr::Ascii("gnoist"),
        dictgen::InsensitiveStr::Ascii("gonisic"),
        dictgen::InsensitiveStr::Ascii("gonisitc"),
        dictgen::InsensitiveStr::Ascii("gonisitic"),
        dictgen::InsensitiveStr::Ascii("gonistc"),
        dictgen::InsensitiveStr::Ascii("gonostic"),
        dictgen::InsensitiveStr::Ascii("gonstic"),
        dictgen::InsensitiveStr::Ascii("liasing"),
        dictgen::InsensitiveStr::Ascii("rcitca"),
        dictgen::InsensitiveStr::Ascii("rctia"),
        dictgen::InsensitiveStr::Ascii("rctida"),
        dictgen::InsensitiveStr::Ascii("rtic"),
    ],
    values: &[
        &["antagonist"],
        &["antagonistic"],
        &["antagonist"],
        &["antagonistic"],
        &["antagonistic"],
        &["antagonistic"],
        &["antagonistic"],
        &["antagonist"],
        &["antagonist"],
        &["antialiasing"],
        &["antarctica"],
        &["antarctica"],
        &["antarctica"],
        &["antarctic"],
    ],
    range: 4..=9,
};

static WORD_ANS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ANS_CHILDREN),
    value: None,
};

pub static WORD_ANS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("alisation"),
        dictgen::InsensitiveStr::Ascii("alization"),
        dictgen::InsensitiveStr::Ascii("amble"),
        dictgen::InsensitiveStr::Ascii("ambles"),
        dictgen::InsensitiveStr::Ascii("er"),
        dictgen::InsensitiveStr::Ascii("ester"),
        dictgen::InsensitiveStr::Ascii("esters"),
        dictgen::InsensitiveStr::Ascii("estor"),
        dictgen::InsensitiveStr::Ascii("estors"),
        dictgen::InsensitiveStr::Ascii("werd"),
        dictgen::InsensitiveStr::Ascii("weres"),
        dictgen::InsensitiveStr::Ascii("whare"),
        dictgen::InsensitiveStr::Ascii("whared"),
        dictgen::InsensitiveStr::Ascii("whareing"),
        dictgen::InsensitiveStr::Ascii("whares"),
        dictgen::InsensitiveStr::Ascii("wharing"),
        dictgen::InsensitiveStr::Ascii("whars"),
        dictgen::InsensitiveStr::Ascii("yert"),
        dictgen::InsensitiveStr::Ascii("ynchronous"),
    ],
    values: &[
        &["nasalisation"],
        &["nasalization"],
        &["ensemble"],
        &["ensembles"],
        &["answer"],
        &["ancestor"],
        &["ancestors"],
        &["ancestor"],
        &["ancestors"],
        &["answered"],
        &["answers"],
        &["answer"],
        &["answered"],
        &["answering"],
        &["answers"],
        &["answering"],
        &["answers"],
        &["answer", "answered"],
        &["asynchronous"],
    ],
    range: 2..=10,
};

static WORD_ANR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ANR_CHILDREN),
    value: None,
};

pub static WORD_ANR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("achist"),
        dictgen::InsensitiveStr::Ascii("oid"),
    ],
    values: &[&["anarchist"], &["android"]],
    range: 3..=6,
};

static WORD_ANP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ANP_CHILDREN),
    value: None,
};

pub static WORD_ANP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("atheater"),
        dictgen::InsensitiveStr::Ascii("atheaters"),
        dictgen::InsensitiveStr::Ascii("hatheater"),
        dictgen::InsensitiveStr::Ascii("hatheaters"),
        dictgen::InsensitiveStr::Ascii("hetamines"),
        dictgen::InsensitiveStr::Ascii("hibian"),
        dictgen::InsensitiveStr::Ascii("hibians"),
        dictgen::InsensitiveStr::Ascii("hitheater"),
        dictgen::InsensitiveStr::Ascii("hitheaters"),
        dictgen::InsensitiveStr::Ascii("itheater"),
        dictgen::InsensitiveStr::Ascii("itheaters"),
    ],
    values: &[
        &["amphitheater"],
        &["amphitheaters"],
        &["amphitheater"],
        &["amphitheaters"],
        &["amphetamines"],
        &["amphibian"],
        &["amphibians"],
        &["amphitheater"],
        &["amphitheaters"],
        &["amphitheater"],
        &["amphitheaters"],
    ],
    range: 6..=10,
};

static WORD_ANO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_ANO_CHILDREN),
    value: None,
};

static WORD_ANO_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    None,
    None,
    Some(&WORD_ANOE_NODE),
    None,
    None,
    Some(&WORD_ANOH_NODE),
    None,
    None,
    None,
    Some(&WORD_ANOL_NODE),
    Some(&WORD_ANOM_NODE),
    Some(&WORD_ANON_NODE),
    None,
    None,
    None,
    Some(&WORD_ANOR_NODE),
    None,
    Some(&WORD_ANOT_NODE),
    Some(&WORD_ANOU_NODE),
    None,
    None,
    Some(&WORD_ANOX_NODE),
    Some(&WORD_ANOY_NODE),
    None,
];

static WORD_ANOY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ANOY_CHILDREN),
    value: Some(&["annoy"]),
};

pub static WORD_ANOY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("mous"),
        dictgen::InsensitiveStr::Ascii("mously"),
        dictgen::InsensitiveStr::Ascii("s"),
    ],
    values: &[
        &["annoyed"],
        &["annoying"],
        &["anonymous"],
        &["anonymously"],
        &["annoys"],
    ],
    range: 1..=6,
};

static WORD_ANOX_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ANOX_CHILDREN),
    value: None,
};

pub static WORD_ANOX_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eria"),
        dictgen::InsensitiveStr::Ascii("eric"),
    ],
    values: &[&["anorexia"], &["anorexic"]],
    range: 4..=4,
};

static WORD_ANOU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ANOU_CHILDREN),
    value: None,
};

pub static WORD_ANOU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("nce"),
        dictgen::InsensitiveStr::Ascii("nced"),
        dictgen::InsensitiveStr::Ascii("ncement"),
        dictgen::InsensitiveStr::Ascii("nt"),
        dictgen::InsensitiveStr::Ascii("t"),
    ],
    values: &[
        &["announce"],
        &["announced"],
        &["announcement"],
        &["amount"],
        &["about"],
    ],
    range: 1..=7,
};

static WORD_ANOT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ANOT_CHILDREN),
    value: None,
};

pub static WORD_ANOT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ate"),
        dictgen::InsensitiveStr::Ascii("ated"),
        dictgen::InsensitiveStr::Ascii("ates"),
        dictgen::InsensitiveStr::Ascii("ating"),
        dictgen::InsensitiveStr::Ascii("ation"),
        dictgen::InsensitiveStr::Ascii("ations"),
        dictgen::InsensitiveStr::Ascii("er"),
        dictgen::InsensitiveStr::Ascii("he"),
        dictgen::InsensitiveStr::Ascii("hers"),
        dictgen::InsensitiveStr::Ascii("hr"),
    ],
    values: &[
        &["annotate"],
        &["annotated"],
        &["annotates"],
        &["annotating"],
        &["annotation"],
        &["annotations"],
        &["another"],
        &["another"],
        &["another"],
        &["another"],
    ],
    range: 2..=6,
};

static WORD_ANOR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ANOR_CHILDREN),
    value: None,
};

pub static WORD_ANOR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eixa"),
        dictgen::InsensitiveStr::Ascii("exiac"),
        dictgen::InsensitiveStr::Ascii("exica"),
        dictgen::InsensitiveStr::Ascii("mal"),
        dictgen::InsensitiveStr::Ascii("malies"),
        dictgen::InsensitiveStr::Ascii("mally"),
        dictgen::InsensitiveStr::Ascii("maly"),
    ],
    values: &[
        &["anorexia"],
        &["anorexic"],
        &["anorexia"],
        &["abnormal"],
        &["anomalies"],
        &["abnormally"],
        &["abnormally"],
    ],
    range: 3..=6,
};

static WORD_ANON_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ANON_CHILDREN),
    value: None,
};

pub static WORD_ANON_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("amously"),
        dictgen::InsensitiveStr::Ascii("imised"),
        dictgen::InsensitiveStr::Ascii("imity"),
        dictgen::InsensitiveStr::Ascii("imized"),
        dictgen::InsensitiveStr::Ascii("imously"),
        dictgen::InsensitiveStr::Ascii("imus"),
        dictgen::InsensitiveStr::Ascii("imusally"),
        dictgen::InsensitiveStr::Ascii("imusly"),
        dictgen::InsensitiveStr::Ascii("myous"),
        dictgen::InsensitiveStr::Ascii("myously"),
        dictgen::InsensitiveStr::Ascii("omous"),
        dictgen::InsensitiveStr::Ascii("omously"),
        dictgen::InsensitiveStr::Ascii("onymous"),
        dictgen::InsensitiveStr::Ascii("ther"),
        dictgen::InsensitiveStr::Ascii("ymos"),
        dictgen::InsensitiveStr::Ascii("ymosly"),
        dictgen::InsensitiveStr::Ascii("ymouse"),
        dictgen::InsensitiveStr::Ascii("ymousny"),
        dictgen::InsensitiveStr::Ascii("ymousy"),
        dictgen::InsensitiveStr::Ascii("ymoys"),
        dictgen::InsensitiveStr::Ascii("yms"),
        dictgen::InsensitiveStr::Ascii("ymus"),
    ],
    values: &[
        &["anonymously"],
        &["anonymised"],
        &["anonymity"],
        &["anonymized"],
        &["anonymously"],
        &["anonymous"],
        &["anonymously"],
        &["anonymously"],
        &["anonymous"],
        &["anonymously"],
        &["anonymous"],
        &["anonymously"],
        &["anonymous"],
        &["another"],
        &["anonymous"],
        &["anonymously"],
        &["anonymous"],
        &["anonymously"],
        &["anonymously"],
        &["anonymously"],
        &["anonymous"],
        &["anonymous"],
    ],
    range: 3..=8,
};

static WORD_ANOM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ANOM_CHILDREN),
    value: None,
};

pub static WORD_ANOM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ally"),
        dictgen::InsensitiveStr::Ascii("isity"),
        dictgen::InsensitiveStr::Ascii("olee"),
        dictgen::InsensitiveStr::Ascii("olies"),
        dictgen::InsensitiveStr::Ascii("olous"),
        dictgen::InsensitiveStr::Ascii("oly"),
        dictgen::InsensitiveStr::Ascii("ynity"),
        dictgen::InsensitiveStr::Ascii("ynous"),
    ],
    values: &[
        &["anomaly"],
        &["animosity"],
        &["anomaly"],
        &["anomalies"],
        &["anomalous"],
        &["anomaly"],
        &["anonymity"],
        &["anonymous"],
    ],
    range: 3..=5,
};

static WORD_ANOL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ANOL_CHILDREN),
    value: None,
};

pub static WORD_ANOL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ogon"),
        dictgen::InsensitiveStr::Ascii("ogous"),
    ],
    values: &[&["analogon"], &["analogous"]],
    range: 4..=5,
};

static WORD_ANOH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ANOH_CHILDREN),
    value: None,
};

pub static WORD_ANOH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("er"),
        dictgen::InsensitiveStr::Ascii("ter"),
    ],
    values: &[&["another"], &["another"]],
    range: 2..=3,
};

static WORD_ANOE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ANOE_CHILDREN),
    value: None,
};

pub static WORD_ANOE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("rxia"),
        dictgen::InsensitiveStr::Ascii("rxic"),
    ],
    values: &[&["anorexia"], &["anorexic"]],
    range: 4..=4,
};

static WORD_ANN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_ANN_CHILDREN),
    value: None,
};

static WORD_ANN_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_ANNA_NODE),
    None,
    None,
    Some(&WORD_ANND_NODE),
    None,
    None,
    None,
    Some(&WORD_ANNH_NODE),
    Some(&WORD_ANNI_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_ANNN_NODE),
    Some(&WORD_ANNO_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_ANNT_NODE),
    Some(&WORD_ANNU_NODE),
    None,
    None,
    None,
    Some(&WORD_ANNY_NODE),
    None,
];

static WORD_ANNY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ANNY_CHILDREN),
    value: None,
};

pub static WORD_ANNY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("oance"),
        dictgen::InsensitiveStr::Ascii("oingly"),
    ],
    values: &[&["annoyance"], &["annoyingly"]],
    range: 5..=6,
};

static WORD_ANNU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ANNU_CHILDREN),
    value: None,
};

pub static WORD_ANNU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aly"),
        dictgen::InsensitiveStr::Ascii("led"),
    ],
    values: &[&["annually"], &["annulled"]],
    range: 3..=3,
};

static WORD_ANNT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ANNT_CHILDREN),
    value: None,
};

pub static WORD_ANNT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("enas")],
    values: &[&["antennas"]],
    range: 4..=4,
};

static WORD_ANNO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ANNO_CHILDREN),
    value: None,
};

pub static WORD_ANNO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ation"),
        dictgen::InsensitiveStr::Ascii("int"),
        dictgen::InsensitiveStr::Ascii("inted"),
        dictgen::InsensitiveStr::Ascii("inting"),
        dictgen::InsensitiveStr::Ascii("ints"),
        dictgen::InsensitiveStr::Ascii("nate"),
        dictgen::InsensitiveStr::Ascii("nated"),
        dictgen::InsensitiveStr::Ascii("nates"),
        dictgen::InsensitiveStr::Ascii("nce"),
        dictgen::InsensitiveStr::Ascii("nced"),
        dictgen::InsensitiveStr::Ascii("ncement"),
        dictgen::InsensitiveStr::Ascii("ncements"),
        dictgen::InsensitiveStr::Ascii("nces"),
        dictgen::InsensitiveStr::Ascii("nceurs"),
        dictgen::InsensitiveStr::Ascii("ncing"),
        dictgen::InsensitiveStr::Ascii("nomus"),
        dictgen::InsensitiveStr::Ascii("nomusally"),
        dictgen::InsensitiveStr::Ascii("nomusly"),
        dictgen::InsensitiveStr::Ascii("nymous"),
        dictgen::InsensitiveStr::Ascii("nymouse"),
        dictgen::InsensitiveStr::Ascii("nymously"),
        dictgen::InsensitiveStr::Ascii("taion"),
        dictgen::InsensitiveStr::Ascii("taions"),
        dictgen::InsensitiveStr::Ascii("taiotn"),
        dictgen::InsensitiveStr::Ascii("ted"),
        dictgen::InsensitiveStr::Ascii("ther"),
        dictgen::InsensitiveStr::Ascii("uce"),
        dictgen::InsensitiveStr::Ascii("uced"),
        dictgen::InsensitiveStr::Ascii("ucement"),
        dictgen::InsensitiveStr::Ascii("ucements"),
        dictgen::InsensitiveStr::Ascii("ucenment"),
        dictgen::InsensitiveStr::Ascii("uces"),
        dictgen::InsensitiveStr::Ascii("ucing"),
        dictgen::InsensitiveStr::Ascii("ucne"),
        dictgen::InsensitiveStr::Ascii("ucnement"),
        dictgen::InsensitiveStr::Ascii("ucnements"),
        dictgen::InsensitiveStr::Ascii("ucners"),
        dictgen::InsensitiveStr::Ascii("ucnes"),
        dictgen::InsensitiveStr::Ascii("ucning"),
        dictgen::InsensitiveStr::Ascii("uing"),
        dictgen::InsensitiveStr::Ascii("unceing"),
        dictgen::InsensitiveStr::Ascii("uncemet"),
        dictgen::InsensitiveStr::Ascii("uncemnet"),
        dictgen::InsensitiveStr::Ascii("uncemnt"),
        dictgen::InsensitiveStr::Ascii("uncemnts"),
        dictgen::InsensitiveStr::Ascii("uncents"),
        dictgen::InsensitiveStr::Ascii("unched"),
        dictgen::InsensitiveStr::Ascii("uncment"),
        dictgen::InsensitiveStr::Ascii("uncments"),
        dictgen::InsensitiveStr::Ascii("uned"),
        dictgen::InsensitiveStr::Ascii("unement"),
        dictgen::InsensitiveStr::Ascii("unements"),
        dictgen::InsensitiveStr::Ascii("yence"),
        dictgen::InsensitiveStr::Ascii("yences"),
        dictgen::InsensitiveStr::Ascii("yingy"),
        dictgen::InsensitiveStr::Ascii("ymous"),
        dictgen::InsensitiveStr::Ascii("ymously"),
        dictgen::InsensitiveStr::Ascii("yn"),
        dictgen::InsensitiveStr::Ascii("ynace"),
        dictgen::InsensitiveStr::Ascii("yning"),
        dictgen::InsensitiveStr::Ascii("yningly"),
        dictgen::InsensitiveStr::Ascii("yying"),
    ],
    values: &[
        &["annotation"],
        &["anoint"],
        &["anointed"],
        &["anointing"],
        &["anoints"],
        &["annotate"],
        &["annotated"],
        &["annotates"],
        &["announce"],
        &["announced"],
        &["announcement"],
        &["announcements"],
        &["announces"],
        &["announcers"],
        &["announcing"],
        &["anonymous"],
        &["anonymously"],
        &["anonymously"],
        &["anonymous"],
        &["anonymous"],
        &["anonymously"],
        &["annotation"],
        &["annotations"],
        &["annotation"],
        &["annotated"],
        &["another"],
        &["announce"],
        &["announced"],
        &["announcement"],
        &["announcements"],
        &["announcements"],
        &["announces"],
        &["announcing"],
        &["announce"],
        &["announcement"],
        &["announcements"],
        &["announcers"],
        &["announces"],
        &["announcing"],
        &["annoying"],
        &["announcing"],
        &["announcements"],
        &["announcements"],
        &["announcement"],
        &["announcements"],
        &["announces"],
        &["announce"],
        &["announcement"],
        &["announcements"],
        &["announced"],
        &["announcement"],
        &["announcements"],
        &["annoyance"],
        &["annoyances"],
        &["annoyingly"],
        &["anonymous"],
        &["anonymously"],
        &["annoy", "annoying"],
        &["annoyance"],
        &["annoying"],
        &["annoyingly"],
        &["annoying"],
    ],
    range: 2..=9,
};

static WORD_ANNN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ANNN_CHILDREN),
    value: None,
};

pub static WORD_ANNN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ounce")],
    values: &[&["announce"]],
    range: 5..=5,
};

static WORD_ANNI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ANNI_CHILDREN),
    value: None,
};

pub static WORD_ANNI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("halated"),
        dictgen::InsensitiveStr::Ascii("halition"),
        dictgen::InsensitiveStr::Ascii("hilaton"),
        dictgen::InsensitiveStr::Ascii("hilatron"),
        dictgen::InsensitiveStr::Ascii("hilited"),
        dictgen::InsensitiveStr::Ascii("hliated"),
        dictgen::InsensitiveStr::Ascii("hliation"),
        dictgen::InsensitiveStr::Ascii("lihate"),
        dictgen::InsensitiveStr::Ascii("lihated"),
        dictgen::InsensitiveStr::Ascii("lihation"),
        dictgen::InsensitiveStr::Ascii("mal"),
        dictgen::InsensitiveStr::Ascii("verary"),
        dictgen::InsensitiveStr::Ascii("versairy"),
        dictgen::InsensitiveStr::Ascii("versarry"),
        dictgen::InsensitiveStr::Ascii("versay"),
        dictgen::InsensitiveStr::Ascii("versery"),
        dictgen::InsensitiveStr::Ascii("versiary"),
        dictgen::InsensitiveStr::Ascii("versry"),
        dictgen::InsensitiveStr::Ascii("versy"),
    ],
    values: &[
        &["annihilated"],
        &["annihilation"],
        &["annihilation"],
        &["annihilation"],
        &["annihilated"],
        &["annihilated"],
        &["annihilation"],
        &["annihilated"],
        &["annihilated"],
        &["annihilation"],
        &["animal"],
        &["anniversary"],
        &["anniversary"],
        &["anniversary"],
        &["anniversary"],
        &["anniversary"],
        &["anniversary"],
        &["anniversary"],
        &["anniversary"],
    ],
    range: 3..=8,
};

static WORD_ANNH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ANNH_CHILDREN),
    value: None,
};

pub static WORD_ANNH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("iliation")],
    values: &[&["annihilation"]],
    range: 8..=8,
};

static WORD_ANND_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ANND_CHILDREN),
    value: Some(&["and"]),
};

pub static WORD_ANND_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[],
    values: &[],
    range: 0..=0,
};

static WORD_ANNA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ANNA_CHILDREN),
    value: None,
};

pub static WORD_ANNA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("verseries"),
        dictgen::InsensitiveStr::Ascii("versery"),
        dictgen::InsensitiveStr::Ascii("verserys"),
        dictgen::InsensitiveStr::Ascii("y"),
        dictgen::InsensitiveStr::Ascii("yed"),
        dictgen::InsensitiveStr::Ascii("ying"),
        dictgen::InsensitiveStr::Ascii("ys"),
    ],
    values: &[
        &["anniversaries"],
        &["anniversary"],
        &["anniversaries"],
        &["annoy", "any"],
        &["annoyed"],
        &["annoying"],
        &["annoys", "any"],
    ],
    range: 1..=9,
};

static WORD_ANM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ANM_CHILDREN),
    value: None,
};

pub static WORD_ANM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("esia"),
        dictgen::InsensitiveStr::Ascii("esty"),
    ],
    values: &[&["name", "anime"], &["amnesia"], &["amnesty"]],
    range: 1..=4,
};

static WORD_ANL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ANL_CHILDREN),
    value: None,
};

pub static WORD_ANL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ayses"),
        dictgen::InsensitiveStr::Ascii("aytics"),
        dictgen::InsensitiveStr::Ascii("ge"),
        dictgen::InsensitiveStr::Ascii("y"),
        dictgen::InsensitiveStr::Ascii("ysis"),
        dictgen::InsensitiveStr::Ascii("yzing"),
    ],
    values: &[
        &["analyses"],
        &["analytics"],
        &["angle"],
        &["only", "any"],
        &["analysis"],
        &["analyzing"],
    ],
    range: 1..=6,
};

static WORD_ANK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ANK_CHILDREN),
    value: None,
};

pub static WORD_ANK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("shios"),
        dictgen::InsensitiveStr::Ascii("shiosly"),
        dictgen::InsensitiveStr::Ascii("shiosness"),
        dictgen::InsensitiveStr::Ascii("shis"),
        dictgen::InsensitiveStr::Ascii("shisly"),
        dictgen::InsensitiveStr::Ascii("shisness"),
        dictgen::InsensitiveStr::Ascii("shiuos"),
        dictgen::InsensitiveStr::Ascii("shiuosly"),
        dictgen::InsensitiveStr::Ascii("shiuosness"),
        dictgen::InsensitiveStr::Ascii("shus"),
        dictgen::InsensitiveStr::Ascii("shusly"),
        dictgen::InsensitiveStr::Ascii("shusness"),
    ],
    values: &[
        &["anxious"],
        &["anxiously"],
        &["anxiousness"],
        &["anxious"],
        &["anxiously"],
        &["anxiousness"],
        &["anxious"],
        &["anxiously"],
        &["anxiousness"],
        &["anxious"],
        &["anxiously"],
        &["anxiousness"],
    ],
    range: 4..=10,
};

static WORD_ANJ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ANJ_CHILDREN),
    value: None,
};

pub static WORD_ANJ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("anew")],
    values: &[&["ingenue"]],
    range: 4..=4,
};

static WORD_ANI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ANI_CHILDREN),
    value: None,
};

pub static WORD_ANI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("alate"),
        dictgen::InsensitiveStr::Ascii("alated"),
        dictgen::InsensitiveStr::Ascii("alates"),
        dictgen::InsensitiveStr::Ascii("alating"),
        dictgen::InsensitiveStr::Ascii("cent"),
        dictgen::InsensitiveStr::Ascii("cents"),
        dictgen::InsensitiveStr::Ascii("d"),
        dictgen::InsensitiveStr::Ascii("hilation"),
        dictgen::InsensitiveStr::Ascii("maing"),
        dictgen::InsensitiveStr::Ascii("maite"),
        dictgen::InsensitiveStr::Ascii("maiter"),
        dictgen::InsensitiveStr::Ascii("maiters"),
        dictgen::InsensitiveStr::Ascii("maiton"),
        dictgen::InsensitiveStr::Ascii("maitons"),
        dictgen::InsensitiveStr::Ascii("maitor"),
        dictgen::InsensitiveStr::Ascii("maitors"),
        dictgen::InsensitiveStr::Ascii("matie"),
        dictgen::InsensitiveStr::Ascii("matior"),
        dictgen::InsensitiveStr::Ascii("maton"),
        dictgen::InsensitiveStr::Ascii("matonic"),
        dictgen::InsensitiveStr::Ascii("matte"),
        dictgen::InsensitiveStr::Ascii("mete"),
        dictgen::InsensitiveStr::Ascii("meted"),
        dictgen::InsensitiveStr::Ascii("metion"),
        dictgen::InsensitiveStr::Ascii("metions"),
        dictgen::InsensitiveStr::Ascii("mets"),
        dictgen::InsensitiveStr::Ascii("monee"),
        dictgen::InsensitiveStr::Ascii("more"),
        dictgen::InsensitiveStr::Ascii("mostiy"),
        dictgen::InsensitiveStr::Ascii("nate"),
        dictgen::InsensitiveStr::Ascii("nation"),
        dictgen::InsensitiveStr::Ascii("nteresting"),
        dictgen::InsensitiveStr::Ascii("other"),
        dictgen::InsensitiveStr::Ascii("sotrophically"),
        dictgen::InsensitiveStr::Ascii("taliasing"),
        dictgen::InsensitiveStr::Ascii("tbiotic"),
        dictgen::InsensitiveStr::Ascii("tbiotics"),
        dictgen::InsensitiveStr::Ascii("tdepressant"),
        dictgen::InsensitiveStr::Ascii("tdepressants"),
        dictgen::InsensitiveStr::Ascii("thing"),
        dictgen::InsensitiveStr::Ascii("tialising"),
        dictgen::InsensitiveStr::Ascii("time"),
        dictgen::InsensitiveStr::Ascii("tquated"),
        dictgen::InsensitiveStr::Ascii("tque"),
        dictgen::InsensitiveStr::Ascii("trez"),
        dictgen::InsensitiveStr::Ascii("tsocial"),
        dictgen::InsensitiveStr::Ascii("tvirus"),
        dictgen::InsensitiveStr::Ascii("versary"),
        dictgen::InsensitiveStr::Ascii("way"),
        dictgen::InsensitiveStr::Ascii("where"),
        dictgen::InsensitiveStr::Ascii("xety"),
    ],
    values: &[
        &["annihilate"],
        &["annihilated"],
        &["annihilates"],
        &["annihilating"],
        &["ancient"],
        &["ancients"],
        &["and"],
        &["annihilation"],
        &["animating"],
        &["animate"],
        &["animator"],
        &["animators"],
        &["animation"],
        &["animations"],
        &["animator"],
        &["animators"],
        &["animate"],
        &["animator", "animation"],
        &["animation"],
        &["animatronic"],
        &["animate"],
        &["animate"],
        &["animated"],
        &["animation"],
        &["animations"],
        &["animates"],
        &["anemone"],
        &["anymore"],
        &["animosity"],
        &["animate"],
        &["animation"],
        &["uninteresting"],
        &["another"],
        &["anisotropically"],
        &["antialiasing"],
        &["antibiotic"],
        &["antibiotics"],
        &["antidepressants"],
        &["antidepressants"],
        &["anything"],
        &["antialiasing"],
        &["anytime"],
        &["antiquated"],
        &["antique"],
        &["antirez"],
        &["antisocial"],
        &["antivirus"],
        &["anniversary"],
        &["anyway"],
        &["anywhere"],
        &["anxiety"],
    ],
    range: 1..=13,
};

static WORD_ANH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ANH_CHILDREN),
    value: None,
};

pub static WORD_ANH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("oter")],
    values: &[&["another"]],
    range: 4..=4,
};

static WORD_ANG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ANG_CHILDREN),
    value: None,
};

pub static WORD_ANG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("irly"),
        dictgen::InsensitiveStr::Ascii("luar"),
        dictgen::InsensitiveStr::Ascii("ostic"),
        dictgen::InsensitiveStr::Ascii("osticism"),
        dictgen::InsensitiveStr::Ascii("rilly"),
        dictgen::InsensitiveStr::Ascii("shios"),
        dictgen::InsensitiveStr::Ascii("shiosly"),
        dictgen::InsensitiveStr::Ascii("shiosness"),
        dictgen::InsensitiveStr::Ascii("shis"),
        dictgen::InsensitiveStr::Ascii("shisly"),
        dictgen::InsensitiveStr::Ascii("shisness"),
        dictgen::InsensitiveStr::Ascii("shiuos"),
        dictgen::InsensitiveStr::Ascii("shiuosly"),
        dictgen::InsensitiveStr::Ascii("shiuosness"),
        dictgen::InsensitiveStr::Ascii("shus"),
        dictgen::InsensitiveStr::Ascii("shusly"),
        dictgen::InsensitiveStr::Ascii("shusness"),
        dictgen::InsensitiveStr::Ascii("uage"),
        dictgen::InsensitiveStr::Ascii("ualr"),
        dictgen::InsensitiveStr::Ascii("uluar"),
        dictgen::InsensitiveStr::Ascii("ziety"),
    ],
    values: &[
        &["angrily"],
        &["angular"],
        &["agnostic"],
        &["agnosticism"],
        &["angrily"],
        &["anxious"],
        &["anxiously"],
        &["anxiousness"],
        &["anxious"],
        &["anxiously"],
        &["anxiousness"],
        &["anxious"],
        &["anxiously"],
        &["anxiousness"],
        &["anxious"],
        &["anxiously"],
        &["anxiousness"],
        &["language"],
        &["angular"],
        &["angular"],
        &["anxiety"],
    ],
    range: 4..=10,
};

static WORD_ANE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ANE_CHILDREN),
    value: Some(&["and"]),
};

pub static WORD_ANE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cdatally"),
        dictgen::InsensitiveStr::Ascii("cdotale"),
        dictgen::InsensitiveStr::Ascii("cdotallly"),
        dictgen::InsensitiveStr::Ascii("cdotelly"),
        dictgen::InsensitiveStr::Ascii("cdotice"),
        dictgen::InsensitiveStr::Ascii("cdotle"),
        dictgen::InsensitiveStr::Ascii("cdots"),
        dictgen::InsensitiveStr::Ascii("codtal"),
        dictgen::InsensitiveStr::Ascii("codtally"),
        dictgen::InsensitiveStr::Ascii("codtes"),
        dictgen::InsensitiveStr::Ascii("ctodal"),
        dictgen::InsensitiveStr::Ascii("ctodally"),
        dictgen::InsensitiveStr::Ascii("ctode"),
        dictgen::InsensitiveStr::Ascii("ctodes"),
        dictgen::InsensitiveStr::Ascii("ctotally"),
        dictgen::InsensitiveStr::Ascii("doctal"),
        dictgen::InsensitiveStr::Ascii("doctally"),
        dictgen::InsensitiveStr::Ascii("docte"),
        dictgen::InsensitiveStr::Ascii("doctes"),
        dictgen::InsensitiveStr::Ascii("el"),
        dictgen::InsensitiveStr::Ascii("eled"),
        dictgen::InsensitiveStr::Ascii("eling"),
        dictgen::InsensitiveStr::Ascii("els"),
        dictgen::InsensitiveStr::Ascii("roxia"),
        dictgen::InsensitiveStr::Ascii("roxic"),
        dictgen::InsensitiveStr::Ascii("stheisa"),
        dictgen::InsensitiveStr::Ascii("sthetia"),
        dictgen::InsensitiveStr::Ascii("sthisia"),
        dictgen::InsensitiveStr::Ascii("vironment"),
        dictgen::InsensitiveStr::Ascii("vironments"),
    ],
    values: &[
        &["anecdotally"],
        &["anecdote"],
        &["anecdotally"],
        &["anecdotally"],
        &["anecdote"],
        &["anecdote"],
        &["anecdotes"],
        &["anecdotal"],
        &["anecdotally"],
        &["anecdotes"],
        &["anecdotal"],
        &["anecdotally"],
        &["anecdote"],
        &["anecdotes"],
        &["anecdotally"],
        &["anecdotal"],
        &["anecdotally"],
        &["anecdote"],
        &["anecdotes"],
        &["anneal"],
        &["annealed"],
        &["annealing"],
        &["anneals"],
        &["anorexia"],
        &["anorexic"],
        &["anesthesia"],
        &["anesthesia"],
        &["anesthesia"],
        &["environment"],
        &["environments"],
    ],
    range: 2..=10,
};

static WORD_AND_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AND_CHILDREN),
    value: None,
};

pub static WORD_AND_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("d"),
        dictgen::InsensitiveStr::Ascii("lers"),
        dictgen::InsensitiveStr::Ascii("oid"),
        dictgen::InsensitiveStr::Ascii("oids"),
        dictgen::InsensitiveStr::Ascii("oirds"),
        dictgen::InsensitiveStr::Ascii("orid"),
        dictgen::InsensitiveStr::Ascii("orids"),
        dictgen::InsensitiveStr::Ascii("riod"),
        dictgen::InsensitiveStr::Ascii("riods"),
        dictgen::InsensitiveStr::Ascii("rogenous"),
        dictgen::InsensitiveStr::Ascii("rogeny"),
        dictgen::InsensitiveStr::Ascii("roiders"),
        dictgen::InsensitiveStr::Ascii("roides"),
        dictgen::InsensitiveStr::Ascii("roidextra"),
        dictgen::InsensitiveStr::Ascii("roidos"),
        dictgen::InsensitiveStr::Ascii("roidtvs"),
        dictgen::InsensitiveStr::Ascii("roind"),
        dictgen::InsensitiveStr::Ascii("roinds"),
        dictgen::InsensitiveStr::Ascii("rois"),
    ],
    values: &[
        &["and"],
        &["handlers", "antlers"],
        &["android"],
        &["androids"],
        &["androids"],
        &["android"],
        &["androids"],
        &["android"],
        &["androids"],
        &["androgynous"],
        &["androgyny"],
        &["androids"],
        &["androids"],
        &["androidextras"],
        &["androids"],
        &["androids"],
        &["android"],
        &["androids"],
        &["androids"],
    ],
    range: 1..=9,
};

static WORD_ANC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ANC_CHILDREN),
    value: None,
};

pub static WORD_ANC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("apsulate"),
        dictgen::InsensitiveStr::Ascii("apsulated"),
        dictgen::InsensitiveStr::Ascii("apsulates"),
        dictgen::InsensitiveStr::Ascii("apsulating"),
        dictgen::InsensitiveStr::Ascii("apsulation"),
        dictgen::InsensitiveStr::Ascii("edotal"),
        dictgen::InsensitiveStr::Ascii("edotally"),
        dictgen::InsensitiveStr::Ascii("edote"),
        dictgen::InsensitiveStr::Ascii("edotes"),
        dictgen::InsensitiveStr::Ascii("eint"),
        dictgen::InsensitiveStr::Ascii("eints"),
        dictgen::InsensitiveStr::Ascii("esetor"),
        dictgen::InsensitiveStr::Ascii("esetors"),
        dictgen::InsensitiveStr::Ascii("ester"),
        dictgen::InsensitiveStr::Ascii("esteres"),
        dictgen::InsensitiveStr::Ascii("esters"),
        dictgen::InsensitiveStr::Ascii("estoral"),
        dictgen::InsensitiveStr::Ascii("estore"),
        dictgen::InsensitiveStr::Ascii("estores"),
        dictgen::InsensitiveStr::Ascii("estory"),
        dictgen::InsensitiveStr::Ascii("hestor"),
        dictgen::InsensitiveStr::Ascii("hestors"),
        dictgen::InsensitiveStr::Ascii("hord"),
        dictgen::InsensitiveStr::Ascii("illiary"),
        dictgen::InsensitiveStr::Ascii("inets"),
    ],
    values: &[
        &["encapsulate"],
        &["encapsulated"],
        &["encapsulates"],
        &["encapsulating"],
        &["encapsulation"],
        &["anecdotal"],
        &["anecdotally"],
        &["anecdote"],
        &["anecdotes"],
        &["ancient"],
        &["ancients"],
        &["ancestor"],
        &["ancestors"],
        &["ancestor"],
        &["ancestors"],
        &["ancestors"],
        &["ancestral"],
        &["ancestor"],
        &["ancestors"],
        &["ancestry"],
        &["ancestor"],
        &["ancestors"],
        &["anchored"],
        &["ancillary"],
        &["ancients"],
    ],
    range: 4..=10,
};

static WORD_ANB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ANB_CHILDREN),
    value: None,
};

pub static WORD_ANB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("d")],
    values: &[&["and"]],
    range: 1..=1,
};

static WORD_ANA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_ANA_CHILDREN),
    value: None,
};

static WORD_ANA_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    Some(&WORD_ANAC_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_ANAL_NODE),
    None,
    Some(&WORD_ANAN_NODE),
    Some(&WORD_ANAO_NODE),
    None,
    None,
    Some(&WORD_ANAR_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_ANAY_NODE),
    None,
];

static WORD_ANAY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ANAY_CHILDREN),
    value: None,
};

pub static WORD_ANAY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("lse"),
        dictgen::InsensitiveStr::Ascii("lsed"),
        dictgen::InsensitiveStr::Ascii("lser"),
        dictgen::InsensitiveStr::Ascii("lses"),
        dictgen::InsensitiveStr::Ascii("lsis"),
        dictgen::InsensitiveStr::Ascii("lsises"),
        dictgen::InsensitiveStr::Ascii("lst"),
        dictgen::InsensitiveStr::Ascii("lsts"),
        dictgen::InsensitiveStr::Ascii("ltic"),
        dictgen::InsensitiveStr::Ascii("ltical"),
        dictgen::InsensitiveStr::Ascii("ltically"),
        dictgen::InsensitiveStr::Ascii("ltics"),
        dictgen::InsensitiveStr::Ascii("lze"),
        dictgen::InsensitiveStr::Ascii("lzed"),
        dictgen::InsensitiveStr::Ascii("lzer"),
        dictgen::InsensitiveStr::Ascii("lzes"),
        dictgen::InsensitiveStr::Ascii("lzing"),
    ],
    values: &[
        &["analyse"],
        &["analysed"],
        &["analyser"],
        &["analyses"],
        &["analysis"],
        &["analysises"],
        &["analyst"],
        &["analysts"],
        &["analytic"],
        &["analytical"],
        &["analytically"],
        &["analytics"],
        &["analyze"],
        &["analyzed"],
        &["analyzer"],
        &["analyzes"],
        &["analyzing"],
    ],
    range: 3..=8,
};

static WORD_ANAR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ANAR_CHILDREN),
    value: None,
};

pub static WORD_ANAR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("chim"),
        dictgen::InsensitiveStr::Ascii("chisim"),
        dictgen::InsensitiveStr::Ascii("chistes"),
        dictgen::InsensitiveStr::Ascii("chistm"),
        dictgen::InsensitiveStr::Ascii("chiszm"),
        dictgen::InsensitiveStr::Ascii("chit"),
        dictgen::InsensitiveStr::Ascii("chits"),
        dictgen::InsensitiveStr::Ascii("chsim"),
        dictgen::InsensitiveStr::Ascii("chsits"),
        dictgen::InsensitiveStr::Ascii("kist"),
        dictgen::InsensitiveStr::Ascii("kistic"),
        dictgen::InsensitiveStr::Ascii("kists"),
        dictgen::InsensitiveStr::Ascii("quism"),
        dictgen::InsensitiveStr::Ascii("quist"),
        dictgen::InsensitiveStr::Ascii("quistic"),
        dictgen::InsensitiveStr::Ascii("quists"),
    ],
    values: &[
        &["anarchism"],
        &["anarchism"],
        &["anarchists"],
        &["anarchism", "anarchist"],
        &["anarchism"],
        &["anarchist"],
        &["anarchists"],
        &["anarchism"],
        &["anarchists"],
        &["anarchist"],
        &["anarchistic"],
        &["anarchists"],
        &["anarchism"],
        &["anarchist"],
        &["anarchistic"],
        &["anarchists"],
    ],
    range: 4..=7,
};

static WORD_ANAO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ANAO_CHILDREN),
    value: None,
};

pub static WORD_ANAO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("lgue")],
    values: &[&["analogue"]],
    range: 4..=4,
};

static WORD_ANAN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ANAN_CHILDREN),
    value: None,
};

pub static WORD_ANAN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("log")],
    values: &[&["analog"]],
    range: 3..=3,
};

static WORD_ANAL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_ANAL_CHILDREN),
    value: None,
};

static WORD_ANAL_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_ANALA_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_ANALG_NODE),
    None,
    Some(&WORD_ANALI_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_ANALO_NODE),
    None,
    None,
    None,
    Some(&WORD_ANALS_NODE),
    Some(&WORD_ANALT_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_ANALY_NODE),
    Some(&WORD_ANALZ_NODE),
];

static WORD_ANALZ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ANALZ_CHILDREN),
    value: None,
};

pub static WORD_ANALZ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ye"),
        dictgen::InsensitiveStr::Ascii("yed"),
        dictgen::InsensitiveStr::Ascii("yer"),
        dictgen::InsensitiveStr::Ascii("yers"),
        dictgen::InsensitiveStr::Ascii("yes"),
        dictgen::InsensitiveStr::Ascii("ying"),
    ],
    values: &[
        &["analyze"],
        &["analyzed"],
        &["analyzer"],
        &["analyzers"],
        &["analyzes"],
        &["analyzing"],
    ],
    range: 2..=4,
};

static WORD_ANALY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ANALY_CHILDREN),
    value: None,
};

pub static WORD_ANALY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("er"),
        dictgen::InsensitiveStr::Ascii("ers"),
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("is"),
        dictgen::InsensitiveStr::Ascii("ist"),
        dictgen::InsensitiveStr::Ascii("ists"),
        dictgen::InsensitiveStr::Ascii("itcal"),
        dictgen::InsensitiveStr::Ascii("itcs"),
        dictgen::InsensitiveStr::Ascii("sator"),
        dictgen::InsensitiveStr::Ascii("seas"),
        dictgen::InsensitiveStr::Ascii("sees"),
        dictgen::InsensitiveStr::Ascii("seles"),
        dictgen::InsensitiveStr::Ascii("sens"),
        dictgen::InsensitiveStr::Ascii("seras"),
        dictgen::InsensitiveStr::Ascii("seres"),
        dictgen::InsensitiveStr::Ascii("sie"),
        dictgen::InsensitiveStr::Ascii("sies"),
        dictgen::InsensitiveStr::Ascii("sise"),
        dictgen::InsensitiveStr::Ascii("sised"),
        dictgen::InsensitiveStr::Ascii("sisto"),
        dictgen::InsensitiveStr::Ascii("sit"),
        dictgen::InsensitiveStr::Ascii("ste"),
        dictgen::InsensitiveStr::Ascii("stes"),
        dictgen::InsensitiveStr::Ascii("stics"),
        dictgen::InsensitiveStr::Ascii("sus"),
        dictgen::InsensitiveStr::Ascii("sy"),
        dictgen::InsensitiveStr::Ascii("sys"),
        dictgen::InsensitiveStr::Ascii("sze"),
        dictgen::InsensitiveStr::Ascii("ticall"),
        dictgen::InsensitiveStr::Ascii("ticals"),
        dictgen::InsensitiveStr::Ascii("ticaly"),
        dictgen::InsensitiveStr::Ascii("ticly"),
        dictgen::InsensitiveStr::Ascii("ts"),
        dictgen::InsensitiveStr::Ascii("zator"),
        dictgen::InsensitiveStr::Ascii("zies"),
    ],
    values: &[
        &["analyse", "analyze"],
        &["analysed", "analyzed"],
        &["analyser", "analyzer"],
        &["analysers", "analyzers"],
        &["analyse", "analyses", "analyzes", "analyze"],
        &["analysis"],
        &["analyst"],
        &["analysts"],
        &["analytical"],
        &["analytics"],
        &["analyser"],
        &["analyses"],
        &["analyses"],
        &["analyses"],
        &["analyses"],
        &["analyses"],
        &["analyses"],
        &["analyse"],
        &["analyses", "analysis"],
        &["analyses"],
        &["analyses"],
        &["analysts"],
        &["analyst"],
        &["analyse"],
        &["analysts"],
        &["analysts"],
        &["analysis"],
        &["analysis"],
        &["analysis"],
        &["analyse"],
        &["analytical", "analytically"],
        &["analytics"],
        &["analytically"],
        &["analytically"],
        &["analyst"],
        &["analyzer"],
        &["analysis", "analyzes"],
    ],
    range: 1..=6,
};

static WORD_ANALT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ANALT_CHILDREN),
    value: None,
};

pub static WORD_ANALT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("yics")],
    values: &[&["analytics"]],
    range: 4..=4,
};

static WORD_ANALS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ANALS_CHILDREN),
    value: None,
};

pub static WORD_ANALS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ye"),
        dictgen::InsensitiveStr::Ascii("yed"),
        dictgen::InsensitiveStr::Ascii("yer"),
        dictgen::InsensitiveStr::Ascii("yers"),
        dictgen::InsensitiveStr::Ascii("yes"),
        dictgen::InsensitiveStr::Ascii("ying"),
        dictgen::InsensitiveStr::Ascii("yis"),
        dictgen::InsensitiveStr::Ascii("yt"),
        dictgen::InsensitiveStr::Ascii("yts"),
    ],
    values: &[
        &["analyse"],
        &["analysed"],
        &["analyser"],
        &["analysers"],
        &["analyses"],
        &["analysing"],
        &["analysis"],
        &["analyst"],
        &["analysts"],
    ],
    range: 2..=4,
};

static WORD_ANALO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ANALO_CHILDREN),
    value: None,
};

pub static WORD_ANALO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ge"),
        dictgen::InsensitiveStr::Ascii("geous"),
        dictgen::InsensitiveStr::Ascii("gicaly"),
        dictgen::InsensitiveStr::Ascii("guous"),
        dictgen::InsensitiveStr::Ascii("guously"),
        dictgen::InsensitiveStr::Ascii("gus"),
        dictgen::InsensitiveStr::Ascii("uge"),
        dictgen::InsensitiveStr::Ascii("uges"),
    ],
    values: &[
        &["analogue"],
        &["analogous"],
        &["analogically"],
        &["analogous"],
        &["analogously"],
        &["analogous"],
        &["analogue"],
        &["analogues"],
    ],
    range: 2..=7,
};

static WORD_ANALI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ANALI_CHILDREN),
    value: None,
};

pub static WORD_ANALI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("g"),
        dictgen::InsensitiveStr::Ascii("se"),
        dictgen::InsensitiveStr::Ascii("sed"),
        dictgen::InsensitiveStr::Ascii("ser"),
        dictgen::InsensitiveStr::Ascii("ses"),
        dictgen::InsensitiveStr::Ascii("sing"),
        dictgen::InsensitiveStr::Ascii("sis"),
        dictgen::InsensitiveStr::Ascii("sys"),
        dictgen::InsensitiveStr::Ascii("tic"),
        dictgen::InsensitiveStr::Ascii("tical"),
        dictgen::InsensitiveStr::Ascii("tically"),
        dictgen::InsensitiveStr::Ascii("ticaly"),
        dictgen::InsensitiveStr::Ascii("tycal"),
        dictgen::InsensitiveStr::Ascii("tycs"),
        dictgen::InsensitiveStr::Ascii("ze"),
        dictgen::InsensitiveStr::Ascii("zed"),
        dictgen::InsensitiveStr::Ascii("zer"),
        dictgen::InsensitiveStr::Ascii("zes"),
        dictgen::InsensitiveStr::Ascii("zing"),
    ],
    values: &[
        &["analog"],
        &["analyse"],
        &["analysed"],
        &["analyser"],
        &["analysis", "analyses"],
        &["analysing"],
        &["analysis"],
        &["analysis"],
        &["analytic"],
        &["analytical"],
        &["analytically"],
        &["analytically"],
        &["analytical"],
        &["analytics"],
        &["analyze"],
        &["analyzed"],
        &["analyzer"],
        &["analyzes"],
        &["analyzing"],
    ],
    range: 1..=7,
};

static WORD_ANALG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ANALG_CHILDREN),
    value: None,
};

pub static WORD_ANALG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("oue"),
        dictgen::InsensitiveStr::Ascii("ous"),
    ],
    values: &[&["analogue"], &["analogous"]],
    range: 3..=3,
};

static WORD_ANALA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ANALA_CHILDREN),
    value: None,
};

pub static WORD_ANALA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("gous"),
        dictgen::InsensitiveStr::Ascii("gus"),
        dictgen::InsensitiveStr::Ascii("og"),
    ],
    values: &[&["analogous"], &["analogous"], &["analog"]],
    range: 2..=4,
};

static WORD_ANAC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ANAC_CHILDREN),
    value: None,
};

pub static WORD_ANAC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("hrist")],
    values: &[&["anarchist"]],
    range: 5..=5,
};

static WORD_AM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_AM_CHILDREN),
    value: None,
};

static WORD_AM_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_AMA_NODE),
    Some(&WORD_AMB_NODE),
    None,
    Some(&WORD_AMD_NODE),
    Some(&WORD_AME_NODE),
    None,
    Some(&WORD_AMG_NODE),
    None,
    Some(&WORD_AMI_NODE),
    None,
    Some(&WORD_AMK_NODE),
    None,
    Some(&WORD_AMM_NODE),
    Some(&WORD_AMN_NODE),
    Some(&WORD_AMO_NODE),
    Some(&WORD_AMP_NODE),
    None,
    Some(&WORD_AMR_NODE),
    None,
    Some(&WORD_AMT_NODE),
    Some(&WORD_AMU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_AMU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AMU_CHILDREN),
    value: None,
};

pub static WORD_AMU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("blance"),
        dictgen::InsensitiveStr::Ascii("ch"),
        dictgen::InsensitiveStr::Ascii("ng"),
        dictgen::InsensitiveStr::Ascii("nition"),
        dictgen::InsensitiveStr::Ascii("nt"),
    ],
    values: &[
        &["ambulance"],
        &["much"],
        &["among"],
        &["ammunition"],
        &["amount"],
    ],
    range: 2..=6,
};

static WORD_AMT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AMT_CHILDREN),
    value: None,
};

pub static WORD_AMT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("heyst")],
    values: &[&["amethyst"]],
    range: 5..=5,
};

static WORD_AMR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AMR_CHILDREN),
    value: None,
};

pub static WORD_AMR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ageddon"),
        dictgen::InsensitiveStr::Ascii("chair"),
        dictgen::InsensitiveStr::Ascii("enian"),
        dictgen::InsensitiveStr::Ascii("pits"),
        dictgen::InsensitiveStr::Ascii("strong"),
    ],
    values: &[
        &["armageddon"],
        &["armchair"],
        &["armenian"],
        &["armpits"],
        &["armstrong"],
    ],
    range: 4..=7,
};

static WORD_AMP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AMP_CHILDREN),
    value: None,
};

pub static WORD_AMP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("atheater"),
        dictgen::InsensitiveStr::Ascii("atheaters"),
        dictgen::InsensitiveStr::Ascii("ehtamine"),
        dictgen::InsensitiveStr::Ascii("ehtamines"),
        dictgen::InsensitiveStr::Ascii("erstands"),
        dictgen::InsensitiveStr::Ascii("ethamine"),
        dictgen::InsensitiveStr::Ascii("ethamines"),
        dictgen::InsensitiveStr::Ascii("hasis"),
        dictgen::InsensitiveStr::Ascii("hatamines"),
        dictgen::InsensitiveStr::Ascii("hatheater"),
        dictgen::InsensitiveStr::Ascii("hatheaters"),
        dictgen::InsensitiveStr::Ascii("hedamines"),
        dictgen::InsensitiveStr::Ascii("hetamenes"),
        dictgen::InsensitiveStr::Ascii("hetamies"),
        dictgen::InsensitiveStr::Ascii("hetamins"),
        dictgen::InsensitiveStr::Ascii("hetemine"),
        dictgen::InsensitiveStr::Ascii("hetemines"),
        dictgen::InsensitiveStr::Ascii("hetimine"),
        dictgen::InsensitiveStr::Ascii("hetimines"),
        dictgen::InsensitiveStr::Ascii("hetmaine"),
        dictgen::InsensitiveStr::Ascii("hetmaines"),
        dictgen::InsensitiveStr::Ascii("ilfy"),
        dictgen::InsensitiveStr::Ascii("itheater"),
        dictgen::InsensitiveStr::Ascii("itheaters"),
        dictgen::InsensitiveStr::Ascii("lifer"),
        dictgen::InsensitiveStr::Ascii("lifiy"),
        dictgen::InsensitiveStr::Ascii("lifly"),
        dictgen::InsensitiveStr::Ascii("lifyer"),
        dictgen::InsensitiveStr::Ascii("litud"),
        dictgen::InsensitiveStr::Ascii("ty"),
    ],
    values: &[
        &["amphitheater"],
        &["amphitheaters"],
        &["amphetamine"],
        &["amphetamines"],
        &["ampersands"],
        &["amphetamine"],
        &["amphetamines"],
        &["emphasis"],
        &["amphetamines"],
        &["amphitheater"],
        &["amphitheaters"],
        &["amphetamines"],
        &["amphetamines"],
        &["amphetamines"],
        &["amphetamines"],
        &["amphetamine"],
        &["amphetamines"],
        &["amphetamine"],
        &["amphetamines"],
        &["amphetamines"],
        &["amphetamines"],
        &["amplify"],
        &["amphitheater"],
        &["amphitheaters"],
        &["amplifier"],
        &["amplify"],
        &["amplify"],
        &["amplifier"],
        &["amplitude"],
        &["empty"],
    ],
    range: 2..=10,
};

static WORD_AMO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AMO_CHILDREN),
    value: None,
};

pub static WORD_AMO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("gnst"),
        dictgen::InsensitiveStr::Ascii("hetamines"),
        dictgen::InsensitiveStr::Ascii("ngs"),
        dictgen::InsensitiveStr::Ascii("ngts"),
        dictgen::InsensitiveStr::Ascii("nsgt"),
        dictgen::InsensitiveStr::Ascii("nst"),
        dictgen::InsensitiveStr::Ascii("nt"),
        dictgen::InsensitiveStr::Ascii("nut"),
        dictgen::InsensitiveStr::Ascii("und"),
        dictgen::InsensitiveStr::Ascii("unds"),
        dictgen::InsensitiveStr::Ascii("ung"),
        dictgen::InsensitiveStr::Ascii("ungst"),
        dictgen::InsensitiveStr::Ascii("ut"),
        dictgen::InsensitiveStr::Ascii("utn"),
        dictgen::InsensitiveStr::Ascii("utns"),
        dictgen::InsensitiveStr::Ascii("uts"),
    ],
    values: &[
        &["amongst"],
        &["amphetamines"],
        &["among"],
        &["amongst"],
        &["amongst"],
        &["amongst"],
        &["among", "amount"],
        &["amount"],
        &["amount"],
        &["amounts"],
        &["among"],
        &["amongst"],
        &["amount"],
        &["amount"],
        &["amounts"],
        &["amounts"],
    ],
    range: 2..=9,
};

static WORD_AMN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AMN_CHILDREN),
    value: None,
};

pub static WORD_AMN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eisa"),
        dictgen::InsensitiveStr::Ascii("estry"),
        dictgen::InsensitiveStr::Ascii("sety"),
        dictgen::InsensitiveStr::Ascii("y"),
    ],
    values: &[&["amnesia"], &["amnesty"], &["amnesty"], &["many"]],
    range: 1..=5,
};

static WORD_AMM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AMM_CHILDREN),
    value: None,
};

pub static WORD_AMM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("end"),
        dictgen::InsensitiveStr::Ascii("ended"),
        dictgen::InsensitiveStr::Ascii("ending"),
        dictgen::InsensitiveStr::Ascii("endment"),
        dictgen::InsensitiveStr::Ascii("endments"),
        dictgen::InsensitiveStr::Ascii("ends"),
        dictgen::InsensitiveStr::Ascii("inistrative"),
        dictgen::InsensitiveStr::Ascii("ong"),
        dictgen::InsensitiveStr::Ascii("ongst"),
        dictgen::InsensitiveStr::Ascii("ortizes"),
        dictgen::InsensitiveStr::Ascii("oung"),
        dictgen::InsensitiveStr::Ascii("oungst"),
        dictgen::InsensitiveStr::Ascii("ount"),
        dictgen::InsensitiveStr::Ascii("used"),
    ],
    values: &[
        &["amend"],
        &["amended"],
        &["amending"],
        &["amendment"],
        &["amendments"],
        &["amends"],
        &["administrative"],
        &["among"],
        &["amongst"],
        &["amortizes"],
        &["among"],
        &["amongst"],
        &["amount"],
        &["amused"],
    ],
    range: 3..=11,
};

static WORD_AMK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AMK_CHILDREN),
    value: None,
};

pub static WORD_AMK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("ing"),
    ],
    values: &[&["make"], &["making"]],
    range: 1..=3,
};

static WORD_AMI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AMI_CHILDREN),
    value: None,
};

pub static WORD_AMI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("bguity"),
        dictgen::InsensitiveStr::Ascii("guous"),
        dictgen::InsensitiveStr::Ascii("nosity"),
    ],
    values: &[&["ambiguity"], &["ambiguous"], &["animosity"]],
    range: 5..=6,
};

static WORD_AMG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AMG_CHILDREN),
    value: None,
};

pub static WORD_AMG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("le"),
        dictgen::InsensitiveStr::Ascii("les"),
    ],
    values: &[&["angle"], &["angles"]],
    range: 2..=3,
};

static WORD_AME_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_AME_CHILDREN),
    value: None,
};

static WORD_AME_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_AMEA_NODE),
    None,
    None,
    None,
    Some(&WORD_AMEE_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_AMEL_NODE),
    None,
    Some(&WORD_AMEN_NODE),
    None,
    None,
    None,
    Some(&WORD_AMER_NODE),
    None,
    Some(&WORD_AMET_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_AMEY_NODE),
    None,
];

static WORD_AMEY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AMEY_CHILDREN),
    value: None,
};

pub static WORD_AMEY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("thst")],
    values: &[&["amethyst"]],
    range: 4..=4,
};

static WORD_AMET_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AMET_CHILDREN),
    value: None,
};

pub static WORD_AMET_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("hsyt")],
    values: &[&["amethyst"]],
    range: 4..=4,
};

static WORD_AMER_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AMER_CHILDREN),
    value: None,
};

pub static WORD_AMER_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cia"),
        dictgen::InsensitiveStr::Ascii("cian"),
        dictgen::InsensitiveStr::Ascii("cians"),
        dictgen::InsensitiveStr::Ascii("cias"),
        dictgen::InsensitiveStr::Ascii("icain"),
        dictgen::InsensitiveStr::Ascii("icains"),
        dictgen::InsensitiveStr::Ascii("icams"),
        dictgen::InsensitiveStr::Ascii("icanas"),
        dictgen::InsensitiveStr::Ascii("icanis"),
        dictgen::InsensitiveStr::Ascii("icanss"),
        dictgen::InsensitiveStr::Ascii("icants"),
        dictgen::InsensitiveStr::Ascii("icanus"),
        dictgen::InsensitiveStr::Ascii("icaps"),
        dictgen::InsensitiveStr::Ascii("icares"),
        dictgen::InsensitiveStr::Ascii("icats"),
        dictgen::InsensitiveStr::Ascii("ics"),
        dictgen::InsensitiveStr::Ascii("liorate"),
        dictgen::InsensitiveStr::Ascii("liorated"),
        dictgen::InsensitiveStr::Ascii("liorates"),
        dictgen::InsensitiveStr::Ascii("liorating"),
        dictgen::InsensitiveStr::Ascii("liorative"),
        dictgen::InsensitiveStr::Ascii("liorator"),
        dictgen::InsensitiveStr::Ascii("nian"),
    ],
    values: &[
        &["america"],
        &["american"],
        &["americans"],
        &["americas"],
        &["american"],
        &["americas"],
        &["americas"],
        &["americans"],
        &["americas"],
        &["americas"],
        &["americas"],
        &["americans"],
        &["americas"],
        &["americas"],
        &["americas"],
        &["americas"],
        &["ameliorate"],
        &["ameliorated"],
        &["ameliorates"],
        &["ameliorating"],
        &["ameliorative"],
        &["ameliorator"],
        &["armenian"],
    ],
    range: 3..=9,
};

static WORD_AMEN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AMEN_CHILDREN),
    value: None,
};

pub static WORD_AMEN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("dement"),
        dictgen::InsensitiveStr::Ascii("dmant"),
        dictgen::InsensitiveStr::Ascii("dmants"),
        dictgen::InsensitiveStr::Ascii("dmends"),
        dictgen::InsensitiveStr::Ascii("dmenters"),
        dictgen::InsensitiveStr::Ascii("dmet"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("sia"),
        dictgen::InsensitiveStr::Ascii("sty"),
    ],
    values: &[
        &["amendment"],
        &["amendment"],
        &["amendments"],
        &["amendments"],
        &["amendments"],
        &["amendments"],
        &["amended", "amend"],
        &["amnesia"],
        &["amnesty"],
    ],
    range: 2..=8,
};

static WORD_AMEL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AMEL_CHILDREN),
    value: None,
};

pub static WORD_AMEL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("earate"),
        dictgen::InsensitiveStr::Ascii("earated"),
        dictgen::InsensitiveStr::Ascii("earates"),
        dictgen::InsensitiveStr::Ascii("earating"),
        dictgen::InsensitiveStr::Ascii("earative"),
        dictgen::InsensitiveStr::Ascii("earator"),
    ],
    values: &[
        &["ameliorate"],
        &["ameliorated"],
        &["ameliorates"],
        &["ameliorating"],
        &["ameliorative"],
        &["ameliorator"],
    ],
    range: 6..=8,
};

static WORD_AMEE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AMEE_CHILDREN),
    value: None,
};

pub static WORD_AMEE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("larate"),
        dictgen::InsensitiveStr::Ascii("larated"),
        dictgen::InsensitiveStr::Ascii("larates"),
        dictgen::InsensitiveStr::Ascii("larating"),
        dictgen::InsensitiveStr::Ascii("larative"),
        dictgen::InsensitiveStr::Ascii("larator"),
        dictgen::InsensitiveStr::Ascii("liarate"),
        dictgen::InsensitiveStr::Ascii("liarated"),
        dictgen::InsensitiveStr::Ascii("liarates"),
        dictgen::InsensitiveStr::Ascii("liarating"),
        dictgen::InsensitiveStr::Ascii("liarative"),
        dictgen::InsensitiveStr::Ascii("liarator"),
    ],
    values: &[
        &["ameliorate"],
        &["ameliorated"],
        &["ameliorates"],
        &["ameliorating"],
        &["ameliorative"],
        &["ameliorator"],
        &["ameliorate"],
        &["ameliorated"],
        &["ameliorates"],
        &["ameliorating"],
        &["ameliorative"],
        &["ameliorator"],
    ],
    range: 6..=9,
};

static WORD_AMEA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AMEA_CHILDREN),
    value: None,
};

pub static WORD_AMEA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("learate"),
        dictgen::InsensitiveStr::Ascii("learated"),
        dictgen::InsensitiveStr::Ascii("learates"),
        dictgen::InsensitiveStr::Ascii("learating"),
        dictgen::InsensitiveStr::Ascii("learative"),
        dictgen::InsensitiveStr::Ascii("learator"),
        dictgen::InsensitiveStr::Ascii("liarate"),
        dictgen::InsensitiveStr::Ascii("liarated"),
        dictgen::InsensitiveStr::Ascii("liarates"),
        dictgen::InsensitiveStr::Ascii("liarating"),
        dictgen::InsensitiveStr::Ascii("liarative"),
        dictgen::InsensitiveStr::Ascii("liarator"),
    ],
    values: &[
        &["ameliorate"],
        &["ameliorated"],
        &["ameliorates"],
        &["ameliorating"],
        &["ameliorative"],
        &["ameliorator"],
        &["ameliorate"],
        &["ameliorated"],
        &["ameliorates"],
        &["ameliorating"],
        &["ameliorative"],
        &["ameliorator"],
    ],
    range: 7..=9,
};

static WORD_AMD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AMD_CHILDREN),
    value: None,
};

pub static WORD_AMD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("gput")],
    values: &[&["amdgpu"]],
    range: 4..=4,
};

static WORD_AMB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AMB_CHILDREN),
    value: None,
};

pub static WORD_AMB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("adexterous"),
        dictgen::InsensitiveStr::Ascii("adexterouseness"),
        dictgen::InsensitiveStr::Ascii("adexterously"),
        dictgen::InsensitiveStr::Ascii("adexterousness"),
        dictgen::InsensitiveStr::Ascii("adextrous"),
        dictgen::InsensitiveStr::Ascii("adextrouseness"),
        dictgen::InsensitiveStr::Ascii("adextrously"),
        dictgen::InsensitiveStr::Ascii("adextrousness"),
        dictgen::InsensitiveStr::Ascii("assabor"),
        dictgen::InsensitiveStr::Ascii("assader"),
        dictgen::InsensitiveStr::Ascii("assator"),
        dictgen::InsensitiveStr::Ascii("assedor"),
        dictgen::InsensitiveStr::Ascii("assidor"),
        dictgen::InsensitiveStr::Ascii("assodor"),
        dictgen::InsensitiveStr::Ascii("edded"),
        dictgen::InsensitiveStr::Ascii("ibuity"),
        dictgen::InsensitiveStr::Ascii("idexterous"),
        dictgen::InsensitiveStr::Ascii("idexterouseness"),
        dictgen::InsensitiveStr::Ascii("idexterously"),
        dictgen::InsensitiveStr::Ascii("idexterousness"),
        dictgen::InsensitiveStr::Ascii("ien"),
        dictgen::InsensitiveStr::Ascii("igious"),
        dictgen::InsensitiveStr::Ascii("igous"),
        dictgen::InsensitiveStr::Ascii("iguious"),
        dictgen::InsensitiveStr::Ascii("iguitiy"),
        dictgen::InsensitiveStr::Ascii("iguos"),
        dictgen::InsensitiveStr::Ascii("itous"),
        dictgen::InsensitiveStr::Ascii("luance"),
        dictgen::InsensitiveStr::Ascii("uguity"),
        dictgen::InsensitiveStr::Ascii("uigity"),
        dictgen::InsensitiveStr::Ascii("ulancier"),
        dictgen::InsensitiveStr::Ascii("ulence"),
        dictgen::InsensitiveStr::Ascii("ulences"),
    ],
    values: &[
        &["ambidextrous"],
        &["ambidextrousness"],
        &["ambidextrously"],
        &["ambidextrousness"],
        &["ambidextrous"],
        &["ambidextrousness"],
        &["ambidextrously"],
        &["ambidextrousness"],
        &["ambassador"],
        &["ambassador"],
        &["ambassador"],
        &["ambassador"],
        &["ambassador"],
        &["ambassador"],
        &["embedded"],
        &["ambiguity"],
        &["ambidextrous"],
        &["ambidextrousness"],
        &["ambidextrously"],
        &["ambidextrousness"],
        &["ambient"],
        &["ambiguous"],
        &["ambiguous"],
        &["ambiguous"],
        &["ambiguity"],
        &["ambiguous"],
        &["ambitious"],
        &["ambulance"],
        &["ambiguity"],
        &["ambiguity"],
        &["ambulance"],
        &["ambulance"],
        &["ambulances"],
    ],
    range: 3..=15,
};

static WORD_AMA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AMA_CHILDREN),
    value: None,
};

pub static WORD_AMA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cing"),
        dictgen::InsensitiveStr::Ascii("cingly"),
        dictgen::InsensitiveStr::Ascii("lgomated"),
        dictgen::InsensitiveStr::Ascii("lgum"),
        dictgen::InsensitiveStr::Ascii("lgums"),
        dictgen::InsensitiveStr::Ascii("rgeddon"),
        dictgen::InsensitiveStr::Ascii("tersu"),
        dictgen::InsensitiveStr::Ascii("terus"),
        dictgen::InsensitiveStr::Ascii("teures"),
        dictgen::InsensitiveStr::Ascii("teurest"),
        dictgen::InsensitiveStr::Ascii("teus"),
        dictgen::InsensitiveStr::Ascii("tuer"),
        dictgen::InsensitiveStr::Ascii("tuers"),
        dictgen::InsensitiveStr::Ascii("tur"),
        dictgen::InsensitiveStr::Ascii("ture"),
        dictgen::InsensitiveStr::Ascii("turs"),
        dictgen::InsensitiveStr::Ascii("zaing"),
    ],
    values: &[
        &["amazing"],
        &["amazingly"],
        &["amalgamated"],
        &["amalgam"],
        &["amalgams"],
        &["armageddon"],
        &["amateurs"],
        &["amateurs"],
        &["amateurs"],
        &["amateurs"],
        &["amateurs"],
        &["amateur"],
        &["amateurs"],
        &["amateur"],
        &["armature", "amateur"],
        &["amateurs"],
        &["amazing"],
    ],
    range: 3..=8,
};

static WORD_AL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_AL_CHILDREN),
    value: None,
};

static WORD_AL_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_ALA_NODE),
    Some(&WORD_ALB_NODE),
    Some(&WORD_ALC_NODE),
    Some(&WORD_ALD_NODE),
    Some(&WORD_ALE_NODE),
    Some(&WORD_ALF_NODE),
    Some(&WORD_ALG_NODE),
    Some(&WORD_ALH_NODE),
    Some(&WORD_ALI_NODE),
    None,
    None,
    Some(&WORD_ALL_NODE),
    Some(&WORD_ALM_NODE),
    None,
    Some(&WORD_ALO_NODE),
    Some(&WORD_ALP_NODE),
    None,
    Some(&WORD_ALR_NODE),
    Some(&WORD_ALS_NODE),
    Some(&WORD_ALT_NODE),
    Some(&WORD_ALU_NODE),
    Some(&WORD_ALV_NODE),
    Some(&WORD_ALW_NODE),
    None,
    Some(&WORD_ALY_NODE),
    None,
];

static WORD_ALY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ALY_CHILDREN),
    value: None,
};

pub static WORD_ALY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ways")],
    values: &[&["always"]],
    range: 4..=4,
};

static WORD_ALW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ALW_CHILDREN),
    value: None,
};

pub static WORD_ALW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ais"),
        dictgen::InsensitiveStr::Ascii("as"),
        dictgen::InsensitiveStr::Ascii("ast"),
        dictgen::InsensitiveStr::Ascii("asy"),
        dictgen::InsensitiveStr::Ascii("asys"),
        dictgen::InsensitiveStr::Ascii("aus"),
        dictgen::InsensitiveStr::Ascii("auys"),
        dictgen::InsensitiveStr::Ascii("ay"),
        dictgen::InsensitiveStr::Ascii("yas"),
        dictgen::InsensitiveStr::Ascii("ys"),
    ],
    values: &[
        &["always"],
        &["always"],
        &["always"],
        &["always"],
        &["always"],
        &["always"],
        &["always"],
        &["always"],
        &["always"],
        &["always"],
    ],
    range: 2..=4,
};

static WORD_ALV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ALV_CHILDREN),
    value: None,
};

pub static WORD_ALV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("orithm"),
        dictgen::InsensitiveStr::Ascii("orithmic"),
        dictgen::InsensitiveStr::Ascii("orithmically"),
        dictgen::InsensitiveStr::Ascii("orithms"),
    ],
    values: &[
        &["algorithm"],
        &["algorithmic"],
        &["algorithmically"],
        &["algorithms"],
    ],
    range: 6..=12,
};

static WORD_ALU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ALU_CHILDREN),
    value: None,
};

pub static WORD_ALU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("minim"),
        dictgen::InsensitiveStr::Ascii("minimum"),
        dictgen::InsensitiveStr::Ascii("mnium"),
        dictgen::InsensitiveStr::Ascii("nimum"),
        dictgen::InsensitiveStr::Ascii("sion"),
    ],
    values: &[
        &["value"],
        &["aluminium"],
        &["aluminium"],
        &["aluminium"],
        &["aluminum"],
        &["allusion", "illusion"],
    ],
    range: 1..=7,
};

static WORD_ALT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_ALT_CHILDREN),
    value: None,
};

static WORD_ALT_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_ALTA_NODE),
    None,
    None,
    None,
    Some(&WORD_ALTE_NODE),
    None,
    None,
    Some(&WORD_ALTH_NODE),
    Some(&WORD_ALTI_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_ALTN_NODE),
    Some(&WORD_ALTO_NODE),
    None,
    None,
    Some(&WORD_ALTR_NODE),
    None,
    None,
    Some(&WORD_ALTU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_ALTU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ALTU_CHILDREN),
    value: None,
};

pub static WORD_ALTU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("rism"),
        dictgen::InsensitiveStr::Ascii("ristic"),
    ],
    values: &[&["altruism"], &["altruistic"]],
    range: 4..=6,
};

static WORD_ALTR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ALTR_CHILDREN),
    value: None,
};

pub static WORD_ALTR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eady"),
        dictgen::InsensitiveStr::Ascii("iusm"),
        dictgen::InsensitiveStr::Ascii("iustic"),
        dictgen::InsensitiveStr::Ascii("uisim"),
        dictgen::InsensitiveStr::Ascii("uisitc"),
        dictgen::InsensitiveStr::Ascii("uisitic"),
        dictgen::InsensitiveStr::Ascii("uistisch"),
        dictgen::InsensitiveStr::Ascii("uistric"),
        dictgen::InsensitiveStr::Ascii("usim"),
        dictgen::InsensitiveStr::Ascii("usitic"),
    ],
    values: &[
        &["already"],
        &["altruism"],
        &["altruistic"],
        &["altruism"],
        &["altruistic"],
        &["altruistic"],
        &["altruistic"],
        &["altruistic"],
        &["altruism"],
        &["altruistic"],
    ],
    range: 4..=8,
};

static WORD_ALTO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ALTO_CHILDREN),
    value: None,
};

pub static WORD_ALTO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("gehter"),
        dictgen::InsensitiveStr::Ascii("gheter"),
        dictgen::InsensitiveStr::Ascii("ugh"),
        dictgen::InsensitiveStr::Ascii("ught"),
    ],
    values: &[
        &["altogether"],
        &["altogether"],
        &["although"],
        &["although"],
    ],
    range: 3..=6,
};

static WORD_ALTN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ALTN_CHILDREN),
    value: None,
};

pub static WORD_ALTN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("erately")],
    values: &[&["alternately"]],
    range: 7..=7,
};

static WORD_ALTI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ALTI_CHILDREN),
    value: None,
};

pub static WORD_ALTI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("tide"),
        dictgen::InsensitiveStr::Ascii("tute"),
    ],
    values: &[&["altitude"], &["altitude"]],
    range: 4..=4,
};

static WORD_ALTH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ALTH_CHILDREN),
    value: None,
};

pub static WORD_ALTH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("etes"),
        dictgen::InsensitiveStr::Ascii("etic"),
        dictgen::InsensitiveStr::Ascii("eticism"),
        dictgen::InsensitiveStr::Ascii("etics"),
        dictgen::InsensitiveStr::Ascii("ogh"),
        dictgen::InsensitiveStr::Ascii("oguh"),
        dictgen::InsensitiveStr::Ascii("orithm"),
        dictgen::InsensitiveStr::Ascii("orithmic"),
        dictgen::InsensitiveStr::Ascii("orithmically"),
        dictgen::InsensitiveStr::Ascii("orithms"),
        dictgen::InsensitiveStr::Ascii("oug"),
        dictgen::InsensitiveStr::Ascii("ought"),
        dictgen::InsensitiveStr::Ascii("ougth"),
        dictgen::InsensitiveStr::Ascii("outh"),
    ],
    values: &[
        &["athletes"],
        &["athletic"],
        &["athleticism"],
        &["athletics"],
        &["although"],
        &["although"],
        &["algorithm"],
        &["algorithmic"],
        &["algorithmically"],
        &["algorithms"],
        &["although"],
        &["although"],
        &["although"],
        &["although"],
    ],
    range: 3..=12,
};

static WORD_ALTE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ALTE_CHILDREN),
    value: None,
};

pub static WORD_ALTE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ast"),
        dictgen::InsensitiveStr::Ascii("nate"),
        dictgen::InsensitiveStr::Ascii("native"),
        dictgen::InsensitiveStr::Ascii("racion"),
        dictgen::InsensitiveStr::Ascii("rante"),
        dictgen::InsensitiveStr::Ascii("rantive"),
        dictgen::InsensitiveStr::Ascii("rantively"),
        dictgen::InsensitiveStr::Ascii("rantives"),
        dictgen::InsensitiveStr::Ascii("rarion"),
        dictgen::InsensitiveStr::Ascii("rated"),
        dictgen::InsensitiveStr::Ascii("rately"),
        dictgen::InsensitiveStr::Ascii("rating"),
        dictgen::InsensitiveStr::Ascii("rative"),
        dictgen::InsensitiveStr::Ascii("ratively"),
        dictgen::InsensitiveStr::Ascii("ratives"),
        dictgen::InsensitiveStr::Ascii("rato"),
        dictgen::InsensitiveStr::Ascii("rior"),
        dictgen::InsensitiveStr::Ascii("rnador"),
        dictgen::InsensitiveStr::Ascii("rnaive"),
        dictgen::InsensitiveStr::Ascii("rnaively"),
        dictgen::InsensitiveStr::Ascii("rnaives"),
        dictgen::InsensitiveStr::Ascii("rnar"),
        dictgen::InsensitiveStr::Ascii("rnarive"),
        dictgen::InsensitiveStr::Ascii("rnarively"),
        dictgen::InsensitiveStr::Ascii("rnarives"),
        dictgen::InsensitiveStr::Ascii("rnater"),
        dictgen::InsensitiveStr::Ascii("rnatevly"),
        dictgen::InsensitiveStr::Ascii("rnatie"),
        dictgen::InsensitiveStr::Ascii("rnatiely"),
        dictgen::InsensitiveStr::Ascii("rnaties"),
        dictgen::InsensitiveStr::Ascii("rnatieve"),
        dictgen::InsensitiveStr::Ascii("rnatievly"),
        dictgen::InsensitiveStr::Ascii("rnativelly"),
        dictgen::InsensitiveStr::Ascii("rnativets"),
        dictgen::InsensitiveStr::Ascii("rnativey"),
        dictgen::InsensitiveStr::Ascii("rnativley"),
        dictgen::InsensitiveStr::Ascii("rnativly"),
        dictgen::InsensitiveStr::Ascii("rnativos"),
        dictgen::InsensitiveStr::Ascii("rnatley"),
        dictgen::InsensitiveStr::Ascii("rnatly"),
        dictgen::InsensitiveStr::Ascii("rnatr"),
        dictgen::InsensitiveStr::Ascii("rnatve"),
        dictgen::InsensitiveStr::Ascii("rnatvely"),
        dictgen::InsensitiveStr::Ascii("rnavtely"),
        dictgen::InsensitiveStr::Ascii("rnavtive"),
        dictgen::InsensitiveStr::Ascii("rnavtively"),
        dictgen::InsensitiveStr::Ascii("rnavtives"),
        dictgen::InsensitiveStr::Ascii("rnetive"),
        dictgen::InsensitiveStr::Ascii("rnetively"),
        dictgen::InsensitiveStr::Ascii("rnetives"),
        dictgen::InsensitiveStr::Ascii("rnetly"),
        dictgen::InsensitiveStr::Ascii("rnitavely"),
        dictgen::InsensitiveStr::Ascii("rnitive"),
        dictgen::InsensitiveStr::Ascii("rnitively"),
        dictgen::InsensitiveStr::Ascii("rnitiveness"),
        dictgen::InsensitiveStr::Ascii("rnitives"),
        dictgen::InsensitiveStr::Ascii("rnitivly"),
        dictgen::InsensitiveStr::Ascii("tnative"),
        dictgen::InsensitiveStr::Ascii("tnatively"),
        dictgen::InsensitiveStr::Ascii("tnatives"),
    ],
    values: &[
        &["atleast"],
        &["alternate"],
        &["alternative"],
        &["alteration"],
        &["alternate"],
        &["alternative"],
        &["alternatively"],
        &["alternatives"],
        &["alteration"],
        &["altered"],
        &["alternately"],
        &["alteration"],
        &["alternative"],
        &["alternatively"],
        &["alternatives"],
        &["alteration"],
        &["ulterior"],
        &["alternator"],
        &["alternative"],
        &["alternatively"],
        &["alternatives"],
        &["alternator"],
        &["alternative"],
        &["alternatively"],
        &["alternatives"],
        &["alternator"],
        &["alternately"],
        &["alternatives", "alternate", "alternative"],
        &["alternately", "alternatively"],
        &["alternates", "alternatives"],
        &["alternative"],
        &["alternatively"],
        &["alternatively"],
        &["alternatives"],
        &["alternatively"],
        &["alternatively"],
        &["alternatively"],
        &["alternatives"],
        &["alternately"],
        &["alternately"],
        &["alternator"],
        &["alternate", "alternative"],
        &["alternately"],
        &["alternatively"],
        &["alternative"],
        &["alternatively"],
        &["alternatives"],
        &["alternative"],
        &["alternatively"],
        &["alternatives"],
        &["alternately"],
        &["alternatively"],
        &["alternative"],
        &["alternatively"],
        &["alternativeness"],
        &["alternatives"],
        &["alternatively"],
        &["alternative"],
        &["alternatively"],
        &["alternatives"],
    ],
    range: 3..=11,
};

static WORD_ALTA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ALTA_CHILDREN),
    value: None,
};

pub static WORD_ALTA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("nta"),
        dictgen::InsensitiveStr::Ascii("ntic"),
    ],
    values: &[&["atlanta"], &["atlantic"]],
    range: 3..=4,
};

static WORD_ALS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ALS_CHILDREN),
    value: Some(&["also"]),
};

pub static WORD_ALS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("most"),
        dictgen::InsensitiveStr::Ascii("ot"),
        dictgen::InsensitiveStr::Ascii("ready"),
    ],
    values: &[
        &["else", "also", "false"],
        &["almost"],
        &["also"],
        &["already"],
    ],
    range: 1..=5,
};

static WORD_ALR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ALR_CHILDREN),
    value: None,
};

pub static WORD_ALR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ady"),
        dictgen::InsensitiveStr::Ascii("aedy"),
        dictgen::InsensitiveStr::Ascii("ead"),
        dictgen::InsensitiveStr::Ascii("eadh"),
        dictgen::InsensitiveStr::Ascii("eadly"),
        dictgen::InsensitiveStr::Ascii("eadt"),
        dictgen::InsensitiveStr::Ascii("easy"),
        dictgen::InsensitiveStr::Ascii("eay"),
        dictgen::InsensitiveStr::Ascii("eayd"),
        dictgen::InsensitiveStr::Ascii("eday"),
        dictgen::InsensitiveStr::Ascii("edy"),
        dictgen::InsensitiveStr::Ascii("eight"),
        dictgen::InsensitiveStr::Ascii("elady"),
        dictgen::InsensitiveStr::Ascii("ightey"),
        dictgen::InsensitiveStr::Ascii("ightly"),
        dictgen::InsensitiveStr::Ascii("ightty"),
        dictgen::InsensitiveStr::Ascii("ighy"),
        dictgen::InsensitiveStr::Ascii("igthy"),
        dictgen::InsensitiveStr::Ascii("ington"),
        dictgen::InsensitiveStr::Ascii("ms"),
        dictgen::InsensitiveStr::Ascii("ogithm"),
        dictgen::InsensitiveStr::Ascii("orythm"),
        dictgen::InsensitiveStr::Ascii("teady"),
    ],
    values: &[
        &["already"],
        &["already"],
        &["already"],
        &["already"],
        &["already"],
        &["already"],
        &["already"],
        &["already"],
        &["already"],
        &["already"],
        &["already"],
        &["alright"],
        &["already"],
        &["alrighty"],
        &["alrighty"],
        &["alrighty"],
        &["alrighty"],
        &["alrighty"],
        &["arlington"],
        &["alarms"],
        &["algorithm"],
        &["algorithm"],
        &["already"],
    ],
    range: 2..=6,
};

static WORD_ALP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ALP_CHILDREN),
    value: None,
};

pub static WORD_ALP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("abet"),
        dictgen::InsensitiveStr::Ascii("abetic"),
        dictgen::InsensitiveStr::Ascii("abetical"),
        dictgen::InsensitiveStr::Ascii("abets"),
        dictgen::InsensitiveStr::Ascii("ah"),
        dictgen::InsensitiveStr::Ascii("ahabetical"),
        dictgen::InsensitiveStr::Ascii("ahbet"),
        dictgen::InsensitiveStr::Ascii("ahbetically"),
        dictgen::InsensitiveStr::Ascii("h"),
        dictgen::InsensitiveStr::Ascii("habeast"),
        dictgen::InsensitiveStr::Ascii("habeat"),
        dictgen::InsensitiveStr::Ascii("habeticaly"),
        dictgen::InsensitiveStr::Ascii("habeticly"),
        dictgen::InsensitiveStr::Ascii("habt"),
        dictgen::InsensitiveStr::Ascii("hapeicall"),
        dictgen::InsensitiveStr::Ascii("hapeticaly"),
    ],
    values: &[
        &["alphabet"],
        &["alphabetic"],
        &["alphabetical"],
        &["alphabets"],
        &["alpha"],
        &["alphabetical"],
        &["alphabet"],
        &["alphabetically"],
        &["alpha"],
        &["alphabet"],
        &["alphabet"],
        &["alphabetically"],
        &["alphabetical"],
        &["alphabet"],
        &["alphabetical"],
        &["alphabetically"],
    ],
    range: 1..=11,
};

static WORD_ALO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ALO_CHILDREN),
    value: Some(&["also"]),
};

pub static WORD_ALO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("able"),
        dictgen::InsensitiveStr::Ascii("catable"),
        dictgen::InsensitiveStr::Ascii("cate"),
        dictgen::InsensitiveStr::Ascii("cated"),
        dictgen::InsensitiveStr::Ascii("cates"),
        dictgen::InsensitiveStr::Ascii("cating"),
        dictgen::InsensitiveStr::Ascii("cation"),
        dictgen::InsensitiveStr::Ascii("cations"),
        dictgen::InsensitiveStr::Ascii("chol"),
        dictgen::InsensitiveStr::Ascii("cholic"),
        dictgen::InsensitiveStr::Ascii("cholics"),
        dictgen::InsensitiveStr::Ascii("cholism"),
        dictgen::InsensitiveStr::Ascii("g"),
        dictgen::InsensitiveStr::Ascii("girhtm"),
        dictgen::InsensitiveStr::Ascii("girhtmic"),
        dictgen::InsensitiveStr::Ascii("girhtmically"),
        dictgen::InsensitiveStr::Ascii("girhtms"),
        dictgen::InsensitiveStr::Ascii("girthm"),
        dictgen::InsensitiveStr::Ascii("girthmic"),
        dictgen::InsensitiveStr::Ascii("girthmically"),
        dictgen::InsensitiveStr::Ascii("girthms"),
        dictgen::InsensitiveStr::Ascii("gned"),
        dictgen::InsensitiveStr::Ascii("gorithm"),
        dictgen::InsensitiveStr::Ascii("gorithms"),
        dictgen::InsensitiveStr::Ascii("grithm"),
        dictgen::InsensitiveStr::Ascii("grithmic"),
        dictgen::InsensitiveStr::Ascii("grithmically"),
        dictgen::InsensitiveStr::Ascii("grithms"),
        dictgen::InsensitiveStr::Ascii("mst"),
        dictgen::InsensitiveStr::Ascii("ows"),
        dictgen::InsensitiveStr::Ascii("rithm"),
        dictgen::InsensitiveStr::Ascii("s"),
        dictgen::InsensitiveStr::Ascii("tted"),
        dictgen::InsensitiveStr::Ascii("w"),
        dictgen::InsensitiveStr::Ascii("wed"),
        dictgen::InsensitiveStr::Ascii("wing"),
        dictgen::InsensitiveStr::Ascii("ws"),
    ],
    values: &[
        &["allowable", "available"],
        &["allocatable"],
        &["allocate"],
        &["allocated"],
        &["allocates"],
        &["allocating"],
        &["allocation"],
        &["allocations"],
        &["alcohol"],
        &["alcoholic"],
        &["alcoholics"],
        &["alcoholism"],
        &["along"],
        &["algorithm"],
        &["algorithmic"],
        &["algorithmically"],
        &["algorithms"],
        &["algorithm"],
        &["algorithmic"],
        &["algorithmically"],
        &["algorithms"],
        &["aligned"],
        &["algorithm"],
        &["algorithms"],
        &["algorithm"],
        &["algorithmic"],
        &["algorithmically"],
        &["algorithms"],
        &["almost"],
        &["allows"],
        &["algorithm"],
        &["also"],
        &["allotted"],
        &["allow"],
        &["allowed"],
        &["allowing"],
        &["allows"],
    ],
    range: 1..=12,
};

static WORD_ALM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ALM_CHILDREN),
    value: None,
};

pub static WORD_ALM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ightly"),
        dictgen::InsensitiveStr::Ascii("ighy"),
        dictgen::InsensitiveStr::Ascii("igthy"),
        dictgen::InsensitiveStr::Ascii("oast"),
        dictgen::InsensitiveStr::Ascii("ostly"),
        dictgen::InsensitiveStr::Ascii("sot"),
    ],
    values: &[
        &["almighty"],
        &["almighty"],
        &["almighty"],
        &["almost"],
        &["almost"],
        &["almost"],
    ],
    range: 3..=6,
};

static WORD_ALL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_ALL_CHILDREN),
    value: None,
};

static WORD_ALL_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_ALLA_NODE),
    None,
    Some(&WORD_ALLC_NODE),
    None,
    Some(&WORD_ALLE_NODE),
    None,
    None,
    None,
    Some(&WORD_ALLI_NODE),
    None,
    Some(&WORD_ALLK_NODE),
    Some(&WORD_ALLL_NODE),
    Some(&WORD_ALLM_NODE),
    None,
    Some(&WORD_ALLO_NODE),
    Some(&WORD_ALLP_NODE),
    None,
    Some(&WORD_ALLR_NODE),
    Some(&WORD_ALLS_NODE),
    Some(&WORD_ALLT_NODE),
    None,
    None,
    Some(&WORD_ALLW_NODE),
    None,
    None,
    None,
];

static WORD_ALLW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ALLW_CHILDREN),
    value: None,
};

pub static WORD_ALLW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ays"),
        dictgen::InsensitiveStr::Ascii("o"),
        dictgen::InsensitiveStr::Ascii("os"),
        dictgen::InsensitiveStr::Ascii("s"),
        dictgen::InsensitiveStr::Ascii("ys"),
    ],
    values: &[
        &["always"],
        &["allow"],
        &["allows"],
        &["allows"],
        &["always"],
    ],
    range: 1..=3,
};

static WORD_ALLT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ALLT_CHILDREN),
    value: None,
};

pub static WORD_ALLT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("hough"),
        dictgen::InsensitiveStr::Ascii("ogeher"),
        dictgen::InsensitiveStr::Ascii("ogehter"),
        dictgen::InsensitiveStr::Ascii("ogether"),
        dictgen::InsensitiveStr::Ascii("ogetrher"),
        dictgen::InsensitiveStr::Ascii("ogther"),
        dictgen::InsensitiveStr::Ascii("ough"),
    ],
    values: &[
        &["although"],
        &["altogether"],
        &["altogether"],
        &["altogether"],
        &["altogether"],
        &["altogether"],
        &["although"],
    ],
    range: 4..=8,
};

static WORD_ALLS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ALLS_CHILDREN),
    value: Some(&["all", "falls"]),
};

pub static WORD_ALLS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("o")],
    values: &[&["also"]],
    range: 1..=1,
};

static WORD_ALLR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ALLR_CHILDREN),
    value: None,
};

pub static WORD_ALLR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eady"),
        dictgen::InsensitiveStr::Ascii("edy"),
        dictgen::InsensitiveStr::Ascii("eight"),
        dictgen::InsensitiveStr::Ascii("ight"),
    ],
    values: &[&["already"], &["already"], &["alright"], &["alright"]],
    range: 3..=5,
};

static WORD_ALLP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ALLP_CHILDREN),
    value: None,
};

pub static WORD_ALLP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ication"),
        dictgen::InsensitiveStr::Ascii("ications"),
    ],
    values: &[&["application"], &["applications"]],
    range: 7..=8,
};

static WORD_ALLO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ALLO_CHILDREN),
    value: Some(&["allow"]),
};

pub static WORD_ALLO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("acate"),
        dictgen::InsensitiveStr::Ascii("ate"),
        dictgen::InsensitiveStr::Ascii("ated"),
        dictgen::InsensitiveStr::Ascii("cae"),
        dictgen::InsensitiveStr::Ascii("caed"),
        dictgen::InsensitiveStr::Ascii("caes"),
        dictgen::InsensitiveStr::Ascii("cagtor"),
        dictgen::InsensitiveStr::Ascii("caiing"),
        dictgen::InsensitiveStr::Ascii("caing"),
        dictgen::InsensitiveStr::Ascii("caion"),
        dictgen::InsensitiveStr::Ascii("caions"),
        dictgen::InsensitiveStr::Ascii("caite"),
        dictgen::InsensitiveStr::Ascii("caites"),
        dictgen::InsensitiveStr::Ascii("caiting"),
        dictgen::InsensitiveStr::Ascii("caition"),
        dictgen::InsensitiveStr::Ascii("caitions"),
        dictgen::InsensitiveStr::Ascii("caiton"),
        dictgen::InsensitiveStr::Ascii("caitons"),
        dictgen::InsensitiveStr::Ascii("cal"),
        dictgen::InsensitiveStr::Ascii("carion"),
        dictgen::InsensitiveStr::Ascii("cat"),
        dictgen::InsensitiveStr::Ascii("catbale"),
        dictgen::InsensitiveStr::Ascii("catedi"),
        dictgen::InsensitiveStr::Ascii("catedp"),
        dictgen::InsensitiveStr::Ascii("cateing"),
        dictgen::InsensitiveStr::Ascii("cateng"),
        dictgen::InsensitiveStr::Ascii("cationg"),
        dictgen::InsensitiveStr::Ascii("caton"),
        dictgen::InsensitiveStr::Ascii("catoor"),
        dictgen::InsensitiveStr::Ascii("catote"),
        dictgen::InsensitiveStr::Ascii("catrd"),
        dictgen::InsensitiveStr::Ascii("cattion"),
        dictgen::InsensitiveStr::Ascii("ccate"),
        dictgen::InsensitiveStr::Ascii("ccated"),
        dictgen::InsensitiveStr::Ascii("ccates"),
        dictgen::InsensitiveStr::Ascii("ccating"),
        dictgen::InsensitiveStr::Ascii("ced"),
        dictgen::InsensitiveStr::Ascii("co"),
        dictgen::InsensitiveStr::Ascii("cos"),
        dictgen::InsensitiveStr::Ascii("cte"),
        dictgen::InsensitiveStr::Ascii("cted"),
        dictgen::InsensitiveStr::Ascii("cting"),
        dictgen::InsensitiveStr::Ascii("ction"),
        dictgen::InsensitiveStr::Ascii("ctions"),
        dictgen::InsensitiveStr::Ascii("ctor"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("ews"),
        dictgen::InsensitiveStr::Ascii("ne"),
        dictgen::InsensitiveStr::Ascii("ng"),
        dictgen::InsensitiveStr::Ascii("ocates"),
        dictgen::InsensitiveStr::Ascii("pone"),
        dictgen::InsensitiveStr::Ascii("pones"),
        dictgen::InsensitiveStr::Ascii("s"),
        dictgen::InsensitiveStr::Ascii("ted"),
        dictgen::InsensitiveStr::Ascii("ud"),
        dictgen::InsensitiveStr::Ascii("wd"),
        dictgen::InsensitiveStr::Ascii("we"),
        dictgen::InsensitiveStr::Ascii("wence"),
        dictgen::InsensitiveStr::Ascii("wences"),
        dictgen::InsensitiveStr::Ascii("wes"),
    ],
    values: &[
        &["allocate"],
        &["allocate", "allotted", "allot"],
        &["allocated", "allotted"],
        &["allocate"],
        &["allocated"],
        &["allocates"],
        &["allocator"],
        &["allocating"],
        &["allocating"],
        &["allocation"],
        &["allocations"],
        &["allocate"],
        &["allocates"],
        &["allocating"],
        &["allocation"],
        &["allocations"],
        &["allocation"],
        &["allocations"],
        &["allocate"],
        &["allocation"],
        &["allocate"],
        &["allocatable"],
        &["allocated"],
        &["allocated"],
        &["allocating"],
        &["allocating"],
        &["allocating", "allocation"],
        &["allocation"],
        &["allocator"],
        &["allocate"],
        &["allocated"],
        &["allocation"],
        &["allocate"],
        &["allocated"],
        &["allocates"],
        &["allocating"],
        &["allocated"],
        &["alloc"],
        &["allocs"],
        &["allocate"],
        &["allocated"],
        &["allocating"],
        &["allocation"],
        &["allocations"],
        &["allocator"],
        &["allowed", "aloud"],
        &["allows"],
        &["alone"],
        &["along"],
        &["allocates"],
        &["allophone"],
        &["allophones"],
        &["allows"],
        &["allotted"],
        &["aloud", "allowed"],
        &["allowed", "allow", "allows"],
        &["allowed", "allow", "allows"],
        &["allowance"],
        &["allowances"],
        &["allowed", "allows"],
    ],
    range: 1..=8,
};

static WORD_ALLM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ALLM_CHILDREN),
    value: None,
};

pub static WORD_ALLM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ost")],
    values: &[&["almost"]],
    range: 3..=3,
};

static WORD_ALLL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ALLL_CHILDREN),
    value: None,
};

pub static WORD_ALLL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ocate"),
        dictgen::InsensitiveStr::Ascii("ocation"),
        dictgen::InsensitiveStr::Ascii("ow"),
        dictgen::InsensitiveStr::Ascii("owed"),
        dictgen::InsensitiveStr::Ascii("ows"),
    ],
    values: &[
        &["allocate"],
        &["allocation"],
        &["allow"],
        &["allowed"],
        &["allows"],
    ],
    range: 2..=7,
};

static WORD_ALLK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ALLK_CHILDREN),
    value: Some(&["all"]),
};

pub static WORD_ALLK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[],
    values: &[],
    range: 0..=0,
};

static WORD_ALLI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ALLI_CHILDREN),
    value: None,
};

pub static WORD_ALLI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("anse"),
        dictgen::InsensitiveStr::Ascii("egance"),
        dictgen::InsensitiveStr::Ascii("evate"),
        dictgen::InsensitiveStr::Ascii("geance"),
        dictgen::InsensitiveStr::Ascii("gn"),
        dictgen::InsensitiveStr::Ascii("gned"),
        dictgen::InsensitiveStr::Ascii("gnement"),
        dictgen::InsensitiveStr::Ascii("gnemnt"),
        dictgen::InsensitiveStr::Ascii("gning"),
        dictgen::InsensitiveStr::Ascii("gnment"),
        dictgen::InsensitiveStr::Ascii("gnmenterror"),
        dictgen::InsensitiveStr::Ascii("gnments"),
        dictgen::InsensitiveStr::Ascii("gns"),
        dictgen::InsensitiveStr::Ascii("nace"),
        dictgen::InsensitiveStr::Ascii("viate"),
    ],
    values: &[
        &["alliances"],
        &["allegiance"],
        &["alleviate"],
        &["allegiance"],
        &["align"],
        &["aligned"],
        &["alignment"],
        &["alignment"],
        &["aligning"],
        &["alignment"],
        &["alignmenterror"],
        &["alignments"],
        &["aligns"],
        &["alliance"],
        &["alleviate"],
    ],
    range: 2..=11,
};

static WORD_ALLE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ALLE_CHILDREN),
    value: Some(&["all", "alley"]),
};

pub static WORD_ALLE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("d"),
        dictgen::InsensitiveStr::Ascii("dge"),
        dictgen::InsensitiveStr::Ascii("dged"),
        dictgen::InsensitiveStr::Ascii("dgedly"),
        dictgen::InsensitiveStr::Ascii("dgely"),
        dictgen::InsensitiveStr::Ascii("dges"),
        dictgen::InsensitiveStr::Ascii("geance"),
        dictgen::InsensitiveStr::Ascii("gedely"),
        dictgen::InsensitiveStr::Ascii("gedley"),
        dictgen::InsensitiveStr::Ascii("gedy"),
        dictgen::InsensitiveStr::Ascii("gely"),
        dictgen::InsensitiveStr::Ascii("gence"),
        dictgen::InsensitiveStr::Ascii("giancies"),
        dictgen::InsensitiveStr::Ascii("gience"),
        dictgen::InsensitiveStr::Ascii("gric"),
        dictgen::InsensitiveStr::Ascii("gry"),
        dictgen::InsensitiveStr::Ascii("igance"),
        dictgen::InsensitiveStr::Ascii("igances"),
        dictgen::InsensitiveStr::Ascii("ivate"),
        dictgen::InsensitiveStr::Ascii("rgey"),
        dictgen::InsensitiveStr::Ascii("rgisch"),
    ],
    values: &[
        &["called", "allied"],
        &["allege"],
        &["alleged"],
        &["allegedly"],
        &["allegedly"],
        &["alleges"],
        &["allegiance"],
        &["allegedly"],
        &["allegedly"],
        &["allegedly"],
        &["allegedly"],
        &["allegiance"],
        &["allegiance"],
        &["allegiance"],
        &["allergic"],
        &["allergy"],
        &["allegiance"],
        &["allegiance"],
        &["alleviate"],
        &["allergy"],
        &["allergic"],
    ],
    range: 1..=8,
};

static WORD_ALLC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ALLC_CHILDREN),
    value: None,
};

pub static WORD_ALLC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ate"),
        dictgen::InsensitiveStr::Ascii("ateing"),
        dictgen::InsensitiveStr::Ascii("ater"),
        dictgen::InsensitiveStr::Ascii("aters"),
        dictgen::InsensitiveStr::Ascii("ating"),
        dictgen::InsensitiveStr::Ascii("ation"),
        dictgen::InsensitiveStr::Ascii("ator"),
        dictgen::InsensitiveStr::Ascii("oate"),
        dictgen::InsensitiveStr::Ascii("oated"),
        dictgen::InsensitiveStr::Ascii("oateing"),
        dictgen::InsensitiveStr::Ascii("oateng"),
        dictgen::InsensitiveStr::Ascii("oater"),
        dictgen::InsensitiveStr::Ascii("oaters"),
        dictgen::InsensitiveStr::Ascii("oating"),
        dictgen::InsensitiveStr::Ascii("oation"),
        dictgen::InsensitiveStr::Ascii("oator"),
        dictgen::InsensitiveStr::Ascii("oators"),
        dictgen::InsensitiveStr::Ascii("ommnads"),
    ],
    values: &[
        &["allocate"],
        &["allocating"],
        &["allocator"],
        &["allocators"],
        &["allocating"],
        &["allocation"],
        &["allocator"],
        &["allocate"],
        &["allocated"],
        &["allocating"],
        &["allocating"],
        &["allocator"],
        &["allocators"],
        &["allocating"],
        &["allocation"],
        &["allocator"],
        &["allocators"],
        &["allcommands"],
    ],
    range: 3..=7,
};

static WORD_ALLA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ALLA_CHILDREN),
    value: None,
};

pub static WORD_ALLA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ince"),
        dictgen::InsensitiveStr::Ascii("inces"),
    ],
    values: &[&["alliance"], &["alliances"]],
    range: 4..=5,
};

static WORD_ALI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ALI_CHILDREN),
    value: None,
};

pub static WORD_ALI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("agn"),
        dictgen::InsensitiveStr::Ascii("asas"),
        dictgen::InsensitiveStr::Ascii("ase"),
        dictgen::InsensitiveStr::Ascii("asses"),
        dictgen::InsensitiveStr::Ascii("enet"),
        dictgen::InsensitiveStr::Ascii("entating"),
        dictgen::InsensitiveStr::Ascii("evating"),
        dictgen::InsensitiveStr::Ascii("ged"),
        dictgen::InsensitiveStr::Ascii("ghed"),
        dictgen::InsensitiveStr::Ascii("ghned"),
        dictgen::InsensitiveStr::Ascii("ghnment"),
        dictgen::InsensitiveStr::Ascii("gin"),
        dictgen::InsensitiveStr::Ascii("gined"),
        dictgen::InsensitiveStr::Ascii("gining"),
        dictgen::InsensitiveStr::Ascii("ginment"),
        dictgen::InsensitiveStr::Ascii("gins"),
        dictgen::InsensitiveStr::Ascii("gment"),
        dictgen::InsensitiveStr::Ascii("gments"),
        dictgen::InsensitiveStr::Ascii("gnation"),
        dictgen::InsensitiveStr::Ascii("gnd"),
        dictgen::InsensitiveStr::Ascii("gne"),
        dictgen::InsensitiveStr::Ascii("gnement"),
        dictgen::InsensitiveStr::Ascii("gnemnt"),
        dictgen::InsensitiveStr::Ascii("gnemnts"),
        dictgen::InsensitiveStr::Ascii("gnemt"),
        dictgen::InsensitiveStr::Ascii("gnes"),
        dictgen::InsensitiveStr::Ascii("gnmant"),
        dictgen::InsensitiveStr::Ascii("gnmeent"),
        dictgen::InsensitiveStr::Ascii("gnmen"),
        dictgen::InsensitiveStr::Ascii("gnmenet"),
        dictgen::InsensitiveStr::Ascii("gnmenets"),
        dictgen::InsensitiveStr::Ascii("gnmet"),
        dictgen::InsensitiveStr::Ascii("gnmets"),
        dictgen::InsensitiveStr::Ascii("gnmment"),
        dictgen::InsensitiveStr::Ascii("gnmments"),
        dictgen::InsensitiveStr::Ascii("gnmnet"),
        dictgen::InsensitiveStr::Ascii("gnmnt"),
        dictgen::InsensitiveStr::Ascii("gnrigh"),
        dictgen::InsensitiveStr::Ascii("kes"),
        dictgen::InsensitiveStr::Ascii("money"),
        dictgen::InsensitiveStr::Ascii("munium"),
        dictgen::InsensitiveStr::Ascii("ng"),
        dictgen::InsensitiveStr::Ascii("nged"),
        dictgen::InsensitiveStr::Ascii("nging"),
        dictgen::InsensitiveStr::Ascii("ngment"),
        dictgen::InsensitiveStr::Ascii("ngs"),
        dictgen::InsensitiveStr::Ascii("nment"),
        dictgen::InsensitiveStr::Ascii("nments"),
        dictgen::InsensitiveStr::Ascii("rghty"),
        dictgen::InsensitiveStr::Ascii("s"),
        dictgen::InsensitiveStr::Ascii("sas"),
        dictgen::InsensitiveStr::Ascii("sed"),
        dictgen::InsensitiveStr::Ascii("sing"),
        dictgen::InsensitiveStr::Ascii("ver"),
    ],
    values: &[
        &["align"],
        &["aliases"],
        &["aliases", "alias"],
        &["aliases"],
        &["alienate"],
        &["alienating"],
        &["alienating"],
        &["aligned"],
        &["aligned", "alighted"],
        &["aligned"],
        &["alignment"],
        &["align"],
        &["aligned"],
        &["aligning"],
        &["alignment"],
        &["aligns"],
        &["alignment"],
        &["alignments"],
        &["alignment"],
        &["aligned"],
        &["align"],
        &["alignment"],
        &["alignment"],
        &["alignments"],
        &["alignment"],
        &["aligns"],
        &["alignment"],
        &["alignment"],
        &["alignment"],
        &["alignment"],
        &["alignments"],
        &["alignment"],
        &["alignments"],
        &["alignment"],
        &["alignments"],
        &["alignment"],
        &["alignment"],
        &["alignright"],
        &["alike", "likes"],
        &["alimony"],
        &["aluminium"],
        &["aline", "along", "ailing", "sling"],
        &["alined"],
        &["aligning"],
        &["alinement"],
        &["alines", "slings"],
        &["alignment"],
        &["alignments"],
        &["alrighty"],
        &["alas", "alias", "alms", "axis"],
        &["alias", "aliases"],
        &["aliased"],
        &["aliasing"],
        &["alive", "liver", "sliver"],
    ],
    range: 1..=8,
};

static WORD_ALH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ALH_CHILDREN),
    value: None,
};

pub static WORD_ALH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("a"),
        dictgen::InsensitiveStr::Ascii("abet"),
        dictgen::InsensitiveStr::Ascii("abetical"),
        dictgen::InsensitiveStr::Ascii("abetically"),
        dictgen::InsensitiveStr::Ascii("abeticaly"),
        dictgen::InsensitiveStr::Ascii("abets"),
        dictgen::InsensitiveStr::Ascii("apet"),
        dictgen::InsensitiveStr::Ascii("apetical"),
        dictgen::InsensitiveStr::Ascii("apetically"),
        dictgen::InsensitiveStr::Ascii("apeticaly"),
        dictgen::InsensitiveStr::Ascii("apets"),
        dictgen::InsensitiveStr::Ascii("ough"),
        dictgen::InsensitiveStr::Ascii("pa"),
        dictgen::InsensitiveStr::Ascii("pabet"),
        dictgen::InsensitiveStr::Ascii("pabetical"),
        dictgen::InsensitiveStr::Ascii("pabetically"),
        dictgen::InsensitiveStr::Ascii("pabeticaly"),
        dictgen::InsensitiveStr::Ascii("pabets"),
    ],
    values: &[
        &["alpha"],
        &["alphabet"],
        &["alphabetical"],
        &["alphabetically"],
        &["alphabetically"],
        &["alphabets"],
        &["alphabet"],
        &["alphabetical"],
        &["alphabetically"],
        &["alphabetically"],
        &["alphabets"],
        &["although"],
        &["alpha"],
        &["alphabet"],
        &["alphabetical"],
        &["alphabetically"],
        &["alphabetically"],
        &["alphabets"],
    ],
    range: 1..=11,
};

static WORD_ALG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_ALG_CHILDREN),
    value: None,
};

static WORD_ALG_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    None,
    None,
    Some(&WORD_ALGE_NODE),
    None,
    None,
    Some(&WORD_ALGH_NODE),
    Some(&WORD_ALGI_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_ALGO_NODE),
    None,
    None,
    Some(&WORD_ALGR_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_ALGR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ALGR_CHILDREN),
    value: None,
};

pub static WORD_ALGR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ithm")],
    values: &[&["algorithm"]],
    range: 4..=4,
};

static WORD_ALGO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_ALGO_CHILDREN),
    value: None,
};

static WORD_ALGO_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_ALGOH_NODE),
    Some(&WORD_ALGOI_NODE),
    None,
    None,
    Some(&WORD_ALGOL_NODE),
    None,
    None,
    Some(&WORD_ALGOO_NODE),
    Some(&WORD_ALGOP_NODE),
    None,
    Some(&WORD_ALGOR_NODE),
    None,
    Some(&WORD_ALGOT_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_ALGOT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ALGOT_CHILDREN),
    value: None,
};

pub static WORD_ALGOT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("hitm"),
        dictgen::InsensitiveStr::Ascii("hitmic"),
        dictgen::InsensitiveStr::Ascii("hitmically"),
        dictgen::InsensitiveStr::Ascii("hitms"),
        dictgen::InsensitiveStr::Ascii("ighm"),
        dictgen::InsensitiveStr::Ascii("ighmic"),
        dictgen::InsensitiveStr::Ascii("ighmically"),
        dictgen::InsensitiveStr::Ascii("ighms"),
        dictgen::InsensitiveStr::Ascii("ihm"),
        dictgen::InsensitiveStr::Ascii("ihmic"),
        dictgen::InsensitiveStr::Ascii("ihmically"),
        dictgen::InsensitiveStr::Ascii("ihms"),
        dictgen::InsensitiveStr::Ascii("irhm"),
        dictgen::InsensitiveStr::Ascii("irhmic"),
        dictgen::InsensitiveStr::Ascii("irhmically"),
        dictgen::InsensitiveStr::Ascii("irhms"),
        dictgen::InsensitiveStr::Ascii("ithm"),
        dictgen::InsensitiveStr::Ascii("ithmic"),
        dictgen::InsensitiveStr::Ascii("ithmically"),
        dictgen::InsensitiveStr::Ascii("ithms"),
        dictgen::InsensitiveStr::Ascii("rithm"),
        dictgen::InsensitiveStr::Ascii("rithmic"),
        dictgen::InsensitiveStr::Ascii("rithmically"),
        dictgen::InsensitiveStr::Ascii("rithms"),
    ],
    values: &[
        &["algorithm"],
        &["algorithmic"],
        &["algorithmically"],
        &["algorithms"],
        &["algorithm"],
        &["algorithmic"],
        &["algorithmically"],
        &["algorithms"],
        &["algorithm"],
        &["algorithmic"],
        &["algorithmically"],
        &["algorithms"],
        &["algorithm"],
        &["algorithmic"],
        &["algorithmically"],
        &["algorithms"],
        &["algorithm"],
        &["algorithmic"],
        &["algorithmically"],
        &["algorithms"],
        &["algorithm"],
        &["algorithmic"],
        &["algorithmically"],
        &["algorithms"],
    ],
    range: 3..=11,
};

static WORD_ALGOR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_ALGOR_CHILDREN),
    value: None,
};

static WORD_ALGOR_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_ALGORG_NODE),
    Some(&WORD_ALGORH_NODE),
    Some(&WORD_ALGORI_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_ALGORO_NODE),
    None,
    None,
    Some(&WORD_ALGORR_NODE),
    None,
    Some(&WORD_ALGORT_NODE),
    Some(&WORD_ALGORU_NODE),
    None,
    Some(&WORD_ALGORW_NODE),
    None,
    Some(&WORD_ALGORY_NODE),
    None,
];

static WORD_ALGORY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ALGORY_CHILDREN),
    value: None,
};

pub static WORD_ALGORY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("them"),
        dictgen::InsensitiveStr::Ascii("themic"),
        dictgen::InsensitiveStr::Ascii("themically"),
        dictgen::InsensitiveStr::Ascii("thems"),
        dictgen::InsensitiveStr::Ascii("thims"),
        dictgen::InsensitiveStr::Ascii("thm"),
        dictgen::InsensitiveStr::Ascii("thmic"),
        dictgen::InsensitiveStr::Ascii("thmically"),
        dictgen::InsensitiveStr::Ascii("thms"),
    ],
    values: &[
        &["algorithm"],
        &["algorithmic"],
        &["algorithmically"],
        &["algorithms"],
        &["algorithms"],
        &["algorithm"],
        &["algorithmic"],
        &["algorithmically"],
        &["algorithms"],
    ],
    range: 3..=10,
};

static WORD_ALGORW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ALGORW_CHILDREN),
    value: None,
};

pub static WORD_ALGORW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("withm"),
        dictgen::InsensitiveStr::Ascii("withmic"),
        dictgen::InsensitiveStr::Ascii("withmically"),
        dictgen::InsensitiveStr::Ascii("withms"),
    ],
    values: &[
        &["algorithm"],
        &["algorithmic"],
        &["algorithmically"],
        &["algorithms"],
    ],
    range: 5..=11,
};

static WORD_ALGORU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ALGORU_CHILDREN),
    value: None,
};

pub static WORD_ALGORU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("thm"),
        dictgen::InsensitiveStr::Ascii("thmic"),
        dictgen::InsensitiveStr::Ascii("thmically"),
        dictgen::InsensitiveStr::Ascii("thms"),
    ],
    values: &[
        &["algorithm"],
        &["algorithmic"],
        &["algorithmically"],
        &["algorithms"],
    ],
    range: 3..=9,
};

static WORD_ALGORT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ALGORT_CHILDREN),
    value: None,
};

pub static WORD_ALGORT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("him"),
        dictgen::InsensitiveStr::Ascii("himic"),
        dictgen::InsensitiveStr::Ascii("himically"),
        dictgen::InsensitiveStr::Ascii("hims"),
        dictgen::InsensitiveStr::Ascii("hin"),
        dictgen::InsensitiveStr::Ascii("hinic"),
        dictgen::InsensitiveStr::Ascii("hinically"),
        dictgen::InsensitiveStr::Ascii("hins"),
        dictgen::InsensitiveStr::Ascii("hm"),
        dictgen::InsensitiveStr::Ascii("hmic"),
        dictgen::InsensitiveStr::Ascii("hmically"),
        dictgen::InsensitiveStr::Ascii("hms"),
        dictgen::InsensitiveStr::Ascii("hn"),
        dictgen::InsensitiveStr::Ascii("hnic"),
        dictgen::InsensitiveStr::Ascii("hnically"),
        dictgen::InsensitiveStr::Ascii("hns"),
        dictgen::InsensitiveStr::Ascii("hym"),
        dictgen::InsensitiveStr::Ascii("hymic"),
        dictgen::InsensitiveStr::Ascii("hymically"),
        dictgen::InsensitiveStr::Ascii("hyms"),
        dictgen::InsensitiveStr::Ascii("hyn"),
        dictgen::InsensitiveStr::Ascii("hynic"),
        dictgen::InsensitiveStr::Ascii("hynically"),
        dictgen::InsensitiveStr::Ascii("hyns"),
        dictgen::InsensitiveStr::Ascii("ihm"),
        dictgen::InsensitiveStr::Ascii("ihmic"),
        dictgen::InsensitiveStr::Ascii("ihmically"),
        dictgen::InsensitiveStr::Ascii("ihms"),
        dictgen::InsensitiveStr::Ascii("im"),
        dictgen::InsensitiveStr::Ascii("imic"),
        dictgen::InsensitiveStr::Ascii("imically"),
        dictgen::InsensitiveStr::Ascii("ims"),
        dictgen::InsensitiveStr::Ascii("ism"),
        dictgen::InsensitiveStr::Ascii("ismic"),
        dictgen::InsensitiveStr::Ascii("ismically"),
        dictgen::InsensitiveStr::Ascii("isms"),
        dictgen::InsensitiveStr::Ascii("ithm"),
        dictgen::InsensitiveStr::Ascii("ithmic"),
        dictgen::InsensitiveStr::Ascii("ithmically"),
        dictgen::InsensitiveStr::Ascii("ithms"),
    ],
    values: &[
        &["algorithm"],
        &["algorithmic"],
        &["algorithmically"],
        &["algorithms"],
        &["algorithm"],
        &["algorithmic"],
        &["algorithmically"],
        &["algorithms"],
        &["algorithm"],
        &["algorithmic"],
        &["algorithmically"],
        &["algorithms"],
        &["algorithm"],
        &["algorithmic"],
        &["algorithmically"],
        &["algorithms"],
        &["algorithm"],
        &["algorithmic"],
        &["algorithmically"],
        &["algorithms"],
        &["algorithm"],
        &["algorithmic"],
        &["algorithmically"],
        &["algorithms"],
        &["algorithm"],
        &["algorithmic"],
        &["algorithmically"],
        &["algorithms"],
        &["algorithm"],
        &["algorithmic"],
        &["algorithmically"],
        &["algorithms"],
        &["algorithm"],
        &["algorithmic"],
        &["algorithmically"],
        &["algorithms"],
        &["algorithm"],
        &["algorithmic"],
        &["algorithmically"],
        &["algorithms"],
    ],
    range: 2..=10,
};

static WORD_ALGORR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ALGORR_CHILDREN),
    value: None,
};

pub static WORD_ALGORR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ithm"),
        dictgen::InsensitiveStr::Ascii("ithmic"),
        dictgen::InsensitiveStr::Ascii("ithmically"),
        dictgen::InsensitiveStr::Ascii("ithms"),
        dictgen::InsensitiveStr::Ascii("itm"),
        dictgen::InsensitiveStr::Ascii("itmic"),
        dictgen::InsensitiveStr::Ascii("itmically"),
        dictgen::InsensitiveStr::Ascii("itms"),
    ],
    values: &[
        &["algorithm"],
        &["algorithmic"],
        &["algorithmically"],
        &["algorithms"],
        &["algorithm"],
        &["algorithmic"],
        &["algorithmically"],
        &["algorithms"],
    ],
    range: 3..=10,
};

static WORD_ALGORO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ALGORO_CHILDREN),
    value: None,
};

pub static WORD_ALGORO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ithm"),
        dictgen::InsensitiveStr::Ascii("ithmic"),
        dictgen::InsensitiveStr::Ascii("ithmically"),
        dictgen::InsensitiveStr::Ascii("ithms"),
        dictgen::InsensitiveStr::Ascii("rithm"),
        dictgen::InsensitiveStr::Ascii("rithmic"),
        dictgen::InsensitiveStr::Ascii("rithmically"),
        dictgen::InsensitiveStr::Ascii("rithms"),
        dictgen::InsensitiveStr::Ascii("thm"),
        dictgen::InsensitiveStr::Ascii("thmic"),
        dictgen::InsensitiveStr::Ascii("thmically"),
        dictgen::InsensitiveStr::Ascii("thms"),
    ],
    values: &[
        &["algorithm"],
        &["algorithmic"],
        &["algorithmically"],
        &["algorithms"],
        &["algorithm"],
        &["algorithmic"],
        &["algorithmically"],
        &["algorithms"],
        &["algorithm"],
        &["algorithmic"],
        &["algorithmically"],
        &["algorithms"],
    ],
    range: 3..=11,
};

static WORD_ALGORI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ALGORI_CHILDREN),
    value: None,
};

pub static WORD_ALGORI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ghtm"),
        dictgen::InsensitiveStr::Ascii("ghtmic"),
        dictgen::InsensitiveStr::Ascii("ghtmically"),
        dictgen::InsensitiveStr::Ascii("ghtms"),
        dictgen::InsensitiveStr::Ascii("hm"),
        dictgen::InsensitiveStr::Ascii("hmic"),
        dictgen::InsensitiveStr::Ascii("hmically"),
        dictgen::InsensitiveStr::Ascii("hms"),
        dictgen::InsensitiveStr::Ascii("htm"),
        dictgen::InsensitiveStr::Ascii("htmic"),
        dictgen::InsensitiveStr::Ascii("htmically"),
        dictgen::InsensitiveStr::Ascii("htms"),
        dictgen::InsensitiveStr::Ascii("sthm"),
        dictgen::InsensitiveStr::Ascii("sthms"),
        dictgen::InsensitiveStr::Ascii("th"),
        dictgen::InsensitiveStr::Ascii("them"),
        dictgen::InsensitiveStr::Ascii("themic"),
        dictgen::InsensitiveStr::Ascii("themically"),
        dictgen::InsensitiveStr::Ascii("thems"),
        dictgen::InsensitiveStr::Ascii("thic"),
        dictgen::InsensitiveStr::Ascii("thically"),
        dictgen::InsensitiveStr::Ascii("thim"),
        dictgen::InsensitiveStr::Ascii("thimes"),
        dictgen::InsensitiveStr::Ascii("thimic"),
        dictgen::InsensitiveStr::Ascii("thimical"),
        dictgen::InsensitiveStr::Ascii("thimically"),
        dictgen::InsensitiveStr::Ascii("thims"),
        dictgen::InsensitiveStr::Ascii("thmes"),
        dictgen::InsensitiveStr::Ascii("thmi"),
        dictgen::InsensitiveStr::Ascii("thmical"),
        dictgen::InsensitiveStr::Ascii("thmm"),
        dictgen::InsensitiveStr::Ascii("thmmic"),
        dictgen::InsensitiveStr::Ascii("thmmically"),
        dictgen::InsensitiveStr::Ascii("thmms"),
        dictgen::InsensitiveStr::Ascii("thmn"),
        dictgen::InsensitiveStr::Ascii("thmnic"),
        dictgen::InsensitiveStr::Ascii("thmnically"),
        dictgen::InsensitiveStr::Ascii("thmns"),
        dictgen::InsensitiveStr::Ascii("thmus"),
        dictgen::InsensitiveStr::Ascii("ths"),
        dictgen::InsensitiveStr::Ascii("thsm"),
        dictgen::InsensitiveStr::Ascii("thsmic"),
        dictgen::InsensitiveStr::Ascii("thsmically"),
        dictgen::InsensitiveStr::Ascii("thsms"),
        dictgen::InsensitiveStr::Ascii("thum"),
        dictgen::InsensitiveStr::Ascii("thym"),
        dictgen::InsensitiveStr::Ascii("thyms"),
        dictgen::InsensitiveStr::Ascii("tm"),
        dictgen::InsensitiveStr::Ascii("tmes"),
        dictgen::InsensitiveStr::Ascii("tmic"),
        dictgen::InsensitiveStr::Ascii("tmically"),
        dictgen::InsensitiveStr::Ascii("tmos"),
        dictgen::InsensitiveStr::Ascii("tms"),
    ],
    values: &[
        &["algorithm"],
        &["algorithmic"],
        &["algorithmically"],
        &["algorithms"],
        &["algorithm"],
        &["algorithmic"],
        &["algorithmically"],
        &["algorithms"],
        &["algorithm"],
        &["algorithmic"],
        &["algorithmically"],
        &["algorithms"],
        &["algorithm", "algorithms"],
        &["algorithms"],
        &["algorithm"],
        &["algorithm"],
        &["algorithmic"],
        &["algorithmically"],
        &["algorithm", "algorithms"],
        &["algorithmic"],
        &["algorithmically"],
        &["algorithm"],
        &["algorithms"],
        &["algorithmic"],
        &["algorithmic", "algorithmically"],
        &["algorithmically"],
        &["algorithm", "algorithms"],
        &["algorithms"],
        &["algorithm"],
        &["algorithmically"],
        &["algorithm"],
        &["algorithmic"],
        &["algorithmically"],
        &["algorithms"],
        &["algorithm"],
        &["algorithmic"],
        &["algorithmically"],
        &["algorithms"],
        &["algorithms"],
        &["algorithms"],
        &["algorithms", "algorithm"],
        &["algorithmic"],
        &["algorithmically"],
        &["algorithms"],
        &["algorithm"],
        &["algorithm"],
        &["algorithm"],
        &["algorithm"],
        &["algorithms"],
        &["algorithmic"],
        &["algorithmically"],
        &["algorithms"],
        &["algorithms"],
    ],
    range: 2..=10,
};

static WORD_ALGORH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ALGORH_CHILDREN),
    value: None,
};

pub static WORD_ALGORH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ithm"),
        dictgen::InsensitiveStr::Ascii("ithmic"),
        dictgen::InsensitiveStr::Ascii("ithmically"),
        dictgen::InsensitiveStr::Ascii("ithms"),
        dictgen::InsensitiveStr::Ascii("itm"),
        dictgen::InsensitiveStr::Ascii("itmic"),
        dictgen::InsensitiveStr::Ascii("itmically"),
        dictgen::InsensitiveStr::Ascii("itms"),
        dictgen::InsensitiveStr::Ascii("tm"),
        dictgen::InsensitiveStr::Ascii("tmic"),
        dictgen::InsensitiveStr::Ascii("tmically"),
        dictgen::InsensitiveStr::Ascii("tms"),
        dictgen::InsensitiveStr::Ascii("ythm"),
        dictgen::InsensitiveStr::Ascii("ythmic"),
        dictgen::InsensitiveStr::Ascii("ythmically"),
        dictgen::InsensitiveStr::Ascii("ythms"),
        dictgen::InsensitiveStr::Ascii("ytm"),
        dictgen::InsensitiveStr::Ascii("ytmic"),
        dictgen::InsensitiveStr::Ascii("ytmically"),
        dictgen::InsensitiveStr::Ascii("ytms"),
    ],
    values: &[
        &["algorithm"],
        &["algorithmic"],
        &["algorithmically"],
        &["algorithms"],
        &["algorithm"],
        &["algorithmic"],
        &["algorithmically"],
        &["algorithms"],
        &["algorithm"],
        &["algorithmic"],
        &["algorithmically"],
        &["algorithms"],
        &["algorithm"],
        &["algorithmic"],
        &["algorithmically"],
        &["algorithms"],
        &["algorithm"],
        &["algorithmic"],
        &["algorithmically"],
        &["algorithms"],
    ],
    range: 2..=10,
};

static WORD_ALGORG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ALGORG_CHILDREN),
    value: None,
};

pub static WORD_ALGORG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ithm"),
        dictgen::InsensitiveStr::Ascii("ithmic"),
        dictgen::InsensitiveStr::Ascii("ithmically"),
        dictgen::InsensitiveStr::Ascii("ithms"),
    ],
    values: &[
        &["algorithm"],
        &["algorithmic"],
        &["algorithmically"],
        &["algorithms"],
    ],
    range: 4..=10,
};

static WORD_ALGOP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ALGOP_CHILDREN),
    value: None,
};

pub static WORD_ALGOP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("rithm"),
        dictgen::InsensitiveStr::Ascii("rithmic"),
        dictgen::InsensitiveStr::Ascii("rithmically"),
        dictgen::InsensitiveStr::Ascii("rithms"),
    ],
    values: &[
        &["algorithm"],
        &["algorithmic"],
        &["algorithmically"],
        &["algorithms"],
    ],
    range: 5..=11,
};

static WORD_ALGOO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ALGOO_CHILDREN),
    value: None,
};

pub static WORD_ALGOO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("rithm"),
        dictgen::InsensitiveStr::Ascii("rithmic"),
        dictgen::InsensitiveStr::Ascii("rithmically"),
        dictgen::InsensitiveStr::Ascii("rithms"),
    ],
    values: &[
        &["algorithm"],
        &["algorithmic"],
        &["algorithmically"],
        &["algorithms"],
    ],
    range: 5..=11,
};

static WORD_ALGOL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ALGOL_CHILDREN),
    value: None,
};

pub static WORD_ALGOL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ithm"),
        dictgen::InsensitiveStr::Ascii("ithmic"),
        dictgen::InsensitiveStr::Ascii("ithmically"),
        dictgen::InsensitiveStr::Ascii("ithms"),
    ],
    values: &[
        &["algorithm"],
        &["algorithmic"],
        &["algorithmically"],
        &["algorithms"],
    ],
    range: 4..=10,
};

static WORD_ALGOI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ALGOI_CHILDREN),
    value: None,
};

pub static WORD_ALGOI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("rthm"),
        dictgen::InsensitiveStr::Ascii("rthmic"),
        dictgen::InsensitiveStr::Ascii("rthmically"),
        dictgen::InsensitiveStr::Ascii("rthms"),
        dictgen::InsensitiveStr::Ascii("thm"),
        dictgen::InsensitiveStr::Ascii("thmic"),
        dictgen::InsensitiveStr::Ascii("thmically"),
        dictgen::InsensitiveStr::Ascii("thms"),
    ],
    values: &[
        &["algorithm"],
        &["algorithmic"],
        &["algorithmically"],
        &["algorithms"],
        &["algorithm"],
        &["algorithmic"],
        &["algorithmically"],
        &["algorithms"],
    ],
    range: 3..=10,
};

static WORD_ALGOH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ALGOH_CHILDREN),
    value: None,
};

pub static WORD_ALGOH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("m"),
        dictgen::InsensitiveStr::Ascii("mic"),
        dictgen::InsensitiveStr::Ascii("mically"),
        dictgen::InsensitiveStr::Ascii("ms"),
    ],
    values: &[
        &["algorithm"],
        &["algorithmic"],
        &["algorithmically"],
        &["algorithms"],
    ],
    range: 1..=7,
};

static WORD_ALGI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ALGI_CHILDREN),
    value: None,
};

pub static WORD_ALGI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ned"),
        dictgen::InsensitiveStr::Ascii("nment"),
        dictgen::InsensitiveStr::Ascii("nments"),
    ],
    values: &[&["alined"], &["alignment"], &["alignments"]],
    range: 3..=6,
};

static WORD_ALGH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ALGH_CHILDREN),
    value: None,
};

pub static WORD_ALGH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("orithm"),
        dictgen::InsensitiveStr::Ascii("oritm"),
        dictgen::InsensitiveStr::Ascii("oritmic"),
        dictgen::InsensitiveStr::Ascii("oritmically"),
        dictgen::InsensitiveStr::Ascii("oritms"),
    ],
    values: &[
        &["algorithm"],
        &["algorithm"],
        &["algorithmic"],
        &["algorithmically"],
        &["algorithms"],
    ],
    range: 5..=11,
};

static WORD_ALGE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ALGE_CHILDREN),
    value: None,
};

pub static WORD_ALGE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("braical"),
        dictgen::InsensitiveStr::Ascii("briac"),
        dictgen::InsensitiveStr::Ascii("bric"),
        dictgen::InsensitiveStr::Ascii("brra"),
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("rba"),
    ],
    values: &[
        &["algebraic"],
        &["algebraic"],
        &["algebraic"],
        &["algebra"],
        &["algae"],
        &["algebra"],
    ],
    range: 1..=7,
};

static WORD_ALF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ALF_CHILDREN),
    value: None,
};

pub static WORD_ALF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("orithm"),
        dictgen::InsensitiveStr::Ascii("orithmic"),
        dictgen::InsensitiveStr::Ascii("orithmically"),
        dictgen::InsensitiveStr::Ascii("orithms"),
    ],
    values: &[
        &["algorithm"],
        &["algorithmic"],
        &["algorithmically"],
        &["algorithms"],
    ],
    range: 6..=12,
};

static WORD_ALE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ALE_CHILDREN),
    value: None,
};

pub static WORD_ALE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ady"),
        dictgen::InsensitiveStr::Ascii("ays"),
        dictgen::InsensitiveStr::Ascii("chmist"),
        dictgen::InsensitiveStr::Ascii("dge"),
        dictgen::InsensitiveStr::Ascii("dged"),
        dictgen::InsensitiveStr::Ascii("dges"),
        dictgen::InsensitiveStr::Ascii("gance"),
        dictgen::InsensitiveStr::Ascii("gbra"),
        dictgen::InsensitiveStr::Ascii("ge"),
        dictgen::InsensitiveStr::Ascii("ged"),
        dictgen::InsensitiveStr::Ascii("gience"),
        dictgen::InsensitiveStr::Ascii("gorical"),
        dictgen::InsensitiveStr::Ascii("inated"),
        dictgen::InsensitiveStr::Ascii("inating"),
        dictgen::InsensitiveStr::Ascii("niate"),
        dictgen::InsensitiveStr::Ascii("rnate"),
        dictgen::InsensitiveStr::Ascii("rnated"),
        dictgen::InsensitiveStr::Ascii("rnately"),
        dictgen::InsensitiveStr::Ascii("rnates"),
        dictgen::InsensitiveStr::Ascii("rs"),
        dictgen::InsensitiveStr::Ascii("viate"),
        dictgen::InsensitiveStr::Ascii("viates"),
        dictgen::InsensitiveStr::Ascii("viating"),
        dictgen::InsensitiveStr::Ascii("vt"),
    ],
    values: &[
        &["already"],
        &["always"],
        &["alchemist"],
        &["allege"],
        &["alleged"],
        &["alleges"],
        &["allegiance"],
        &["algebra"],
        &["allege"],
        &["alleged"],
        &["allegiance"],
        &["allegorical"],
        &["alienated"],
        &["alienating"],
        &["alienate"],
        &["alternate"],
        &["alternated"],
        &["alternately"],
        &["alternates"],
        &["alerts"],
        &["alleviate"],
        &["alleviates"],
        &["alleviating"],
        &["alert"],
    ],
    range: 2..=7,
};

static WORD_ALD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ALD_CHILDREN),
    value: None,
};

pub static WORD_ALD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("utery")],
    values: &[&["adultery"]],
    range: 5..=5,
};

static WORD_ALC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ALC_CHILDREN),
    value: None,
};

pub static WORD_ALC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ehmist"),
        dictgen::InsensitiveStr::Ascii("emy"),
        dictgen::InsensitiveStr::Ascii("hemey"),
        dictgen::InsensitiveStr::Ascii("hemsit"),
        dictgen::InsensitiveStr::Ascii("himest"),
        dictgen::InsensitiveStr::Ascii("hmeist"),
        dictgen::InsensitiveStr::Ascii("hmey"),
        dictgen::InsensitiveStr::Ascii("hohol"),
        dictgen::InsensitiveStr::Ascii("hoholic"),
        dictgen::InsensitiveStr::Ascii("hol"),
        dictgen::InsensitiveStr::Ascii("holic"),
        dictgen::InsensitiveStr::Ascii("hool"),
        dictgen::InsensitiveStr::Ascii("hoolic"),
        dictgen::InsensitiveStr::Ascii("hoolism"),
        dictgen::InsensitiveStr::Ascii("ohal"),
        dictgen::InsensitiveStr::Ascii("ohalics"),
        dictgen::InsensitiveStr::Ascii("ohalism"),
        dictgen::InsensitiveStr::Ascii("oholc"),
        dictgen::InsensitiveStr::Ascii("oholical"),
        dictgen::InsensitiveStr::Ascii("oholicas"),
        dictgen::InsensitiveStr::Ascii("oholicos"),
        dictgen::InsensitiveStr::Ascii("oholis"),
        dictgen::InsensitiveStr::Ascii("oholisim"),
        dictgen::InsensitiveStr::Ascii("oholsim"),
    ],
    values: &[
        &["alchemist"],
        &["alchemy"],
        &["alchemy"],
        &["alchemist"],
        &["alchemist"],
        &["alchemist"],
        &["alchemy"],
        &["alcohol"],
        &["alcoholic"],
        &["alcohol"],
        &["alcoholic"],
        &["alcohol"],
        &["alcoholic"],
        &["alcoholism"],
        &["alcohol"],
        &["alcoholics"],
        &["alcoholism"],
        &["alcoholics"],
        &["alcoholic"],
        &["alcoholics"],
        &["alcoholics"],
        &["alcoholics"],
        &["alcoholism"],
        &["alcoholism"],
    ],
    range: 3..=8,
};

static WORD_ALB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ALB_CHILDREN),
    value: None,
};

pub static WORD_ALB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("iet"),
        dictgen::InsensitiveStr::Ascii("umns"),
    ],
    values: &[&["albeit"], &["albums"]],
    range: 3..=4,
};

static WORD_ALA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ALA_CHILDREN),
    value: None,
};

pub static WORD_ALA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ready")],
    values: &[&["already"]],
    range: 5..=5,
};

static WORD_AK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AK_CHILDREN),
    value: None,
};

pub static WORD_AK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("kumulate"),
        dictgen::InsensitiveStr::Ascii("kumulated"),
        dictgen::InsensitiveStr::Ascii("kumulates"),
        dictgen::InsensitiveStr::Ascii("kumulating"),
        dictgen::InsensitiveStr::Ascii("kumulation"),
        dictgen::InsensitiveStr::Ascii("kumulative"),
        dictgen::InsensitiveStr::Ascii("kumulator"),
        dictgen::InsensitiveStr::Ascii("nowledge"),
        dictgen::InsensitiveStr::Ascii("ransas"),
        dictgen::InsensitiveStr::Ascii("s"),
        dictgen::InsensitiveStr::Ascii("sed"),
        dictgen::InsensitiveStr::Ascii("sreddit"),
        dictgen::InsensitiveStr::Ascii("ss"),
        dictgen::InsensitiveStr::Ascii("tivate"),
        dictgen::InsensitiveStr::Ascii("tivated"),
        dictgen::InsensitiveStr::Ascii("tivates"),
        dictgen::InsensitiveStr::Ascii("tivating"),
        dictgen::InsensitiveStr::Ascii("tivation"),
        dictgen::InsensitiveStr::Ascii("umulate"),
        dictgen::InsensitiveStr::Ascii("umulated"),
        dictgen::InsensitiveStr::Ascii("umulates"),
        dictgen::InsensitiveStr::Ascii("umulating"),
        dictgen::InsensitiveStr::Ascii("umulation"),
        dictgen::InsensitiveStr::Ascii("umulative"),
        dictgen::InsensitiveStr::Ascii("umulator"),
    ],
    values: &[
        &["ache"],
        &["accumulate"],
        &["accumulated"],
        &["accumulates"],
        &["accumulating"],
        &["accumulation"],
        &["accumulative"],
        &["accumulator"],
        &["acknowledge"],
        &["arkansas"],
        &["ask"],
        &["asked"],
        &["askreddit"],
        &["asks", "ass"],
        &["activate"],
        &["activated"],
        &["activates"],
        &["activating"],
        &["activation"],
        &["accumulate"],
        &["accumulated"],
        &["accumulates"],
        &["accumulating"],
        &["accumulation"],
        &["accumulative"],
        &["accumulator"],
    ],
    range: 1..=10,
};

static WORD_AJ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AJ_CHILDREN),
    value: None,
};

pub static WORD_AJ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("acence"),
        dictgen::InsensitiveStr::Ascii("acencies"),
        dictgen::InsensitiveStr::Ascii("acency"),
        dictgen::InsensitiveStr::Ascii("acent"),
        dictgen::InsensitiveStr::Ascii("acentcy"),
        dictgen::InsensitiveStr::Ascii("asence"),
        dictgen::InsensitiveStr::Ascii("asencies"),
        dictgen::InsensitiveStr::Ascii("ative"),
        dictgen::InsensitiveStr::Ascii("cencies"),
        dictgen::InsensitiveStr::Ascii("dectives"),
        dictgen::InsensitiveStr::Ascii("sencies"),
        dictgen::InsensitiveStr::Ascii("urnment"),
        dictgen::InsensitiveStr::Ascii("ust"),
        dictgen::InsensitiveStr::Ascii("usted"),
        dictgen::InsensitiveStr::Ascii("ustement"),
        dictgen::InsensitiveStr::Ascii("usting"),
        dictgen::InsensitiveStr::Ascii("ustment"),
        dictgen::InsensitiveStr::Ascii("ustments"),
    ],
    values: &[
        &["adjacence"],
        &["adjacencies"],
        &["adjacency"],
        &["adjacent"],
        &["adjacency"],
        &["adjacence"],
        &["adjacencies"],
        &["adjective"],
        &["adjacencies"],
        &["adjectives"],
        &["adjacencies"],
        &["adjournment"],
        &["adjust"],
        &["adjusted"],
        &["adjustment"],
        &["adjusting"],
        &["adjustment"],
        &["adjustments"],
    ],
    range: 3..=8,
};

static WORD_AI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AI_CHILDREN),
    value: None,
};

pub static WORD_AI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("craft"),
        dictgen::InsensitiveStr::Ascii("ffer"),
        dictgen::InsensitiveStr::Ascii("lenated"),
        dictgen::InsensitiveStr::Ascii("lenating"),
        dictgen::InsensitiveStr::Ascii("lgn"),
        dictgen::InsensitiveStr::Ascii("lmony"),
        dictgen::InsensitiveStr::Ascii("ncents"),
        dictgen::InsensitiveStr::Ascii("port"),
        dictgen::InsensitiveStr::Ascii("rator"),
        dictgen::InsensitiveStr::Ascii("rboner"),
        dictgen::InsensitiveStr::Ascii("rbore"),
        dictgen::InsensitiveStr::Ascii("rbourne"),
        dictgen::InsensitiveStr::Ascii("rbrone"),
        dictgen::InsensitiveStr::Ascii("rcaft"),
        dictgen::InsensitiveStr::Ascii("rcarft"),
        dictgen::InsensitiveStr::Ascii("rcrafts"),
        dictgen::InsensitiveStr::Ascii("rfow"),
        dictgen::InsensitiveStr::Ascii("rial"),
        dictgen::InsensitiveStr::Ascii("rlfow"),
        dictgen::InsensitiveStr::Ascii("rloom"),
        dictgen::InsensitiveStr::Ascii("rosft"),
        dictgen::InsensitiveStr::Ascii("rplance"),
        dictgen::InsensitiveStr::Ascii("rplans"),
        dictgen::InsensitiveStr::Ascii("rporta"),
        dictgen::InsensitiveStr::Ascii("rpost"),
        dictgen::InsensitiveStr::Ascii("rpsace"),
        dictgen::InsensitiveStr::Ascii("rrcraft"),
        dictgen::InsensitiveStr::Ascii("rscape"),
        dictgen::InsensitiveStr::Ascii("rsfot"),
        dictgen::InsensitiveStr::Ascii("rzona"),
        dictgen::InsensitiveStr::Ascii("sian"),
        dictgen::InsensitiveStr::Ascii("xs"),
        dictgen::InsensitiveStr::Ascii("zmuth"),
    ],
    values: &[
        &["aircraft"],
        &["differ"],
        &["alienated"],
        &["alienating"],
        &["align"],
        &["alimony"],
        &["ancients"],
        &["airport"],
        &["aerator"],
        &["airborne"],
        &["airborne"],
        &["airborne"],
        &["airborne"],
        &["aircraft"],
        &["aircraft"],
        &["aircraft"],
        &["airflow"],
        &["aerial", "arial"],
        &["airflow"],
        &["heirloom"],
        &["airsoft"],
        &["airplane"],
        &["airplanes"],
        &["airports"],
        &["airports"],
        &["airspace"],
        &["aircraft"],
        &["airspace"],
        &["airsoft"],
        &["arizona"],
        &["asian"],
        &["axis"],
        &["azimuth"],
    ],
    range: 2..=8,
};

static WORD_AH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AH_CHILDREN),
    value: None,
};

pub static WORD_AH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eared"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("ere"),
        dictgen::InsensitiveStr::Ascii("ev"),
        dictgen::InsensitiveStr::Ascii("lpa"),
        dictgen::InsensitiveStr::Ascii("lpas"),
        dictgen::InsensitiveStr::Ascii("mond"),
        dictgen::InsensitiveStr::Ascii("monds"),
        dictgen::InsensitiveStr::Ascii("ould"),
        dictgen::InsensitiveStr::Ascii("ppen"),
        dictgen::InsensitiveStr::Ascii("tiest"),
        dictgen::InsensitiveStr::Ascii("tletes"),
        dictgen::InsensitiveStr::Ascii("tleticism"),
        dictgen::InsensitiveStr::Ascii("ve"),
    ],
    values: &[
        &["adhered"],
        &["ahead"],
        &["adhere", "here"],
        &["have"],
        &["alpha"],
        &["alphas"],
        &["almond"],
        &["almonds"],
        &["should"],
        &["happen"],
        &["atheist"],
        &["athletes"],
        &["athleticism"],
        &["have"],
    ],
    range: 2..=9,
};

static WORD_AG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_AG_CHILDREN),
    value: None,
};

static WORD_AG_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_AGA_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_AGG_NODE),
    None,
    Some(&WORD_AGI_NODE),
    None,
    Some(&WORD_AGK_NODE),
    Some(&WORD_AGL_NODE),
    None,
    Some(&WORD_AGN_NODE),
    Some(&WORD_AGO_NODE),
    None,
    None,
    Some(&WORD_AGR_NODE),
    Some(&WORD_AGS_NODE),
    None,
    Some(&WORD_AGU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_AGU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AGU_CHILDREN),
    value: None,
};

pub static WORD_AGU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ment"),
        dictgen::InsensitiveStr::Ascii("mented"),
        dictgen::InsensitiveStr::Ascii("ments"),
        dictgen::InsensitiveStr::Ascii("rement"),
    ],
    values: &[&["argument"], &["augmented"], &["arguments"], &["argument"]],
    range: 4..=6,
};

static WORD_AGS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AGS_CHILDREN),
    value: Some(&["ages", "tags"]),
};

pub static WORD_AGS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("inst")],
    values: &[&["against"]],
    range: 4..=4,
};

static WORD_AGR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AGR_CHILDREN),
    value: None,
};

pub static WORD_AGR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("acultural"),
        dictgen::InsensitiveStr::Ascii("ain"),
        dictgen::InsensitiveStr::Ascii("andize"),
        dictgen::InsensitiveStr::Ascii("andized"),
        dictgen::InsensitiveStr::Ascii("andizes"),
        dictgen::InsensitiveStr::Ascii("andizing"),
        dictgen::InsensitiveStr::Ascii("avate"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("eeement"),
        dictgen::InsensitiveStr::Ascii("eemnet"),
        dictgen::InsensitiveStr::Ascii("eemnets"),
        dictgen::InsensitiveStr::Ascii("eemnt"),
        dictgen::InsensitiveStr::Ascii("egate"),
        dictgen::InsensitiveStr::Ascii("egated"),
        dictgen::InsensitiveStr::Ascii("egates"),
        dictgen::InsensitiveStr::Ascii("egation"),
        dictgen::InsensitiveStr::Ascii("egator"),
        dictgen::InsensitiveStr::Ascii("eggate"),
        dictgen::InsensitiveStr::Ascii("eing"),
        dictgen::InsensitiveStr::Ascii("ement"),
        dictgen::InsensitiveStr::Ascii("entina"),
        dictgen::InsensitiveStr::Ascii("essie"),
        dictgen::InsensitiveStr::Ascii("ession"),
        dictgen::InsensitiveStr::Ascii("essive"),
        dictgen::InsensitiveStr::Ascii("essively"),
        dictgen::InsensitiveStr::Ascii("essiveness"),
        dictgen::InsensitiveStr::Ascii("essivity"),
        dictgen::InsensitiveStr::Ascii("essivley"),
        dictgen::InsensitiveStr::Ascii("essivnes"),
        dictgen::InsensitiveStr::Ascii("essor"),
        dictgen::InsensitiveStr::Ascii("esssive"),
        dictgen::InsensitiveStr::Ascii("esssively"),
        dictgen::InsensitiveStr::Ascii("essvie"),
        dictgen::InsensitiveStr::Ascii("gressive"),
        dictgen::InsensitiveStr::Ascii("gressively"),
        dictgen::InsensitiveStr::Ascii("gument"),
        dictgen::InsensitiveStr::Ascii("guments"),
        dictgen::InsensitiveStr::Ascii("icolture"),
        dictgen::InsensitiveStr::Ascii("iculteral"),
        dictgen::InsensitiveStr::Ascii("iculteur"),
        dictgen::InsensitiveStr::Ascii("iculteurs"),
        dictgen::InsensitiveStr::Ascii("icultral"),
        dictgen::InsensitiveStr::Ascii("icultre"),
        dictgen::InsensitiveStr::Ascii("icultrual"),
        dictgen::InsensitiveStr::Ascii("icultual"),
        dictgen::InsensitiveStr::Ascii("icultue"),
        dictgen::InsensitiveStr::Ascii("iculturual"),
        dictgen::InsensitiveStr::Ascii("iculure"),
        dictgen::InsensitiveStr::Ascii("iculutral"),
        dictgen::InsensitiveStr::Ascii("icutlure"),
        dictgen::InsensitiveStr::Ascii("icuture"),
        dictgen::InsensitiveStr::Ascii("ieved"),
        dictgen::InsensitiveStr::Ascii("igultural"),
        dictgen::InsensitiveStr::Ascii("ocultural"),
        dictgen::InsensitiveStr::Ascii("resive"),
        dictgen::InsensitiveStr::Ascii("uable"),
        dictgen::InsensitiveStr::Ascii("uably"),
        dictgen::InsensitiveStr::Ascii("uement"),
        dictgen::InsensitiveStr::Ascii("uing"),
        dictgen::InsensitiveStr::Ascii("ument"),
        dictgen::InsensitiveStr::Ascii("umentative"),
        dictgen::InsensitiveStr::Ascii("uments"),
    ],
    values: &[
        &["agricultural"],
        &["again"],
        &["aggrandize"],
        &["aggrandized"],
        &["aggrandizes"],
        &["aggrandizing"],
        &["aggravate"],
        &["agreed"],
        &["agreement"],
        &["agreement"],
        &["agreements"],
        &["agreement"],
        &["aggregate"],
        &["aggregated"],
        &["aggregates"],
        &["aggregation"],
        &["aggregator"],
        &["aggregate"],
        &["agreeing"],
        &["agreement"],
        &["argentina"],
        &["aggressive"],
        &["aggression"],
        &["aggressive"],
        &["aggressively"],
        &["aggressiveness"],
        &["aggressivity"],
        &["aggressive"],
        &["aggressive"],
        &["aggressor"],
        &["aggressive"],
        &["aggressively"],
        &["aggressive"],
        &["aggressive"],
        &["aggressively"],
        &["argument"],
        &["arguments"],
        &["agriculture"],
        &["agricultural"],
        &["agriculture"],
        &["agriculture"],
        &["agricultural"],
        &["agriculture"],
        &["agricultural"],
        &["agricultural"],
        &["agriculture"],
        &["agricultural"],
        &["agriculture"],
        &["agricultural"],
        &["agriculture"],
        &["agriculture"],
        &["aggrieved"],
        &["agricultural"],
        &["agricultural"],
        &["aggressive"],
        &["arguable"],
        &["arguably"],
        &["argument"],
        &["arguing"],
        &["argument"],
        &["argumentative"],
        &["arguments"],
    ],
    range: 2..=10,
};

static WORD_AGO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AGO_CHILDREN),
    value: None,
};

pub static WORD_AGO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("nstic"),
        dictgen::InsensitiveStr::Ascii("nsticism"),
        dictgen::InsensitiveStr::Ascii("rithm"),
    ],
    values: &[&["agnostic"], &["agnosticism"], &["algorithm"]],
    range: 5..=8,
};

static WORD_AGN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AGN_CHILDREN),
    value: None,
};

pub static WORD_AGN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ositc"),
        dictgen::InsensitiveStr::Ascii("ostacism"),
        dictgen::InsensitiveStr::Ascii("osticim"),
        dictgen::InsensitiveStr::Ascii("osticisim"),
        dictgen::InsensitiveStr::Ascii("osticm"),
        dictgen::InsensitiveStr::Ascii("osticsm"),
        dictgen::InsensitiveStr::Ascii("ostisch"),
        dictgen::InsensitiveStr::Ascii("ostiscm"),
        dictgen::InsensitiveStr::Ascii("ostisicm"),
        dictgen::InsensitiveStr::Ascii("ostisim"),
        dictgen::InsensitiveStr::Ascii("ostisism"),
        dictgen::InsensitiveStr::Ascii("ostocism"),
        dictgen::InsensitiveStr::Ascii("soticism"),
    ],
    values: &[
        &["agnostic"],
        &["agnosticism"],
        &["agnosticism"],
        &["agnosticism"],
        &["agnosticism"],
        &["agnosticism"],
        &["agnostic"],
        &["agnosticism"],
        &["agnosticism"],
        &["agnosticism"],
        &["agnosticism"],
        &["agnosticism"],
        &["agnosticism"],
    ],
    range: 5..=9,
};

static WORD_AGL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AGL_CHILDREN),
    value: None,
};

pub static WORD_AGL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("orithm"),
        dictgen::InsensitiveStr::Ascii("orithms"),
    ],
    values: &[&["algorithm"], &["algorithms"]],
    range: 6..=7,
};

static WORD_AGK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AGK_CHILDREN),
    value: None,
};

pub static WORD_AGK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("nowledged")],
    values: &[&["acknowledged"]],
    range: 9..=9,
};

static WORD_AGI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AGI_CHILDREN),
    value: None,
};

pub static WORD_AGI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("an"),
        dictgen::InsensitiveStr::Ascii("anst"),
        dictgen::InsensitiveStr::Ascii("n"),
        dictgen::InsensitiveStr::Ascii("na"),
        dictgen::InsensitiveStr::Ascii("nst"),
        dictgen::InsensitiveStr::Ascii("rcultural"),
    ],
    values: &[
        &["again"],
        &["against"],
        &["again"],
        &["again", "angina"],
        &["against"],
        &["agricultural"],
    ],
    range: 1..=9,
};

static WORD_AGG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AGG_CHILDREN),
    value: None,
};

pub static WORD_AGG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aravates"),
        dictgen::InsensitiveStr::Ascii("egate"),
        dictgen::InsensitiveStr::Ascii("egrate"),
        dictgen::InsensitiveStr::Ascii("enst"),
        dictgen::InsensitiveStr::Ascii("ergate"),
        dictgen::InsensitiveStr::Ascii("essive"),
        dictgen::InsensitiveStr::Ascii("essively"),
        dictgen::InsensitiveStr::Ascii("gregate"),
        dictgen::InsensitiveStr::Ascii("ragate"),
        dictgen::InsensitiveStr::Ascii("ragating"),
        dictgen::InsensitiveStr::Ascii("ragator"),
        dictgen::InsensitiveStr::Ascii("rated"),
        dictgen::InsensitiveStr::Ascii("ravanti"),
        dictgen::InsensitiveStr::Ascii("raveted"),
        dictgen::InsensitiveStr::Ascii("reagate"),
        dictgen::InsensitiveStr::Ascii("reataon"),
        dictgen::InsensitiveStr::Ascii("reate"),
        dictgen::InsensitiveStr::Ascii("reated"),
        dictgen::InsensitiveStr::Ascii("reation"),
        dictgen::InsensitiveStr::Ascii("reations"),
        dictgen::InsensitiveStr::Ascii("reed"),
        dictgen::InsensitiveStr::Ascii("reement"),
        dictgen::InsensitiveStr::Ascii("regatet"),
        dictgen::InsensitiveStr::Ascii("regatore"),
        dictgen::InsensitiveStr::Ascii("regatted"),
        dictgen::InsensitiveStr::Ascii("regetor"),
        dictgen::InsensitiveStr::Ascii("reggate"),
        dictgen::InsensitiveStr::Ascii("regious"),
        dictgen::InsensitiveStr::Ascii("regrate"),
        dictgen::InsensitiveStr::Ascii("regrated"),
        dictgen::InsensitiveStr::Ascii("resions"),
        dictgen::InsensitiveStr::Ascii("resive"),
        dictgen::InsensitiveStr::Ascii("resively"),
        dictgen::InsensitiveStr::Ascii("ressivley"),
        dictgen::InsensitiveStr::Ascii("ressivly"),
        dictgen::InsensitiveStr::Ascii("ressivo"),
        dictgen::InsensitiveStr::Ascii("resssion"),
        dictgen::InsensitiveStr::Ascii("revate"),
        dictgen::InsensitiveStr::Ascii("rgate"),
        dictgen::InsensitiveStr::Ascii("rgates"),
        dictgen::InsensitiveStr::Ascii("rivate"),
        dictgen::InsensitiveStr::Ascii("rivated"),
        dictgen::InsensitiveStr::Ascii("rivates"),
        dictgen::InsensitiveStr::Ascii("rivating"),
        dictgen::InsensitiveStr::Ascii("rovated"),
        dictgen::InsensitiveStr::Ascii("rovating"),
    ],
    values: &[
        &["aggravates"],
        &["aggregate"],
        &["aggregate"],
        &["against"],
        &["aggregate"],
        &["aggressive"],
        &["aggressively"],
        &["aggregate"],
        &["aggregate"],
        &["aggravating"],
        &["aggregator"],
        &["aggregated"],
        &["aggravating"],
        &["aggravated"],
        &["aggregate"],
        &["aggregation"],
        &["aggregate"],
        &["aggregated"],
        &["aggregation"],
        &["aggregations"],
        &["agreed"],
        &["agreement"],
        &["aggregated"],
        &["aggregate"],
        &["aggregated"],
        &["aggregator"],
        &["aggregate"],
        &["egregious"],
        &["aggregate"],
        &["aggregated"],
        &["aggression"],
        &["aggressive"],
        &["aggressively"],
        &["aggressively"],
        &["aggressively"],
        &["aggression"],
        &["aggression"],
        &["aggravate"],
        &["aggregate"],
        &["aggregates"],
        &["aggravate"],
        &["aggravated"],
        &["aggravates"],
        &["aggravating"],
        &["aggravated"],
        &["aggravating"],
    ],
    range: 4..=9,
};

static WORD_AGA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AGA_CHILDREN),
    value: None,
};

pub static WORD_AGA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("innst"),
        dictgen::InsensitiveStr::Ascii("ins"),
        dictgen::InsensitiveStr::Ascii("insg"),
        dictgen::InsensitiveStr::Ascii("int"),
        dictgen::InsensitiveStr::Ascii("ints"),
        dictgen::InsensitiveStr::Ascii("isnt"),
        dictgen::InsensitiveStr::Ascii("ist"),
        dictgen::InsensitiveStr::Ascii("ncies"),
        dictgen::InsensitiveStr::Ascii("ncy"),
        dictgen::InsensitiveStr::Ascii("nda"),
        dictgen::InsensitiveStr::Ascii("nist"),
        dictgen::InsensitiveStr::Ascii("nt"),
        dictgen::InsensitiveStr::Ascii("nts"),
    ],
    values: &[
        &["against"],
        &["against", "again"],
        &["against"],
        &["against"],
        &["against"],
        &["against"],
        &["against"],
        &["agencies"],
        &["agency"],
        &["agenda", "uganda"],
        &["against"],
        &["agent"],
        &["agents", "against"],
    ],
    range: 2..=5,
};

static WORD_AF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_AF_CHILDREN),
    value: None,
};

static WORD_AF_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_AFA_NODE),
    None,
    None,
    None,
    Some(&WORD_AFE_NODE),
    Some(&WORD_AFF_NODE),
    Some(&WORD_AFG_NODE),
    Some(&WORD_AFH_NODE),
    Some(&WORD_AFI_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_AFO_NODE),
    None,
    None,
    Some(&WORD_AFR_NODE),
    None,
    Some(&WORD_AFT_NODE),
    None,
    None,
    Some(&WORD_AFW_NODE),
    None,
    None,
    None,
];

static WORD_AFW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AFW_CHILDREN),
    value: None,
};

pub static WORD_AFW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ully")],
    values: &[&["awfully"]],
    range: 4..=4,
};

static WORD_AFT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AFT_CHILDREN),
    value: None,
};

pub static WORD_AFT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("erhtought"),
        dictgen::InsensitiveStr::Ascii("ermaket"),
        dictgen::InsensitiveStr::Ascii("ernarket"),
        dictgen::InsensitiveStr::Ascii("ernon"),
        dictgen::InsensitiveStr::Ascii("ernooon"),
        dictgen::InsensitiveStr::Ascii("erthougt"),
        dictgen::InsensitiveStr::Ascii("erthougth"),
        dictgen::InsensitiveStr::Ascii("erw"),
        dictgen::InsensitiveStr::Ascii("her"),
        dictgen::InsensitiveStr::Ascii("rer"),
        dictgen::InsensitiveStr::Ascii("zer"),
    ],
    values: &[
        &["afterthought"],
        &["aftermarket"],
        &["aftermarket"],
        &["afternoon"],
        &["afternoon"],
        &["afterthought"],
        &["afterthought"],
        &["after"],
        &["after", "father"],
        &["after"],
        &["after"],
    ],
    range: 3..=9,
};

static WORD_AFR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AFR_CHILDREN),
    value: None,
};

pub static WORD_AFR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("er"),
        dictgen::InsensitiveStr::Ascii("icain"),
        dictgen::InsensitiveStr::Ascii("icanas"),
        dictgen::InsensitiveStr::Ascii("icaners"),
        dictgen::InsensitiveStr::Ascii("icaness"),
        dictgen::InsensitiveStr::Ascii("icanos"),
        dictgen::InsensitiveStr::Ascii("icas"),
    ],
    values: &[
        &["after"],
        &["african"],
        &["africans"],
        &["africans"],
        &["africans"],
        &["africans"],
        &["africans"],
    ],
    range: 2..=7,
};

static WORD_AFO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AFO_CHILDREN),
    value: None,
};

pub static WORD_AFO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("r"),
        dictgen::InsensitiveStr::Ascii("rememtioned"),
        dictgen::InsensitiveStr::Ascii("rementioend"),
        dictgen::InsensitiveStr::Ascii("rementiond"),
        dictgen::InsensitiveStr::Ascii("rementionned"),
        dictgen::InsensitiveStr::Ascii("rmentioned"),
    ],
    values: &[
        &["for"],
        &["aforementioned"],
        &["aforementioned"],
        &["aforementioned"],
        &["aforementioned"],
        &["aforementioned"],
    ],
    range: 1..=12,
};

static WORD_AFI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AFI_CHILDREN),
    value: None,
};

pub static WORD_AFI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("nity"),
        dictgen::InsensitiveStr::Ascii("rcan"),
        dictgen::InsensitiveStr::Ascii("rcans"),
    ],
    values: &[&["affinity"], &["african"], &["africans"]],
    range: 4..=5,
};

static WORD_AFH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AFH_CHILDREN),
    value: None,
};

pub static WORD_AFH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ganistan")],
    values: &[&["afghanistan"]],
    range: 8..=8,
};

static WORD_AFG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AFG_CHILDREN),
    value: None,
};

pub static WORD_AFG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ahnistan"),
        dictgen::InsensitiveStr::Ascii("anhistan"),
        dictgen::InsensitiveStr::Ascii("hanastan"),
        dictgen::InsensitiveStr::Ascii("hanisthan"),
        dictgen::InsensitiveStr::Ascii("hansitan"),
    ],
    values: &[
        &["afghanistan"],
        &["afghanistan"],
        &["afghanistan"],
        &["afghanistan"],
        &["afghanistan"],
    ],
    range: 8..=9,
};

static WORD_AFF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AFF_CHILDREN),
    value: None,
};

pub static WORD_AFF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("act"),
        dictgen::InsensitiveStr::Ascii("aires"),
        dictgen::InsensitiveStr::Ascii("aris"),
        dictgen::InsensitiveStr::Ascii("ecfted"),
        dictgen::InsensitiveStr::Ascii("ectionatley"),
        dictgen::InsensitiveStr::Ascii("ectionnate"),
        dictgen::InsensitiveStr::Ascii("ekt"),
        dictgen::InsensitiveStr::Ascii("iars"),
        dictgen::InsensitiveStr::Ascii("icianado"),
        dictgen::InsensitiveStr::Ascii("icianados"),
        dictgen::InsensitiveStr::Ascii("icionado"),
        dictgen::InsensitiveStr::Ascii("icionados"),
        dictgen::InsensitiveStr::Ascii("ilate"),
        dictgen::InsensitiveStr::Ascii("ilates"),
        dictgen::InsensitiveStr::Ascii("ilation"),
        dictgen::InsensitiveStr::Ascii("ilations"),
        dictgen::InsensitiveStr::Ascii("iliato"),
        dictgen::InsensitiveStr::Ascii("iliaton"),
        dictgen::InsensitiveStr::Ascii("iliction"),
        dictgen::InsensitiveStr::Ascii("illiate"),
        dictgen::InsensitiveStr::Ascii("initied"),
        dictgen::InsensitiveStr::Ascii("initiy"),
        dictgen::InsensitiveStr::Ascii("initized"),
        dictgen::InsensitiveStr::Ascii("initze"),
        dictgen::InsensitiveStr::Ascii("inties"),
        dictgen::InsensitiveStr::Ascii("intiy"),
        dictgen::InsensitiveStr::Ascii("intize"),
        dictgen::InsensitiveStr::Ascii("inty"),
        dictgen::InsensitiveStr::Ascii("irmate"),
        dictgen::InsensitiveStr::Ascii("irmitave"),
        dictgen::InsensitiveStr::Ascii("irmitive"),
        dictgen::InsensitiveStr::Ascii("irmitve"),
        dictgen::InsensitiveStr::Ascii("itnity"),
        dictgen::InsensitiveStr::Ascii("ixiation"),
        dictgen::InsensitiveStr::Ascii("lcition"),
        dictgen::InsensitiveStr::Ascii("lection"),
        dictgen::InsensitiveStr::Ascii("leunt"),
        dictgen::InsensitiveStr::Ascii("liated"),
        dictgen::InsensitiveStr::Ascii("liation"),
        dictgen::InsensitiveStr::Ascii("liciton"),
        dictgen::InsensitiveStr::Ascii("oradble"),
        dictgen::InsensitiveStr::Ascii("ordible"),
        dictgen::InsensitiveStr::Ascii("orementioned"),
        dictgen::InsensitiveStr::Ascii("ort"),
        dictgen::InsensitiveStr::Ascii("ortable"),
        dictgen::InsensitiveStr::Ascii("orts"),
        dictgen::InsensitiveStr::Ascii("raid"),
        dictgen::InsensitiveStr::Ascii("rimative"),
        dictgen::InsensitiveStr::Ascii("ter"),
        dictgen::InsensitiveStr::Ascii("ulent"),
    ],
    values: &[
        &["affect", "effect"],
        &["affairs"],
        &["affairs"],
        &["affected"],
        &["affectionate"],
        &["affectionate"],
        &["affect", "effect"],
        &["affairs"],
        &["aficionado"],
        &["aficionados"],
        &["aficionado"],
        &["aficionados"],
        &["affiliate"],
        &["affiliates"],
        &["affiliation"],
        &["affiliations"],
        &["affiliation"],
        &["affiliation"],
        &["affiliation"],
        &["affiliate"],
        &["affinities"],
        &["affinity"],
        &["affinities", "affinity"],
        &["affinitize"],
        &["affinities"],
        &["affinity"],
        &["affinitize"],
        &["affinity"],
        &["affirmative"],
        &["affirmative"],
        &["affirmative"],
        &["affirmative"],
        &["affinity"],
        &["affiliation"],
        &["affliction"],
        &["affliction"],
        &["affluent"],
        &["affiliated"],
        &["affliction"],
        &["affliction"],
        &["affordable"],
        &["affordable"],
        &["aforementioned"],
        &["afford", "effort"],
        &["affordable"],
        &["affords"],
        &["afraid"],
        &["affirmative"],
        &["after"],
        &["affluent"],
    ],
    range: 3..=12,
};

static WORD_AFE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AFE_CHILDREN),
    value: Some(&["safe"]),
};

pub static WORD_AFE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ct"),
        dictgen::InsensitiveStr::Ascii("cting"),
        dictgen::InsensitiveStr::Ascii("r"),
        dictgen::InsensitiveStr::Ascii("rwards"),
        dictgen::InsensitiveStr::Ascii("tr"),
    ],
    values: &[
        &["affect", "effect"],
        &["affecting"],
        &["after"],
        &["afterwards"],
        &["after"],
    ],
    range: 1..=6,
};

static WORD_AFA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AFA_CHILDREN),
    value: None,
};

pub static WORD_AFA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ir"),
        dictgen::InsensitiveStr::Ascii("raid"),
    ],
    values: &[&["affair"], &["afraid"]],
    range: 2..=4,
};

static WORD_AE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AE_CHILDREN),
    value: None,
};

pub static WORD_AE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("activate"),
        dictgen::InsensitiveStr::Ascii("orspace"),
        dictgen::InsensitiveStr::Ascii("quidistant"),
        dictgen::InsensitiveStr::Ascii("quivalent"),
        dictgen::InsensitiveStr::Ascii("riel"),
        dictgen::InsensitiveStr::Ascii("riels"),
        dictgen::InsensitiveStr::Ascii("ropsace"),
        dictgen::InsensitiveStr::Ascii("rosapce"),
        dictgen::InsensitiveStr::Ascii("rsopace"),
        dictgen::InsensitiveStr::Ascii("sily"),
        dictgen::InsensitiveStr::Ascii("stethic"),
        dictgen::InsensitiveStr::Ascii("stethically"),
        dictgen::InsensitiveStr::Ascii("stethics"),
        dictgen::InsensitiveStr::Ascii("sthatically"),
        dictgen::InsensitiveStr::Ascii("sthatics"),
        dictgen::InsensitiveStr::Ascii("sthestic"),
        dictgen::InsensitiveStr::Ascii("sthethics"),
        dictgen::InsensitiveStr::Ascii("stheticaly"),
        dictgen::InsensitiveStr::Ascii("stheticlly"),
        dictgen::InsensitiveStr::Ascii("sthitically"),
        dictgen::InsensitiveStr::Ascii("sy"),
        dictgen::InsensitiveStr::Ascii("thistic"),
        dictgen::InsensitiveStr::Ascii("thists"),
        dictgen::InsensitiveStr::Ascii("xs"),
    ],
    values: &[
        &["deactivate", "activate"],
        &["aerospace"],
        &["equidistant"],
        &["equivalent"],
        &["aerial"],
        &["aerials"],
        &["aerospace"],
        &["aerospace"],
        &["aerospace"],
        &["easily"],
        &["aesthetic"],
        &["aesthetically"],
        &["aesthetics"],
        &["aesthetically"],
        &["aesthetics"],
        &["aesthetics"],
        &["aesthetics"],
        &["aesthetically"],
        &["aesthetically"],
        &["aesthetically"],
        &["easy"],
        &["atheistic"],
        &["atheists"],
        &["axes"],
    ],
    range: 2..=11,
};

static WORD_AD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_AD_CHILDREN),
    value: None,
};

static WORD_AD_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_ADA_NODE),
    Some(&WORD_ADB_NODE),
    None,
    Some(&WORD_ADD_NODE),
    Some(&WORD_ADE_NODE),
    Some(&WORD_ADF_NODE),
    Some(&WORD_ADG_NODE),
    Some(&WORD_ADH_NODE),
    Some(&WORD_ADI_NODE),
    Some(&WORD_ADJ_NODE),
    Some(&WORD_ADK_NODE),
    None,
    Some(&WORD_ADM_NODE),
    Some(&WORD_ADN_NODE),
    Some(&WORD_ADO_NODE),
    Some(&WORD_ADP_NODE),
    Some(&WORD_ADQ_NODE),
    Some(&WORD_ADR_NODE),
    None,
    Some(&WORD_ADT_NODE),
    Some(&WORD_ADU_NODE),
    Some(&WORD_ADV_NODE),
    Some(&WORD_ADW_NODE),
    None,
    None,
    None,
];

static WORD_ADW_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ADW_CHILDREN),
    value: None,
};

pub static WORD_ADW_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ances")],
    values: &[&["advances"]],
    range: 5..=5,
};

static WORD_ADV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_ADV_CHILDREN),
    value: None,
};

static WORD_ADV_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_ADVA_NODE),
    None,
    None,
    None,
    Some(&WORD_ADVE_NODE),
    None,
    None,
    None,
    Some(&WORD_ADVI_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_ADVO_NODE),
    None,
    None,
    None,
    Some(&WORD_ADVS_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_ADVS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ADVS_CHILDREN),
    value: None,
};

pub static WORD_ADVS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ior"),
        dictgen::InsensitiveStr::Ascii("iors"),
    ],
    values: &[&["advisor"], &["advisors"]],
    range: 3..=4,
};

static WORD_ADVO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ADVO_CHILDREN),
    value: None,
};

pub static WORD_ADVO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cade"),
        dictgen::InsensitiveStr::Ascii("cats"),
        dictgen::InsensitiveStr::Ascii("cay"),
    ],
    values: &[&["advocated"], &["advocates"], &["advocacy"]],
    range: 3..=4,
};

static WORD_ADVI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ADVI_CHILDREN),
    value: None,
};

pub static WORD_ADVI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cable"),
        dictgen::InsensitiveStr::Ascii("ced"),
        dictgen::InsensitiveStr::Ascii("cing"),
        dictgen::InsensitiveStr::Ascii("rtisement"),
        dictgen::InsensitiveStr::Ascii("seable"),
        dictgen::InsensitiveStr::Ascii("seer"),
        dictgen::InsensitiveStr::Ascii("seur"),
        dictgen::InsensitiveStr::Ascii("soriy"),
        dictgen::InsensitiveStr::Ascii("soriyes"),
        dictgen::InsensitiveStr::Ascii("sorys"),
        dictgen::InsensitiveStr::Ascii("zable"),
    ],
    values: &[
        &["advisable"],
        &["advised"],
        &["advising"],
        &["advertisement"],
        &["advisable"],
        &["adviser"],
        &["adviser"],
        &["advisory", "advisories"],
        &["advisories"],
        &["advisors"],
        &["advisable"],
    ],
    range: 3..=9,
};

static WORD_ADVE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ADVE_CHILDREN),
    value: None,
};

pub static WORD_ADVE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ntageous"),
        dictgen::InsensitiveStr::Ascii("ntages"),
        dictgen::InsensitiveStr::Ascii("ntagous"),
        dictgen::InsensitiveStr::Ascii("ntagously"),
        dictgen::InsensitiveStr::Ascii("nterous"),
        dictgen::InsensitiveStr::Ascii("ntourus"),
        dictgen::InsensitiveStr::Ascii("ntrous"),
        dictgen::InsensitiveStr::Ascii("ntrues"),
        dictgen::InsensitiveStr::Ascii("ntue"),
        dictgen::InsensitiveStr::Ascii("ntuers"),
        dictgen::InsensitiveStr::Ascii("ntuous"),
        dictgen::InsensitiveStr::Ascii("ntureous"),
        dictgen::InsensitiveStr::Ascii("ntureres"),
        dictgen::InsensitiveStr::Ascii("nturious"),
        dictgen::InsensitiveStr::Ascii("nturos"),
        dictgen::InsensitiveStr::Ascii("nturs"),
        dictgen::InsensitiveStr::Ascii("nturuous"),
        dictgen::InsensitiveStr::Ascii("nturus"),
        dictgen::InsensitiveStr::Ascii("ntus"),
        dictgen::InsensitiveStr::Ascii("rised"),
        dictgen::InsensitiveStr::Ascii("risty"),
        dictgen::InsensitiveStr::Ascii("rsiting"),
        dictgen::InsensitiveStr::Ascii("rst"),
        dictgen::InsensitiveStr::Ascii("rtice"),
        dictgen::InsensitiveStr::Ascii("rticed"),
        dictgen::InsensitiveStr::Ascii("rticement"),
        dictgen::InsensitiveStr::Ascii("rtis"),
        dictgen::InsensitiveStr::Ascii("rtisiers"),
        dictgen::InsensitiveStr::Ascii("rtisiment"),
        dictgen::InsensitiveStr::Ascii("rtisment"),
        dictgen::InsensitiveStr::Ascii("rtisments"),
        dictgen::InsensitiveStr::Ascii("rtisors"),
        dictgen::InsensitiveStr::Ascii("rtisted"),
        dictgen::InsensitiveStr::Ascii("rtisters"),
        dictgen::InsensitiveStr::Ascii("rtisting"),
        dictgen::InsensitiveStr::Ascii("rtistment"),
        dictgen::InsensitiveStr::Ascii("rtistments"),
        dictgen::InsensitiveStr::Ascii("rtisy"),
        dictgen::InsensitiveStr::Ascii("sary"),
        dictgen::InsensitiveStr::Ascii("tise"),
    ],
    values: &[
        &["advantageous"],
        &["advantages"],
        &["advantageous"],
        &["advantageously"],
        &["adventures"],
        &["adventurous"],
        &["adventurous"],
        &["adventures"],
        &["adventures"],
        &["adventures"],
        &["adventurous"],
        &["adventures"],
        &["adventures"],
        &["adventurous"],
        &["adventurous"],
        &["adventures"],
        &["adventurous"],
        &["adventurous"],
        &["adventures"],
        &["advertised"],
        &["adversity"],
        &["advertising"],
        &["adverts"],
        &["advertise"],
        &["advertised"],
        &["advertisement"],
        &["adverts"],
        &["advertisers"],
        &["advertisement"],
        &["advertisement"],
        &["advertisements"],
        &["advertisers"],
        &["advertised"],
        &["advertisers"],
        &["advertising"],
        &["advertisement"],
        &["advertisements"],
        &["adversity"],
        &["adversary"],
        &["advertise"],
    ],
    range: 3..=10,
};

static WORD_ADVA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ADVA_CHILDREN),
    value: None,
};

pub static WORD_ADVA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("natage"),
        dictgen::InsensitiveStr::Ascii("natages"),
        dictgen::InsensitiveStr::Ascii("natge"),
        dictgen::InsensitiveStr::Ascii("ndced"),
        dictgen::InsensitiveStr::Ascii("ne"),
        dictgen::InsensitiveStr::Ascii("ned"),
        dictgen::InsensitiveStr::Ascii("ntadges"),
        dictgen::InsensitiveStr::Ascii("ntageos"),
        dictgen::InsensitiveStr::Ascii("ntageus"),
        dictgen::InsensitiveStr::Ascii("ntagious"),
        dictgen::InsensitiveStr::Ascii("ntagous"),
        dictgen::InsensitiveStr::Ascii("ntegeous"),
        dictgen::InsensitiveStr::Ascii("nteges"),
        dictgen::InsensitiveStr::Ascii("nved"),
        dictgen::InsensitiveStr::Ascii("tange"),
        dictgen::InsensitiveStr::Ascii("tanges"),
    ],
    values: &[
        &["advantage"],
        &["advantages"],
        &["advantage"],
        &["advanced"],
        &["advance"],
        &["advanced"],
        &["advantages"],
        &["advantageous"],
        &["advantageous"],
        &["advantageous"],
        &["advantageous"],
        &["advantageous"],
        &["advantages"],
        &["advanced"],
        &["advantage"],
        &["advantages"],
    ],
    range: 2..=8,
};

static WORD_ADU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ADU_CHILDREN),
    value: None,
};

pub static WORD_ADU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("iobook"),
        dictgen::InsensitiveStr::Ascii("ltey"),
        dictgen::InsensitiveStr::Ascii("ltrey"),
        dictgen::InsensitiveStr::Ascii("sted"),
        dictgen::InsensitiveStr::Ascii("stment"),
    ],
    values: &[
        &["audiobook"],
        &["adultery"],
        &["adultery"],
        &["adjusted"],
        &["adjustment"],
    ],
    range: 4..=6,
};

static WORD_ADT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ADT_CHILDREN),
    value: None,
};

pub static WORD_ADT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("er"),
        dictgen::InsensitiveStr::Ascii("odetect"),
    ],
    values: &[&["after"], &["autodetect"]],
    range: 2..=7,
};

static WORD_ADR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ADR_CHILDREN),
    value: None,
};

pub static WORD_ADR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ea"),
        dictgen::InsensitiveStr::Ascii("eanline"),
        dictgen::InsensitiveStr::Ascii("elanine"),
        dictgen::InsensitiveStr::Ascii("eneline"),
        dictgen::InsensitiveStr::Ascii("eniline"),
        dictgen::InsensitiveStr::Ascii("erss"),
        dictgen::InsensitiveStr::Ascii("erssed"),
        dictgen::InsensitiveStr::Ascii("ersser"),
        dictgen::InsensitiveStr::Ascii("ersses"),
        dictgen::InsensitiveStr::Ascii("erssing"),
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("esable"),
        dictgen::InsensitiveStr::Ascii("esing"),
        dictgen::InsensitiveStr::Ascii("ess"),
        dictgen::InsensitiveStr::Ascii("essable"),
        dictgen::InsensitiveStr::Ascii("esse"),
        dictgen::InsensitiveStr::Ascii("essed"),
        dictgen::InsensitiveStr::Ascii("esses"),
        dictgen::InsensitiveStr::Ascii("essing"),
        dictgen::InsensitiveStr::Ascii("esss"),
        dictgen::InsensitiveStr::Ascii("essses"),
        dictgen::InsensitiveStr::Ascii("oable"),
        dictgen::InsensitiveStr::Ascii("ress"),
        dictgen::InsensitiveStr::Ascii("resses"),
    ],
    values: &[
        &["area"],
        &["adrenaline"],
        &["adrenaline"],
        &["adrenaline"],
        &["adrenaline"],
        &["address"],
        &["addressed"],
        &["addresser"],
        &["addresses"],
        &["addressing"],
        &["address"],
        &["addressable"],
        &["addressing"],
        &["address"],
        &["addressable"],
        &["address"],
        &["addressed"],
        &["addresses"],
        &["addressing"],
        &["address"],
        &["addresses"],
        &["adorable"],
        &["address"],
        &["addresses"],
    ],
    range: 2..=7,
};

static WORD_ADQ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ADQ_CHILDREN),
    value: None,
};

pub static WORD_ADQ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("uire"),
        dictgen::InsensitiveStr::Ascii("uired"),
        dictgen::InsensitiveStr::Ascii("uires"),
        dictgen::InsensitiveStr::Ascii("uiring"),
    ],
    values: &[&["acquire"], &["acquired"], &["acquires"], &["acquiring"]],
    range: 4..=6,
};

static WORD_ADP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ADP_CHILDREN),
    value: None,
};

pub static WORD_ADP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("apted"),
        dictgen::InsensitiveStr::Ascii("at"),
        dictgen::InsensitiveStr::Ascii("atation"),
        dictgen::InsensitiveStr::Ascii("ated"),
        dictgen::InsensitiveStr::Ascii("ater"),
        dictgen::InsensitiveStr::Ascii("aters"),
        dictgen::InsensitiveStr::Ascii("ats"),
        dictgen::InsensitiveStr::Ascii("ter"),
    ],
    values: &[
        &["adapted"],
        &["adapt"],
        &["adaptation"],
        &["adapted"],
        &["adapter"],
        &["adapters"],
        &["adapts"],
        &["adapter"],
    ],
    range: 2..=7,
};

static WORD_ADO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ADO_CHILDREN),
    value: None,
};

pub static WORD_ADO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("bted"),
        dictgen::InsensitiveStr::Ascii("lecent"),
        dictgen::InsensitiveStr::Ascii("lence"),
        dictgen::InsensitiveStr::Ascii("lencence"),
        dictgen::InsensitiveStr::Ascii("lencent"),
        dictgen::InsensitiveStr::Ascii("lescance"),
        dictgen::InsensitiveStr::Ascii("lescant"),
        dictgen::InsensitiveStr::Ascii("lescene"),
        dictgen::InsensitiveStr::Ascii("lescense"),
        dictgen::InsensitiveStr::Ascii("loscent"),
        dictgen::InsensitiveStr::Ascii("lsecent"),
        dictgen::InsensitiveStr::Ascii("ptor"),
        dictgen::InsensitiveStr::Ascii("ptors"),
        dictgen::InsensitiveStr::Ascii("rbale"),
        dictgen::InsensitiveStr::Ascii("vcacy"),
        dictgen::InsensitiveStr::Ascii("vcated"),
        dictgen::InsensitiveStr::Ascii("vcates"),
    ],
    values: &[
        &["adopted"],
        &["adolescent"],
        &["adolescent"],
        &["adolescence"],
        &["adolescent"],
        &["adolescence"],
        &["adolescent"],
        &["adolescence"],
        &["adolescence"],
        &["adolescent"],
        &["adolescent"],
        &["adopter", "adaptor"],
        &["adopters", "adaptors"],
        &["adorable"],
        &["advocacy"],
        &["advocated"],
        &["advocates"],
    ],
    range: 4..=8,
};

static WORD_ADN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ADN_CHILDREN),
    value: Some(&["and"]),
};

pub static WORD_ADN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("imistrator")],
    values: &[&["administrators"]],
    range: 10..=10,
};

static WORD_ADM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_ADM_CHILDREN),
    value: None,
};

static WORD_ADM_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    None,
    None,
    Some(&WORD_ADME_NODE),
    None,
    None,
    None,
    Some(&WORD_ADMI_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_ADMN_NODE),
    None,
    None,
    None,
    Some(&WORD_ADMR_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_ADMR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ADMR_CHILDREN),
    value: None,
};

pub static WORD_ADMR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ial")],
    values: &[&["admiral"]],
    range: 3..=3,
};

static WORD_ADMN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ADMN_CHILDREN),
    value: Some(&["admin"]),
};

pub static WORD_ADMN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("istrator"),
        dictgen::InsensitiveStr::Ascii("istrators"),
    ],
    values: &[&["administrator"], &["administrators"]],
    range: 8..=9,
};

static WORD_ADMI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ADMI_CHILDREN),
    value: Some(&["admin"]),
};

pub static WORD_ADMI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("nastrator"),
        dictgen::InsensitiveStr::Ascii("ng"),
        dictgen::InsensitiveStr::Ascii("ninistrative"),
        dictgen::InsensitiveStr::Ascii("ninistrator"),
        dictgen::InsensitiveStr::Ascii("ninistrators"),
        dictgen::InsensitiveStr::Ascii("ninstrator"),
        dictgen::InsensitiveStr::Ascii("nistartion"),
        dictgen::InsensitiveStr::Ascii("nistartor"),
        dictgen::InsensitiveStr::Ascii("nistartors"),
        dictgen::InsensitiveStr::Ascii("nistation"),
        dictgen::InsensitiveStr::Ascii("nistator"),
        dictgen::InsensitiveStr::Ascii("nisted"),
        dictgen::InsensitiveStr::Ascii("nisterd"),
        dictgen::InsensitiveStr::Ascii("nistor"),
        dictgen::InsensitiveStr::Ascii("nistored"),
        dictgen::InsensitiveStr::Ascii("nistr"),
        dictgen::InsensitiveStr::Ascii("nistraion"),
        dictgen::InsensitiveStr::Ascii("nistraively"),
        dictgen::InsensitiveStr::Ascii("nistrar"),
        dictgen::InsensitiveStr::Ascii("nistraron"),
        dictgen::InsensitiveStr::Ascii("nistrater"),
        dictgen::InsensitiveStr::Ascii("nistraters"),
        dictgen::InsensitiveStr::Ascii("nistratief"),
        dictgen::InsensitiveStr::Ascii("nistratiei"),
        dictgen::InsensitiveStr::Ascii("nistratieve"),
        dictgen::InsensitiveStr::Ascii("nistratio"),
        dictgen::InsensitiveStr::Ascii("nistratior"),
        dictgen::InsensitiveStr::Ascii("nistratiors"),
        dictgen::InsensitiveStr::Ascii("nistrativne"),
        dictgen::InsensitiveStr::Ascii("nistrativo"),
        dictgen::InsensitiveStr::Ascii("nistraton"),
        dictgen::InsensitiveStr::Ascii("nistre"),
        dictgen::InsensitiveStr::Ascii("nistren"),
        dictgen::InsensitiveStr::Ascii("nistrer"),
        dictgen::InsensitiveStr::Ascii("nistres"),
        dictgen::InsensitiveStr::Ascii("nistrez"),
        dictgen::InsensitiveStr::Ascii("nistro"),
        dictgen::InsensitiveStr::Ascii("nitrator"),
        dictgen::InsensitiveStr::Ascii("nsiter"),
        dictgen::InsensitiveStr::Ascii("nsitered"),
        dictgen::InsensitiveStr::Ascii("nsitration"),
        dictgen::InsensitiveStr::Ascii("nsitrative"),
        dictgen::InsensitiveStr::Ascii("nsitrator"),
        dictgen::InsensitiveStr::Ascii("nsitrators"),
        dictgen::InsensitiveStr::Ascii("nssion"),
        dictgen::InsensitiveStr::Ascii("nstered"),
        dictgen::InsensitiveStr::Ascii("nstrate"),
        dictgen::InsensitiveStr::Ascii("nstration"),
        dictgen::InsensitiveStr::Ascii("nstrative"),
        dictgen::InsensitiveStr::Ascii("nstrator"),
        dictgen::InsensitiveStr::Ascii("nstrators"),
        dictgen::InsensitiveStr::Ascii("raal"),
        dictgen::InsensitiveStr::Ascii("sible"),
        dictgen::InsensitiveStr::Ascii("ssability"),
        dictgen::InsensitiveStr::Ascii("ssable"),
        dictgen::InsensitiveStr::Ascii("ted"),
        dictgen::InsensitiveStr::Ascii("tedly"),
        dictgen::InsensitiveStr::Ascii("ttadely"),
        dictgen::InsensitiveStr::Ascii("ttadly"),
        dictgen::InsensitiveStr::Ascii("ttetly"),
        dictgen::InsensitiveStr::Ascii("ttidly"),
    ],
    values: &[
        &["administrator"],
        &["admin"],
        &["administrative"],
        &["administrator"],
        &["administrators"],
        &["administrator"],
        &["administration"],
        &["administrator"],
        &["administrators"],
        &["administration"],
        &["administrator"],
        &["administered"],
        &["administered"],
        &["administer", "administrator"],
        &["administer"],
        &["administer"],
        &["administration"],
        &["administratively"],
        &["administrator"],
        &["administrator"],
        &["administrator"],
        &["administrators"],
        &["administrative"],
        &["administrative"],
        &["administrative"],
        &["administrator"],
        &["administrator"],
        &["administrators"],
        &["administrative"],
        &["administration"],
        &["administration"],
        &["administer"],
        &["administer"],
        &["administer"],
        &["administer"],
        &["administer"],
        &["administer"],
        &["administrator"],
        &["administer"],
        &["administered"],
        &["administration"],
        &["administrative"],
        &["administrator"],
        &["administrators"],
        &["admission"],
        &["administered"],
        &["administrate"],
        &["administration"],
        &["administrative"],
        &["administrator"],
        &["administrators"],
        &["admiral"],
        &["admissible"],
        &["admissibility"],
        &["admissible"],
        &["admitted"],
        &["admittedly"],
        &["admittedly"],
        &["admittedly"],
        &["admittedly"],
        &["admittedly"],
    ],
    range: 2..=12,
};

static WORD_ADME_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ADME_CHILDREN),
    value: None,
};

pub static WORD_ADME_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ndment")],
    values: &[&["amendment"]],
    range: 6..=6,
};

static WORD_ADK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ADK_CHILDREN),
    value: None,
};

pub static WORD_ADK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("nowledged"),
        dictgen::InsensitiveStr::Ascii("nowledges"),
    ],
    values: &[&["acknowledged"], &["acknowledges"]],
    range: 9..=9,
};

static WORD_ADJ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ADJ_CHILDREN),
    value: None,
};

pub static WORD_ADJ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("acancy"),
        dictgen::InsensitiveStr::Ascii("acentcy"),
        dictgen::InsensitiveStr::Ascii("acentsy"),
        dictgen::InsensitiveStr::Ascii("actend"),
        dictgen::InsensitiveStr::Ascii("ancent"),
        dictgen::InsensitiveStr::Ascii("asant"),
        dictgen::InsensitiveStr::Ascii("asantly"),
        dictgen::InsensitiveStr::Ascii("ascent"),
        dictgen::InsensitiveStr::Ascii("ascently"),
        dictgen::InsensitiveStr::Ascii("asence"),
        dictgen::InsensitiveStr::Ascii("asencies"),
        dictgen::InsensitiveStr::Ascii("asensy"),
        dictgen::InsensitiveStr::Ascii("asent"),
        dictgen::InsensitiveStr::Ascii("ast"),
        dictgen::InsensitiveStr::Ascii("atate"),
        dictgen::InsensitiveStr::Ascii("atated"),
        dictgen::InsensitiveStr::Ascii("atates"),
        dictgen::InsensitiveStr::Ascii("atating"),
        dictgen::InsensitiveStr::Ascii("ative"),
        dictgen::InsensitiveStr::Ascii("cence"),
        dictgen::InsensitiveStr::Ascii("cencies"),
        dictgen::InsensitiveStr::Ascii("cent"),
        dictgen::InsensitiveStr::Ascii("centcy"),
        dictgen::InsensitiveStr::Ascii("ecent"),
        dictgen::InsensitiveStr::Ascii("ectiveus"),
        dictgen::InsensitiveStr::Ascii("ectivos"),
        dictgen::InsensitiveStr::Ascii("ectivs"),
        dictgen::InsensitiveStr::Ascii("ency"),
        dictgen::InsensitiveStr::Ascii("sence"),
        dictgen::InsensitiveStr::Ascii("sencies"),
        dictgen::InsensitiveStr::Ascii("suted"),
        dictgen::InsensitiveStr::Ascii("uscent"),
        dictgen::InsensitiveStr::Ascii("usment"),
        dictgen::InsensitiveStr::Ascii("ustabe"),
        dictgen::InsensitiveStr::Ascii("ustement"),
        dictgen::InsensitiveStr::Ascii("ustements"),
        dictgen::InsensitiveStr::Ascii("ustes"),
        dictgen::InsensitiveStr::Ascii("ustible"),
        dictgen::InsensitiveStr::Ascii("ustificat"),
        dictgen::InsensitiveStr::Ascii("ustification"),
        dictgen::InsensitiveStr::Ascii("ustmant"),
        dictgen::InsensitiveStr::Ascii("ustmants"),
        dictgen::InsensitiveStr::Ascii("ustmenet"),
    ],
    values: &[
        &["adjacency"],
        &["adjacency", "adjacence"],
        &["adjacency"],
        &["adjacent"],
        &["adjacent"],
        &["adjacent"],
        &["adjacently"],
        &["adjacent"],
        &["adjacently"],
        &["adjacence"],
        &["adjacencies"],
        &["adjacency"],
        &["adjacent"],
        &["adjust"],
        &["agitate"],
        &["agitated"],
        &["agitates"],
        &["agitating"],
        &["adjective"],
        &["adjacence"],
        &["adjacencies"],
        &["adjacent"],
        &["adjacency"],
        &["adjacent"],
        &["adjectives"],
        &["adjectives"],
        &["adjectives"],
        &["adjacency", "agency"],
        &["adjacence"],
        &["adjacencies"],
        &["adjusted"],
        &["adjacent"],
        &["adjustment"],
        &["adjustable"],
        &["adjustment"],
        &["adjustments"],
        &["adjusted", "adjusts"],
        &["adjustable"],
        &["justification"],
        &["justification"],
        &["adjustment"],
        &["adjustments"],
        &["adjustment"],
    ],
    range: 3..=12,
};

static WORD_ADI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ADI_CHILDREN),
    value: None,
};

pub static WORD_ADI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("acent"),
        dictgen::InsensitiveStr::Ascii("diton"),
        dictgen::InsensitiveStr::Ascii("n"),
        dictgen::InsensitiveStr::Ascii("ng"),
        dictgen::InsensitiveStr::Ascii("tion"),
        dictgen::InsensitiveStr::Ascii("tional"),
        dictgen::InsensitiveStr::Ascii("tionally"),
        dictgen::InsensitiveStr::Ascii("tionaly"),
        dictgen::InsensitiveStr::Ascii("tionnal"),
        dictgen::InsensitiveStr::Ascii("vce"),
        dictgen::InsensitiveStr::Ascii("vser"),
        dictgen::InsensitiveStr::Ascii("vsor"),
        dictgen::InsensitiveStr::Ascii("vsories"),
        dictgen::InsensitiveStr::Ascii("vsoriy"),
        dictgen::InsensitiveStr::Ascii("vsoriyes"),
        dictgen::InsensitiveStr::Ascii("vsors"),
        dictgen::InsensitiveStr::Ascii("vsory"),
    ],
    values: &[
        &["adjacent"],
        &["addition"],
        &["admin"],
        &["adding"],
        &["addition"],
        &["additional"],
        &["additionally"],
        &["additionally"],
        &["additional"],
        &["advice", "advise"],
        &["adviser"],
        &["advisor"],
        &["advisories"],
        &["advisory", "advisories"],
        &["advisories"],
        &["advisors"],
        &["advisory"],
    ],
    range: 1..=8,
};

static WORD_ADH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ADH_CHILDREN),
    value: None,
};

pub static WORD_ADH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("earing"),
        dictgen::InsensitiveStr::Ascii("easive"),
        dictgen::InsensitiveStr::Ascii("easives"),
        dictgen::InsensitiveStr::Ascii("eisve"),
        dictgen::InsensitiveStr::Ascii("erance"),
        dictgen::InsensitiveStr::Ascii("evise"),
    ],
    values: &[
        &["adhering"],
        &["adhesive"],
        &["adhesives"],
        &["adhesive"],
        &["adherence"],
        &["adhesive"],
    ],
    range: 5..=7,
};

static WORD_ADG_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ADG_CHILDREN),
    value: None,
};

pub static WORD_ADG_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("es"),
    ],
    values: &[&["edge", "badge", "adage"], &["edges", "badges", "adages"]],
    range: 1..=2,
};

static WORD_ADF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ADF_CHILDREN),
    value: None,
};

pub static WORD_ADF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ter")],
    values: &[&["after"]],
    range: 3..=3,
};

static WORD_ADE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ADE_CHILDREN),
    value: None,
};

pub static WORD_ADE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("alide"),
        dictgen::InsensitiveStr::Ascii("cuate"),
        dictgen::InsensitiveStr::Ascii("d"),
        dictgen::InsensitiveStr::Ascii("ilade"),
        dictgen::InsensitiveStr::Ascii("ladie"),
        dictgen::InsensitiveStr::Ascii("liade"),
        dictgen::InsensitiveStr::Ascii("qaute"),
        dictgen::InsensitiveStr::Ascii("quatedly"),
        dictgen::InsensitiveStr::Ascii("quatley"),
        dictgen::InsensitiveStr::Ascii("quet"),
        dictgen::InsensitiveStr::Ascii("quetely"),
        dictgen::InsensitiveStr::Ascii("quit"),
        dictgen::InsensitiveStr::Ascii("quitely"),
        dictgen::InsensitiveStr::Ascii("rnaline"),
        dictgen::InsensitiveStr::Ascii("vnture"),
        dictgen::InsensitiveStr::Ascii("vntured"),
        dictgen::InsensitiveStr::Ascii("vnturer"),
        dictgen::InsensitiveStr::Ascii("vnturers"),
        dictgen::InsensitiveStr::Ascii("vntures"),
        dictgen::InsensitiveStr::Ascii("vnturing"),
        dictgen::InsensitiveStr::Ascii("w"),
    ],
    values: &[
        &["adelaide"],
        &["adequate"],
        &["added"],
        &["adelaide"],
        &["adelaide"],
        &["adelaide"],
        &["adequate"],
        &["adequately"],
        &["adequately"],
        &["adequate"],
        &["adequately"],
        &["adequate"],
        &["adequately"],
        &["adrenaline"],
        &["adventure"],
        &["adventured"],
        &["adventurer"],
        &["adventurers"],
        &["adventures"],
        &["adventuring"],
        &["adieu"],
    ],
    range: 1..=8,
};

static WORD_ADD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_ADD_CHILDREN),
    value: None,
};

static WORD_ADD_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_ADDA_NODE),
    None,
    Some(&WORD_ADDC_NODE),
    Some(&WORD_ADDD_NODE),
    Some(&WORD_ADDE_NODE),
    None,
    None,
    None,
    Some(&WORD_ADDI_NODE),
    Some(&WORD_ADDJ_NODE),
    None,
    None,
    Some(&WORD_ADDM_NODE),
    Some(&WORD_ADDN_NODE),
    Some(&WORD_ADDO_NODE),
    Some(&WORD_ADDP_NODE),
    None,
    Some(&WORD_ADDR_NODE),
    None,
    Some(&WORD_ADDT_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_ADDT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ADDT_CHILDREN),
    value: None,
};

pub static WORD_ADDT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("ion"),
        dictgen::InsensitiveStr::Ascii("ional"),
        dictgen::InsensitiveStr::Ascii("ionally"),
        dictgen::InsensitiveStr::Ascii("itional"),
    ],
    values: &[
        &["added"],
        &["addition"],
        &["additional"],
        &["additionally"],
        &["additional"],
    ],
    range: 2..=7,
};

static WORD_ADDR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ADDR_CHILDREN),
    value: None,
};

pub static WORD_ADDR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ass"),
        dictgen::InsensitiveStr::Ascii("ees"),
        dictgen::InsensitiveStr::Ascii("eess"),
        dictgen::InsensitiveStr::Ascii("erss"),
        dictgen::InsensitiveStr::Ascii("erssed"),
        dictgen::InsensitiveStr::Ascii("ersser"),
        dictgen::InsensitiveStr::Ascii("ersses"),
        dictgen::InsensitiveStr::Ascii("erssing"),
        dictgen::InsensitiveStr::Ascii("ersss"),
        dictgen::InsensitiveStr::Ascii("ersssed"),
        dictgen::InsensitiveStr::Ascii("erssser"),
        dictgen::InsensitiveStr::Ascii("erssses"),
        dictgen::InsensitiveStr::Ascii("ersssing"),
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("esable"),
        dictgen::InsensitiveStr::Ascii("esed"),
        dictgen::InsensitiveStr::Ascii("eses"),
        dictgen::InsensitiveStr::Ascii("esesd"),
        dictgen::InsensitiveStr::Ascii("esess"),
        dictgen::InsensitiveStr::Ascii("esing"),
        dictgen::InsensitiveStr::Ascii("esse"),
        dictgen::InsensitiveStr::Ascii("essess"),
        dictgen::InsensitiveStr::Ascii("essibility"),
        dictgen::InsensitiveStr::Ascii("essible"),
        dictgen::InsensitiveStr::Ascii("essings"),
        dictgen::InsensitiveStr::Ascii("esss"),
        dictgen::InsensitiveStr::Ascii("esssed"),
        dictgen::InsensitiveStr::Ascii("essses"),
        dictgen::InsensitiveStr::Ascii("esssing"),
        dictgen::InsensitiveStr::Ascii("ress"),
        dictgen::InsensitiveStr::Ascii("ss"),
        dictgen::InsensitiveStr::Ascii("ssed"),
        dictgen::InsensitiveStr::Ascii("sses"),
        dictgen::InsensitiveStr::Ascii("ssing"),
    ],
    values: &[
        &["address"],
        &["address"],
        &["address"],
        &["address"],
        &["addressed"],
        &["addresser"],
        &["addresses"],
        &["addressing"],
        &["address"],
        &["addressed"],
        &["addresser"],
        &["addresses"],
        &["addressing"],
        &["address"],
        &["addressable"],
        &["addressed"],
        &["addresses"],
        &["addressed"],
        &["addresses"],
        &["addressing"],
        &["addresses", "address"],
        &["addresses"],
        &["addressability"],
        &["addressable"],
        &["addressing"],
        &["address"],
        &["addressed"],
        &["addresses"],
        &["addressing"],
        &["address"],
        &["address"],
        &["addressed"],
        &["addresses"],
        &["addressing"],
    ],
    range: 2..=10,
};

static WORD_ADDP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ADDP_CHILDREN),
    value: None,
};

pub static WORD_ADDP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ress")],
    values: &[&["address"]],
    range: 4..=4,
};

static WORD_ADDO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ADDO_CHILDREN),
    value: None,
};

pub static WORD_ADDO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("nts"),
        dictgen::InsensitiveStr::Ascii("pt"),
        dictgen::InsensitiveStr::Ascii("pted"),
        dictgen::InsensitiveStr::Ascii("ptive"),
        dictgen::InsensitiveStr::Ascii("s"),
    ],
    values: &[
        &["addons"],
        &["adopt"],
        &["adopted"],
        &["adoptive", "adaptive"],
        &["addons"],
    ],
    range: 1..=5,
};

static WORD_ADDN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ADDN_CHILDREN),
    value: None,
};

pub static WORD_ADDN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("os")],
    values: &[&["addons"]],
    range: 2..=2,
};

static WORD_ADDM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ADDM_CHILDREN),
    value: None,
};

pub static WORD_ADDM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ission"),
        dictgen::InsensitiveStr::Ascii("it"),
    ],
    values: &[&["admission"], &["admit"]],
    range: 2..=6,
};

static WORD_ADDJ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ADDJ_CHILDREN),
    value: None,
};

pub static WORD_ADDJ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ust"),
        dictgen::InsensitiveStr::Ascii("usted"),
        dictgen::InsensitiveStr::Ascii("usting"),
        dictgen::InsensitiveStr::Ascii("usts"),
    ],
    values: &[&["adjust"], &["adjusted"], &["adjusting"], &["adjusts"]],
    range: 3..=6,
};

static WORD_ADDI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ADDI_CHILDREN),
    value: None,
};

pub static WORD_ADDI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("citons"),
        dictgen::InsensitiveStr::Ascii("ctes"),
        dictgen::InsensitiveStr::Ascii("ctin"),
        dictgen::InsensitiveStr::Ascii("ctis"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("g"),
        dictgen::InsensitiveStr::Ascii("ional"),
        dictgen::InsensitiveStr::Ascii("iton"),
        dictgen::InsensitiveStr::Ascii("itonall"),
        dictgen::InsensitiveStr::Ascii("onal"),
        dictgen::InsensitiveStr::Ascii("onally"),
        dictgen::InsensitiveStr::Ascii("otion"),
        dictgen::InsensitiveStr::Ascii("otional"),
        dictgen::InsensitiveStr::Ascii("otionally"),
        dictgen::InsensitiveStr::Ascii("otions"),
        dictgen::InsensitiveStr::Ascii("tianal"),
        dictgen::InsensitiveStr::Ascii("tianally"),
        dictgen::InsensitiveStr::Ascii("tinal"),
        dictgen::InsensitiveStr::Ascii("tinally"),
        dictgen::InsensitiveStr::Ascii("tioanal"),
        dictgen::InsensitiveStr::Ascii("tioanally"),
        dictgen::InsensitiveStr::Ascii("tioanl"),
        dictgen::InsensitiveStr::Ascii("tioanlly"),
        dictgen::InsensitiveStr::Ascii("tiona"),
        dictgen::InsensitiveStr::Ascii("tionallly"),
        dictgen::InsensitiveStr::Ascii("tionals"),
        dictgen::InsensitiveStr::Ascii("tionaly"),
        dictgen::InsensitiveStr::Ascii("tionalyy"),
        dictgen::InsensitiveStr::Ascii("tionnal"),
        dictgen::InsensitiveStr::Ascii("tionnally"),
        dictgen::InsensitiveStr::Ascii("tionnaly"),
        dictgen::InsensitiveStr::Ascii("tivies"),
        dictgen::InsensitiveStr::Ascii("tivley"),
        dictgen::InsensitiveStr::Ascii("toin"),
        dictgen::InsensitiveStr::Ascii("toinal"),
        dictgen::InsensitiveStr::Ascii("toinally"),
        dictgen::InsensitiveStr::Ascii("toinaly"),
        dictgen::InsensitiveStr::Ascii("ton"),
        dictgen::InsensitiveStr::Ascii("tonal"),
        dictgen::InsensitiveStr::Ascii("tonally"),
        dictgen::InsensitiveStr::Ascii("tonaly"),
        dictgen::InsensitiveStr::Ascii("ttions"),
    ],
    values: &[
        &["addictions"],
        &["addicts"],
        &["addictions"],
        &["addictions"],
        &["added"],
        &["adding"],
        &["additional"],
        &["addition"],
        &["additional"],
        &["additional"],
        &["additionally"],
        &["addition"],
        &["additional"],
        &["additionally"],
        &["additions"],
        &["additional"],
        &["additionally"],
        &["additional"],
        &["additionally"],
        &["additional"],
        &["additionally"],
        &["additional"],
        &["additionally"],
        &["additional"],
        &["additionally"],
        &["additional"],
        &["additionally"],
        &["additionally"],
        &["additional"],
        &["additionally"],
        &["additionally"],
        &["additive"],
        &["additive"],
        &["addition"],
        &["additional"],
        &["additionally"],
        &["additionally"],
        &["addition"],
        &["additional"],
        &["additionally"],
        &["additionally"],
        &["addictions"],
    ],
    range: 1..=9,
};

static WORD_ADDE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ADDE_CHILDREN),
    value: None,
};

pub static WORD_ADDE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("dd"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("rss"),
        dictgen::InsensitiveStr::Ascii("rsses"),
        dictgen::InsensitiveStr::Ascii("rt"),
        dictgen::InsensitiveStr::Ascii("rted"),
        dictgen::InsensitiveStr::Ascii("s"),
        dictgen::InsensitiveStr::Ascii("ss"),
        dictgen::InsensitiveStr::Ascii("ssed"),
        dictgen::InsensitiveStr::Ascii("sses"),
        dictgen::InsensitiveStr::Ascii("ssing"),
    ],
    values: &[
        &["added"],
        &["added"],
        &["address"],
        &["addresses"],
        &["assert"],
        &["asserted"],
        &["adds", "added", "adders", "address"],
        &["address"],
        &["addressed"],
        &["addresses"],
        &["addressing"],
    ],
    range: 1..=5,
};

static WORD_ADDD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ADDD_CHILDREN),
    value: Some(&["add"]),
};

pub static WORD_ADDD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("itional"),
        dictgen::InsensitiveStr::Ascii("ress"),
        dictgen::InsensitiveStr::Ascii("resses"),
        dictgen::InsensitiveStr::Ascii("s"),
    ],
    values: &[
        &["added"],
        &["adding"],
        &["additional"],
        &["address"],
        &["addresses"],
        &["adds"],
    ],
    range: 1..=7,
};

static WORD_ADDC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ADDC_CHILDREN),
    value: None,
};

pub static WORD_ADDC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("its")],
    values: &[&["addicts"]],
    range: 3..=3,
};

static WORD_ADDA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ADDA_CHILDREN),
    value: None,
};

pub static WORD_ADDA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("pt"),
        dictgen::InsensitiveStr::Ascii("ptation"),
        dictgen::InsensitiveStr::Ascii("ptations"),
        dictgen::InsensitiveStr::Ascii("pted"),
        dictgen::InsensitiveStr::Ascii("pting"),
        dictgen::InsensitiveStr::Ascii("pts"),
    ],
    values: &[
        &["adapt"],
        &["adaptation"],
        &["adaptations"],
        &["adapted"],
        &["adapting"],
        &["adapts"],
    ],
    range: 2..=8,
};

static WORD_ADB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ADB_CHILDREN),
    value: None,
};

pub static WORD_ADB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("andon"),
        dictgen::InsensitiveStr::Ascii("omen"),
        dictgen::InsensitiveStr::Ascii("ominal"),
        dictgen::InsensitiveStr::Ascii("ucted"),
    ],
    values: &[&["abandon"], &["abdomen"], &["abdominal"], &["abducted"]],
    range: 4..=6,
};

static WORD_ADA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ADA_CHILDREN),
    value: None,
};

pub static WORD_ADA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ment"),
        dictgen::InsensitiveStr::Ascii("mently"),
        dictgen::InsensitiveStr::Ascii("pated"),
        dictgen::InsensitiveStr::Ascii("pater"),
        dictgen::InsensitiveStr::Ascii("paters"),
        dictgen::InsensitiveStr::Ascii("pation"),
        dictgen::InsensitiveStr::Ascii("pations"),
        dictgen::InsensitiveStr::Ascii("pative"),
        dictgen::InsensitiveStr::Ascii("pd"),
        dictgen::InsensitiveStr::Ascii("pdive"),
        dictgen::InsensitiveStr::Ascii("ped"),
        dictgen::InsensitiveStr::Ascii("pive"),
        dictgen::InsensitiveStr::Ascii("ptacion"),
        dictgen::InsensitiveStr::Ascii("ptaion"),
        dictgen::InsensitiveStr::Ascii("ptare"),
        dictgen::InsensitiveStr::Ascii("ptating"),
        dictgen::InsensitiveStr::Ascii("pte"),
        dictgen::InsensitiveStr::Ascii("ptee"),
        dictgen::InsensitiveStr::Ascii("ptes"),
        dictgen::InsensitiveStr::Ascii("ptibe"),
        dictgen::InsensitiveStr::Ascii("ptove"),
        dictgen::InsensitiveStr::Ascii("quate"),
        dictgen::InsensitiveStr::Ascii("quately"),
        dictgen::InsensitiveStr::Ascii("quetely"),
        dictgen::InsensitiveStr::Ascii("quit"),
        dictgen::InsensitiveStr::Ascii("quitly"),
        dictgen::InsensitiveStr::Ascii("tper"),
        dictgen::InsensitiveStr::Ascii("tpers"),
        dictgen::InsensitiveStr::Ascii("vance"),
        dictgen::InsensitiveStr::Ascii("vanced"),
    ],
    values: &[
        &["adamant"],
        &["adamantly"],
        &["adapted"],
        &["adapter"],
        &["adapters"],
        &["adaptation", "adoption"],
        &["adaptations", "adoptions"],
        &["adaptive"],
        &["adapt", "adapted", "adopt", "adopted"],
        &["adaptive"],
        &["adapted", "adapt", "adopted", "adopt"],
        &["adaptive"],
        &["adaptation"],
        &["adaptation"],
        &["adapter"],
        &["adaptation"],
        &["adapter"],
        &["adapted"],
        &["adapters"],
        &["adaptive"],
        &["adaptive", "adoptive"],
        &["adequate"],
        &["adequately"],
        &["adequately"],
        &["adequate"],
        &["adequately"],
        &["adapter"],
        &["adapters"],
        &["advance"],
        &["advanced"],
    ],
    range: 2..=7,
};

static WORD_AC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_AC_CHILDREN),
    value: None,
};

static WORD_AC_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_ACA_NODE),
    None,
    Some(&WORD_ACC_NODE),
    Some(&WORD_ACD_NODE),
    Some(&WORD_ACE_NODE),
    Some(&WORD_ACF_NODE),
    None,
    Some(&WORD_ACH_NODE),
    Some(&WORD_ACI_NODE),
    None,
    Some(&WORD_ACK_NODE),
    Some(&WORD_ACL_NODE),
    None,
    Some(&WORD_ACN_NODE),
    Some(&WORD_ACO_NODE),
    None,
    Some(&WORD_ACQ_NODE),
    Some(&WORD_ACR_NODE),
    Some(&WORD_ACS_NODE),
    Some(&WORD_ACT_NODE),
    Some(&WORD_ACU_NODE),
    None,
    None,
    None,
    Some(&WORD_ACY_NODE),
    None,
];

static WORD_ACY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ACY_CHILDREN),
    value: None,
};

pub static WORD_ACY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("rlic")],
    values: &[&["acrylic"]],
    range: 4..=4,
};

static WORD_ACU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ACU_CHILDREN),
    value: None,
};

pub static WORD_ACU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("al"),
        dictgen::InsensitiveStr::Ascii("ally"),
        dictgen::InsensitiveStr::Ascii("ired"),
        dictgen::InsensitiveStr::Ascii("ires"),
        dictgen::InsensitiveStr::Ascii("malated"),
        dictgen::InsensitiveStr::Ascii("mulate"),
        dictgen::InsensitiveStr::Ascii("mulated"),
        dictgen::InsensitiveStr::Ascii("mulates"),
        dictgen::InsensitiveStr::Ascii("mulating"),
        dictgen::InsensitiveStr::Ascii("mulation"),
        dictgen::InsensitiveStr::Ascii("mulative"),
        dictgen::InsensitiveStr::Ascii("mulator"),
        dictgen::InsensitiveStr::Ascii("qire"),
        dictgen::InsensitiveStr::Ascii("racy"),
        dictgen::InsensitiveStr::Ascii("rate"),
        dictgen::InsensitiveStr::Ascii("sation"),
        dictgen::InsensitiveStr::Ascii("sed"),
        dictgen::InsensitiveStr::Ascii("sing"),
        dictgen::InsensitiveStr::Ascii("stom"),
        dictgen::InsensitiveStr::Ascii("stommed"),
        dictgen::InsensitiveStr::Ascii("tal"),
        dictgen::InsensitiveStr::Ascii("tality"),
        dictgen::InsensitiveStr::Ascii("tally"),
        dictgen::InsensitiveStr::Ascii("taly"),
        dictgen::InsensitiveStr::Ascii("tions"),
        dictgen::InsensitiveStr::Ascii("tual"),
    ],
    values: &[
        &["actual"],
        &["actually"],
        &["acquired"],
        &["acquires"],
        &["accumulated"],
        &["accumulate"],
        &["accumulated"],
        &["accumulates"],
        &["accumulating"],
        &["accumulation"],
        &["accumulative"],
        &["accumulator"],
        &["acquire"],
        &["accuracy"],
        &["accurate"],
        &["causation"],
        &["accused"],
        &["causing"],
        &["accustom"],
        &["accustomed"],
        &["actual"],
        &["actuality"],
        &["actually"],
        &["actually"],
        &["auctions"],
        &["actual"],
    ],
    range: 2..=8,
};

static WORD_ACT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_ACT_CHILDREN),
    value: None,
};

static WORD_ACT_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_ACTA_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_ACTI_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_ACTO_NODE),
    None,
    None,
    Some(&WORD_ACTR_NODE),
    None,
    None,
    Some(&WORD_ACTU_NODE),
    Some(&WORD_ACTV_NODE),
    None,
    None,
    None,
    Some(&WORD_ACTZ_NODE),
];

static WORD_ACTZ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ACTZ_CHILDREN),
    value: None,
};

pub static WORD_ACTZ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("al")],
    values: &[&["actual"]],
    range: 2..=2,
};

static WORD_ACTV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ACTV_CHILDREN),
    value: None,
};

pub static WORD_ACTV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("e"),
        dictgen::InsensitiveStr::Ascii("ie"),
    ],
    values: &[&["active"], &["active"]],
    range: 1..=2,
};

static WORD_ACTU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ACTU_CHILDREN),
    value: None,
};

pub static WORD_ACTU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("aal"),
        dictgen::InsensitiveStr::Ascii("aally"),
        dictgen::InsensitiveStr::Ascii("ak"),
        dictgen::InsensitiveStr::Ascii("akly"),
        dictgen::InsensitiveStr::Ascii("aley"),
        dictgen::InsensitiveStr::Ascii("aliy"),
        dictgen::InsensitiveStr::Ascii("alky"),
        dictgen::InsensitiveStr::Ascii("all"),
        dictgen::InsensitiveStr::Ascii("allin"),
        dictgen::InsensitiveStr::Ascii("almy"),
        dictgen::InsensitiveStr::Ascii("aloy"),
        dictgen::InsensitiveStr::Ascii("alpy"),
        dictgen::InsensitiveStr::Ascii("alty"),
        dictgen::InsensitiveStr::Ascii("aly"),
        dictgen::InsensitiveStr::Ascii("alyl"),
        dictgen::InsensitiveStr::Ascii("ell"),
        dictgen::InsensitiveStr::Ascii("ion"),
        dictgen::InsensitiveStr::Ascii("ionable"),
        dictgen::InsensitiveStr::Ascii("l"),
        dictgen::InsensitiveStr::Ascii("lay"),
        dictgen::InsensitiveStr::Ascii("llay"),
        dictgen::InsensitiveStr::Ascii("lly"),
        dictgen::InsensitiveStr::Ascii("ral"),
        dictgen::InsensitiveStr::Ascii("rally"),
        dictgen::InsensitiveStr::Ascii("sally"),
    ],
    values: &[
        &["actual"],
        &["actually"],
        &["actual"],
        &["actually"],
        &["actually"],
        &["actuality"],
        &["actually"],
        &["actually", "actual"],
        &["actually"],
        &["actually"],
        &["actually"],
        &["actually"],
        &["actually"],
        &["actually"],
        &["actually"],
        &["actual"],
        &["action"],
        &["actionable"],
        &["actual"],
        &["actually"],
        &["actually"],
        &["actually"],
        &["actual"],
        &["actually"],
        &["actually"],
    ],
    range: 1..=7,
};

static WORD_ACTR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ACTR_CHILDREN),
    value: None,
};

pub static WORD_ACTR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("esess"),
        dictgen::InsensitiveStr::Ascii("esss"),
    ],
    values: &[&["actresses"], &["actresses"]],
    range: 4..=5,
};

static WORD_ACTO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ACTO_CHILDREN),
    value: None,
};

pub static WORD_ACTO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ve")],
    values: &[&["active"]],
    range: 2..=2,
};

static WORD_ACTI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_ACTI_CHILDREN),
    value: None,
};

static WORD_ACTI_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_ACTIA_NODE),
    Some(&WORD_ACTIB_NODE),
    Some(&WORD_ACTIC_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_ACTIN_NODE),
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_ACTIT_NODE),
    Some(&WORD_ACTIU_NODE),
    Some(&WORD_ACTIV_NODE),
    None,
    None,
    None,
    None,
];

static WORD_ACTIV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ACTIV_CHILDREN),
    value: Some(&["active"]),
};

pub static WORD_ACTIV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("acion"),
        dictgen::InsensitiveStr::Ascii("aed"),
        dictgen::InsensitiveStr::Ascii("aste"),
        dictgen::InsensitiveStr::Ascii("ateing"),
        dictgen::InsensitiveStr::Ascii("aters"),
        dictgen::InsensitiveStr::Ascii("atin"),
        dictgen::InsensitiveStr::Ascii("ationg"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("elly"),
        dictgen::InsensitiveStr::Ascii("eta"),
        dictgen::InsensitiveStr::Ascii("ete"),
        dictgen::InsensitiveStr::Ascii("eted"),
        dictgen::InsensitiveStr::Ascii("etes"),
        dictgen::InsensitiveStr::Ascii("iate"),
        dictgen::InsensitiveStr::Ascii("iates"),
        dictgen::InsensitiveStr::Ascii("ies"),
        dictgen::InsensitiveStr::Ascii("iites"),
        dictgen::InsensitiveStr::Ascii("isim"),
        dictgen::InsensitiveStr::Ascii("isiom"),
        dictgen::InsensitiveStr::Ascii("isit"),
        dictgen::InsensitiveStr::Ascii("isits"),
        dictgen::InsensitiveStr::Ascii("istas"),
        dictgen::InsensitiveStr::Ascii("istes"),
        dictgen::InsensitiveStr::Ascii("istion"),
        dictgen::InsensitiveStr::Ascii("it"),
        dictgen::InsensitiveStr::Ascii("ite"),
        dictgen::InsensitiveStr::Ascii("ites"),
        dictgen::InsensitiveStr::Ascii("iti"),
        dictgen::InsensitiveStr::Ascii("iting"),
        dictgen::InsensitiveStr::Ascii("itis"),
        dictgen::InsensitiveStr::Ascii("itites"),
        dictgen::InsensitiveStr::Ascii("itiy"),
        dictgen::InsensitiveStr::Ascii("its"),
        dictgen::InsensitiveStr::Ascii("izion"),
        dictgen::InsensitiveStr::Ascii("ley"),
        dictgen::InsensitiveStr::Ascii("ly"),
        dictgen::InsensitiveStr::Ascii("ste"),
        dictgen::InsensitiveStr::Ascii("sted"),
        dictgen::InsensitiveStr::Ascii("stes"),
        dictgen::InsensitiveStr::Ascii("tes"),
        dictgen::InsensitiveStr::Ascii("ties"),
        dictgen::InsensitiveStr::Ascii("tion"),
        dictgen::InsensitiveStr::Ascii("ty"),
        dictgen::InsensitiveStr::Ascii("w"),
        dictgen::InsensitiveStr::Ascii("y"),
    ],
    values: &[
        &["activation"],
        &["activated"],
        &["activates"],
        &["activating"],
        &["activates"],
        &["activation"],
        &["activating"],
        &["activated"],
        &["actively"],
        &["activate"],
        &["activate"],
        &["activated"],
        &["activates"],
        &["activate"],
        &["activist"],
        &["activities"],
        &["activist"],
        &["activism"],
        &["activism"],
        &["activist"],
        &["activist"],
        &["activists"],
        &["activists"],
        &["activision"],
        &["activist"],
        &["activities"],
        &["activities"],
        &["activity", "activities"],
        &["activating"],
        &["activities"],
        &["activities"],
        &["activity"],
        &["activities"],
        &["activision"],
        &["actively"],
        &["actively"],
        &["activate"],
        &["activated"],
        &["activates"],
        &["activates"],
        &["activities"],
        &["activation"],
        &["activity"],
        &["active"],
        &["activity"],
    ],
    range: 1..=6,
};

static WORD_ACTIU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ACTIU_CHILDREN),
    value: None,
};

pub static WORD_ACTIU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("al")],
    values: &[&["actual"]],
    range: 2..=2,
};

static WORD_ACTIT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ACTIT_CHILDREN),
    value: None,
};

pub static WORD_ACTIT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ivies")],
    values: &[&["activities"]],
    range: 5..=5,
};

static WORD_ACTIN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ACTIN_CHILDREN),
    value: None,
};

pub static WORD_ACTIN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("e")],
    values: &[&["active"]],
    range: 1..=1,
};

static WORD_ACTIC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ACTIC_CHILDREN),
    value: None,
};

pub static WORD_ACTIC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ate"),
        dictgen::InsensitiveStr::Ascii("ating"),
        dictgen::InsensitiveStr::Ascii("ation"),
        dictgen::InsensitiveStr::Ascii("e"),
    ],
    values: &[&["activate"], &["activating"], &["activation"], &["active"]],
    range: 1..=5,
};

static WORD_ACTIB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ACTIB_CHILDREN),
    value: None,
};

pub static WORD_ACTIB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ity")],
    values: &[&["activity"]],
    range: 3..=3,
};

static WORD_ACTIA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ACTIA_CHILDREN),
    value: None,
};

pub static WORD_ACTIA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("l"),
        dictgen::InsensitiveStr::Ascii("lly"),
        dictgen::InsensitiveStr::Ascii("ly"),
        dictgen::InsensitiveStr::Ascii("vte"),
        dictgen::InsensitiveStr::Ascii("vted"),
        dictgen::InsensitiveStr::Ascii("vtes"),
        dictgen::InsensitiveStr::Ascii("vting"),
        dictgen::InsensitiveStr::Ascii("vtion"),
        dictgen::InsensitiveStr::Ascii("vtions"),
        dictgen::InsensitiveStr::Ascii("vtor"),
    ],
    values: &[
        &["actual"],
        &["actually"],
        &["actually"],
        &["activate"],
        &["activated"],
        &["activates"],
        &["activating"],
        &["activation"],
        &["activations"],
        &["activator"],
    ],
    range: 1..=6,
};

static WORD_ACTA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ACTA_CHILDREN),
    value: None,
};

pub static WORD_ACTA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("l"),
        dictgen::InsensitiveStr::Ascii("lly"),
        dictgen::InsensitiveStr::Ascii("ly"),
        dictgen::InsensitiveStr::Ascii("ul"),
        dictgen::InsensitiveStr::Ascii("ully"),
        dictgen::InsensitiveStr::Ascii("uly"),
    ],
    values: &[
        &["actual"],
        &["actually"],
        &["actually"],
        &["actual"],
        &["actually"],
        &["actually"],
    ],
    range: 1..=4,
};

static WORD_ACS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ACS_CHILDREN),
    value: None,
};

pub static WORD_ACS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ended"),
        dictgen::InsensitiveStr::Ascii("ending"),
        dictgen::InsensitiveStr::Ascii("ension"),
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("ii"),
        dictgen::InsensitiveStr::Ascii("sume"),
        dictgen::InsensitiveStr::Ascii("sumed"),
    ],
    values: &[
        &["ascended"],
        &["ascending"],
        &["ascension"],
        &["cases", "access"],
        &["ascii"],
        &["assume"],
        &["assumed"],
    ],
    range: 2..=6,
};

static WORD_ACR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ACR_CHILDREN),
    value: None,
};

pub static WORD_ACR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("age"),
        dictgen::InsensitiveStr::Ascii("lyic"),
        dictgen::InsensitiveStr::Ascii("onmys"),
        dictgen::InsensitiveStr::Ascii("onymes"),
        dictgen::InsensitiveStr::Ascii("onymns"),
        dictgen::InsensitiveStr::Ascii("onysm"),
        dictgen::InsensitiveStr::Ascii("oos"),
        dictgen::InsensitiveStr::Ascii("osss"),
        dictgen::InsensitiveStr::Ascii("ost"),
        dictgen::InsensitiveStr::Ascii("oynms"),
        dictgen::InsensitiveStr::Ascii("ue"),
        dictgen::InsensitiveStr::Ascii("ued"),
        dictgen::InsensitiveStr::Ascii("yllic"),
        dictgen::InsensitiveStr::Ascii("ynoms"),
    ],
    values: &[
        &["acreage"],
        &["acrylic"],
        &["acronyms"],
        &["acronyms"],
        &["acronyms"],
        &["acronyms"],
        &["across"],
        &["across"],
        &["across"],
        &["acronyms"],
        &["accrue"],
        &["accrued"],
        &["acrylic"],
        &["acronyms"],
    ],
    range: 2..=6,
};

static WORD_ACQ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ACQ_CHILDREN),
    value: None,
};

pub static WORD_ACQ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("auinted"),
        dictgen::InsensitiveStr::Ascii("uaintace"),
        dictgen::InsensitiveStr::Ascii("uaintaces"),
        dictgen::InsensitiveStr::Ascii("uaintaince"),
        dictgen::InsensitiveStr::Ascii("uaintence"),
        dictgen::InsensitiveStr::Ascii("uaintences"),
        dictgen::InsensitiveStr::Ascii("uaintinces"),
        dictgen::InsensitiveStr::Ascii("uanitances"),
        dictgen::InsensitiveStr::Ascii("uanited"),
        dictgen::InsensitiveStr::Ascii("uantaince"),
        dictgen::InsensitiveStr::Ascii("uantainces"),
        dictgen::InsensitiveStr::Ascii("uantiance"),
        dictgen::InsensitiveStr::Ascii("uantiances"),
        dictgen::InsensitiveStr::Ascii("ueus"),
        dictgen::InsensitiveStr::Ascii("uiantance"),
        dictgen::InsensitiveStr::Ascii("uiantances"),
        dictgen::InsensitiveStr::Ascii("uianted"),
        dictgen::InsensitiveStr::Ascii("uiantence"),
        dictgen::InsensitiveStr::Ascii("uiantences"),
        dictgen::InsensitiveStr::Ascii("uiesence"),
        dictgen::InsensitiveStr::Ascii("uiess"),
        dictgen::InsensitiveStr::Ascii("uiessed"),
        dictgen::InsensitiveStr::Ascii("uiesses"),
        dictgen::InsensitiveStr::Ascii("uiessing"),
        dictgen::InsensitiveStr::Ascii("uifer"),
        dictgen::InsensitiveStr::Ascii("uinated"),
        dictgen::InsensitiveStr::Ascii("uisation"),
        dictgen::InsensitiveStr::Ascii("uisito"),
        dictgen::InsensitiveStr::Ascii("uisiton"),
        dictgen::InsensitiveStr::Ascii("uisitons"),
        dictgen::InsensitiveStr::Ascii("uited"),
        dictgen::InsensitiveStr::Ascii("uition"),
        dictgen::InsensitiveStr::Ascii("ure"),
        dictgen::InsensitiveStr::Ascii("ured"),
        dictgen::InsensitiveStr::Ascii("ures"),
        dictgen::InsensitiveStr::Ascii("uried"),
        dictgen::InsensitiveStr::Ascii("uries"),
        dictgen::InsensitiveStr::Ascii("uring"),
        dictgen::InsensitiveStr::Ascii("usition"),
        dictgen::InsensitiveStr::Ascii("usitions"),
    ],
    values: &[
        &["acquainted"],
        &["acquaintance"],
        &["acquaintances"],
        &["acquaintance"],
        &["acquaintance"],
        &["acquaintances"],
        &["acquaintances"],
        &["acquaintance"],
        &["acquainted"],
        &["acquaintance"],
        &["acquaintances"],
        &["acquaintances"],
        &["acquaintances"],
        &["aqueous"],
        &["acquaintances"],
        &["acquaintances"],
        &["acquainted"],
        &["acquaintance"],
        &["acquaintances"],
        &["acquiescence"],
        &["acquiesce"],
        &["acquiesced"],
        &["acquiesces"],
        &["acquiescing"],
        &["acquire"],
        &["acquainted"],
        &["acquisition"],
        &["acquisition"],
        &["acquisition"],
        &["acquisitions"],
        &["acquitted"],
        &["acquisition"],
        &["acquire"],
        &["acquired"],
        &["acquires"],
        &["acquired"],
        &["acquires", "equerries"],
        &["acquiring"],
        &["acquisition"],
        &["acquisitions"],
    ],
    range: 3..=10,
};

static WORD_ACO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ACO_CHILDREN),
    value: None,
};

pub static WORD_ACO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cunt"),
        dictgen::InsensitiveStr::Ascii("mmodate"),
        dictgen::InsensitiveStr::Ascii("mmodated"),
        dictgen::InsensitiveStr::Ascii("mmodates"),
        dictgen::InsensitiveStr::Ascii("mmodating"),
        dictgen::InsensitiveStr::Ascii("mmodation"),
        dictgen::InsensitiveStr::Ascii("mmpany"),
        dictgen::InsensitiveStr::Ascii("mmpanying"),
        dictgen::InsensitiveStr::Ascii("modate"),
        dictgen::InsensitiveStr::Ascii("modated"),
        dictgen::InsensitiveStr::Ascii("mpanies"),
        dictgen::InsensitiveStr::Ascii("mplish"),
        dictgen::InsensitiveStr::Ascii("mplished"),
        dictgen::InsensitiveStr::Ascii("mplishment"),
        dictgen::InsensitiveStr::Ascii("mplishments"),
        dictgen::InsensitiveStr::Ascii("ording"),
        dictgen::InsensitiveStr::Ascii("ordingly"),
        dictgen::InsensitiveStr::Ascii("ostic"),
        dictgen::InsensitiveStr::Ascii("palypse"),
        dictgen::InsensitiveStr::Ascii("palyptic"),
        dictgen::InsensitiveStr::Ascii("rdian"),
        dictgen::InsensitiveStr::Ascii("rdians"),
        dictgen::InsensitiveStr::Ascii("rding"),
        dictgen::InsensitiveStr::Ascii("rdingly"),
        dictgen::InsensitiveStr::Ascii("rdinng"),
        dictgen::InsensitiveStr::Ascii("rdion"),
        dictgen::InsensitiveStr::Ascii("rdions"),
        dictgen::InsensitiveStr::Ascii("rnyms"),
        dictgen::InsensitiveStr::Ascii("rss"),
        dictgen::InsensitiveStr::Ascii("rting"),
        dictgen::InsensitiveStr::Ascii("unt"),
        dictgen::InsensitiveStr::Ascii("unts"),
        dictgen::InsensitiveStr::Ascii("usitc"),
        dictgen::InsensitiveStr::Ascii("utsic"),
        dictgen::InsensitiveStr::Ascii("vados"),
    ],
    values: &[
        &["account"],
        &["accommodate"],
        &["accommodated"],
        &["accommodates"],
        &["accommodating"],
        &["accommodation"],
        &["accompany"],
        &["accompanying"],
        &["accommodate"],
        &["accommodated"],
        &["accompanies"],
        &["accomplish"],
        &["accomplished"],
        &["accomplishment"],
        &["accomplishments"],
        &["according"],
        &["accordingly"],
        &["acoustic"],
        &["apocalypse"],
        &["apocalyptic"],
        &["accordion"],
        &["accordions"],
        &["according"],
        &["accordingly"],
        &["according"],
        &["accordion"],
        &["accordions"],
        &["acronyms"],
        &["across"],
        &["according"],
        &["account"],
        &["accounts"],
        &["acoustic"],
        &["acoustic"],
        &["avocados"],
    ],
    range: 3..=11,
};

static WORD_ACN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ACN_CHILDREN),
    value: Some(&["can", "acne"]),
};

pub static WORD_ACN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("edote"),
        dictgen::InsensitiveStr::Ascii("owledge"),
    ],
    values: &[&["anecdote"], &["acknowledge"]],
    range: 5..=7,
};

static WORD_ACL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ACL_CHILDREN),
    value: None,
};

pub static WORD_ACL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("hemist")],
    values: &[&["alchemist"]],
    range: 6..=6,
};

static WORD_ACK_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ACK_CHILDREN),
    value: None,
};

pub static WORD_ACK_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("nodledgment"),
        dictgen::InsensitiveStr::Ascii("nodledgments"),
        dictgen::InsensitiveStr::Ascii("noledge"),
        dictgen::InsensitiveStr::Ascii("noledged"),
        dictgen::InsensitiveStr::Ascii("noledges"),
        dictgen::InsensitiveStr::Ascii("noledging"),
        dictgen::InsensitiveStr::Ascii("noledgment"),
        dictgen::InsensitiveStr::Ascii("noledgments"),
        dictgen::InsensitiveStr::Ascii("nolwedge"),
        dictgen::InsensitiveStr::Ascii("nolwedged"),
        dictgen::InsensitiveStr::Ascii("nolwedgement"),
        dictgen::InsensitiveStr::Ascii("nolwedges"),
        dictgen::InsensitiveStr::Ascii("nolwedging"),
        dictgen::InsensitiveStr::Ascii("noweldge"),
        dictgen::InsensitiveStr::Ascii("noweldged"),
        dictgen::InsensitiveStr::Ascii("noweldgement"),
        dictgen::InsensitiveStr::Ascii("noweldges"),
        dictgen::InsensitiveStr::Ascii("nowiedged"),
        dictgen::InsensitiveStr::Ascii("nowladges"),
        dictgen::InsensitiveStr::Ascii("nowldeged"),
        dictgen::InsensitiveStr::Ascii("nowldegement"),
        dictgen::InsensitiveStr::Ascii("nowldegements"),
        dictgen::InsensitiveStr::Ascii("nowldge"),
        dictgen::InsensitiveStr::Ascii("nowlede"),
        dictgen::InsensitiveStr::Ascii("nowleded"),
        dictgen::InsensitiveStr::Ascii("nowledgeing"),
        dictgen::InsensitiveStr::Ascii("nowledgemnt"),
        dictgen::InsensitiveStr::Ascii("nowledget"),
        dictgen::InsensitiveStr::Ascii("nowleding"),
        dictgen::InsensitiveStr::Ascii("nowlegde"),
        dictgen::InsensitiveStr::Ascii("nowlegded"),
        dictgen::InsensitiveStr::Ascii("nowlegdement"),
        dictgen::InsensitiveStr::Ascii("nowlegdes"),
        dictgen::InsensitiveStr::Ascii("nowlegding"),
        dictgen::InsensitiveStr::Ascii("nowlege"),
        dictgen::InsensitiveStr::Ascii("nowleged"),
        dictgen::InsensitiveStr::Ascii("nowlegement"),
        dictgen::InsensitiveStr::Ascii("nowlegements"),
        dictgen::InsensitiveStr::Ascii("nowleges"),
        dictgen::InsensitiveStr::Ascii("nowleging"),
        dictgen::InsensitiveStr::Ascii("nowlegment"),
        dictgen::InsensitiveStr::Ascii("nwoledge"),
        dictgen::InsensitiveStr::Ascii("owledge"),
        dictgen::InsensitiveStr::Ascii("owledged"),
        dictgen::InsensitiveStr::Ascii("owledgement"),
        dictgen::InsensitiveStr::Ascii("owledgements"),
        dictgen::InsensitiveStr::Ascii("owledges"),
        dictgen::InsensitiveStr::Ascii("owledging"),
        dictgen::InsensitiveStr::Ascii("umulation"),
        dictgen::InsensitiveStr::Ascii("ward"),
    ],
    values: &[
        &["acknowledgment"],
        &["acknowledgments"],
        &["acknowledge"],
        &["acknowledged"],
        &["acknowledges"],
        &["acknowledging"],
        &["acknowledgment"],
        &["acknowledgments"],
        &["acknowledge"],
        &["acknowledged"],
        &["acknowledgement"],
        &["acknowledges"],
        &["acknowledging"],
        &["acknowledge"],
        &["acknowledged"],
        &["acknowledgement"],
        &["acknowledges"],
        &["acknowledged"],
        &["acknowledges"],
        &["acknowledged"],
        &["acknowledgement"],
        &["acknowledgements"],
        &["acknowledge"],
        &["acknowledge"],
        &["acknowledged"],
        &["acknowledging"],
        &["acknowledgement"],
        &["acknowledgment"],
        &["acknowledging"],
        &["acknowledge"],
        &["acknowledged"],
        &["acknowledgement"],
        &["acknowledges"],
        &["acknowledging"],
        &["acknowledge"],
        &["acknowledge", "acknowledged"],
        &["acknowledgement"],
        &["acknowledgements"],
        &["acknowledges"],
        &["acknowledging"],
        &["acknowledgment"],
        &["acknowledges"],
        &["acknowledge"],
        &["acknowledged"],
        &["acknowledgement"],
        &["acknowledgements"],
        &["acknowledges"],
        &["acknowledging"],
        &["accumulation"],
        &["awkward", "backward"],
    ],
    range: 4..=13,
};

static WORD_ACI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ACI_CHILDREN),
    value: Some(&["acpi"]),
};

pub static WORD_ACI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("dent"),
        dictgen::InsensitiveStr::Ascii("dental"),
        dictgen::InsensitiveStr::Ascii("dentally"),
        dictgen::InsensitiveStr::Ascii("dents"),
        dictgen::InsensitiveStr::Ascii("ent"),
        dictgen::InsensitiveStr::Ascii("ents"),
        dictgen::InsensitiveStr::Ascii("i"),
        dictgen::InsensitiveStr::Ascii("tion"),
        dictgen::InsensitiveStr::Ascii("tions"),
        dictgen::InsensitiveStr::Ascii("tivate"),
        dictgen::InsensitiveStr::Ascii("tivation"),
        dictgen::InsensitiveStr::Ascii("tivity"),
        dictgen::InsensitiveStr::Ascii("tvate"),
        dictgen::InsensitiveStr::Ascii("tvates"),
        dictgen::InsensitiveStr::Ascii("tvating"),
        dictgen::InsensitiveStr::Ascii("tve"),
        dictgen::InsensitiveStr::Ascii("tvision"),
        dictgen::InsensitiveStr::Ascii("vate"),
        dictgen::InsensitiveStr::Ascii("ve"),
    ],
    values: &[
        &["accident"],
        &["accidental"],
        &["accidentally"],
        &["accidents"],
        &["ancient"],
        &["ancients"],
        &["ascii"],
        &["action"],
        &["actions"],
        &["activate"],
        &["activation"],
        &["activity"],
        &["activate"],
        &["activates"],
        &["activating"],
        &["active"],
        &["activision"],
        &["activate"],
        &["active"],
    ],
    range: 1..=8,
};

static WORD_ACH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ACH_CHILDREN),
    value: None,
};

pub static WORD_ACH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eevable"),
        dictgen::InsensitiveStr::Ascii("eeve"),
        dictgen::InsensitiveStr::Ascii("eeved"),
        dictgen::InsensitiveStr::Ascii("eevement"),
        dictgen::InsensitiveStr::Ascii("eevements"),
        dictgen::InsensitiveStr::Ascii("eeves"),
        dictgen::InsensitiveStr::Ascii("eeving"),
        dictgen::InsensitiveStr::Ascii("eivable"),
        dictgen::InsensitiveStr::Ascii("eive"),
        dictgen::InsensitiveStr::Ascii("eived"),
        dictgen::InsensitiveStr::Ascii("eivement"),
        dictgen::InsensitiveStr::Ascii("eivements"),
        dictgen::InsensitiveStr::Ascii("eives"),
        dictgen::InsensitiveStr::Ascii("eiving"),
        dictgen::InsensitiveStr::Ascii("eivment"),
        dictgen::InsensitiveStr::Ascii("eivments"),
        dictgen::InsensitiveStr::Ascii("eviable"),
        dictgen::InsensitiveStr::Ascii("iavable"),
        dictgen::InsensitiveStr::Ascii("ieval"),
        dictgen::InsensitiveStr::Ascii("ieveble"),
        dictgen::InsensitiveStr::Ascii("ieveds"),
        dictgen::InsensitiveStr::Ascii("ievemint"),
        dictgen::InsensitiveStr::Ascii("ievemnt"),
        dictgen::InsensitiveStr::Ascii("ievemnts"),
        dictgen::InsensitiveStr::Ascii("ievemts"),
        dictgen::InsensitiveStr::Ascii("ievents"),
        dictgen::InsensitiveStr::Ascii("ievment"),
        dictgen::InsensitiveStr::Ascii("ievments"),
        dictgen::InsensitiveStr::Ascii("illees"),
        dictgen::InsensitiveStr::Ascii("illeos"),
        dictgen::InsensitiveStr::Ascii("illeous"),
        dictgen::InsensitiveStr::Ascii("illeus"),
        dictgen::InsensitiveStr::Ascii("itecture"),
        dictgen::InsensitiveStr::Ascii("itectures"),
        dictgen::InsensitiveStr::Ascii("ivable"),
        dictgen::InsensitiveStr::Ascii("ive"),
        dictgen::InsensitiveStr::Ascii("iveable"),
        dictgen::InsensitiveStr::Ascii("ived"),
        dictgen::InsensitiveStr::Ascii("iveing"),
        dictgen::InsensitiveStr::Ascii("ivement"),
        dictgen::InsensitiveStr::Ascii("ivements"),
        dictgen::InsensitiveStr::Ascii("iver"),
        dictgen::InsensitiveStr::Ascii("ives"),
        dictgen::InsensitiveStr::Ascii("iving"),
        dictgen::InsensitiveStr::Ascii("or"),
        dictgen::InsensitiveStr::Ascii("ored"),
        dictgen::InsensitiveStr::Ascii("oring"),
        dictgen::InsensitiveStr::Ascii("ors"),
    ],
    values: &[
        &["achievable"],
        &["achieve"],
        &["achieved"],
        &["achievement"],
        &["achievements"],
        &["achieves"],
        &["achieving"],
        &["achievable"],
        &["achieve"],
        &["achieved"],
        &["achievement"],
        &["achievements"],
        &["achieves"],
        &["achieving"],
        &["achievement"],
        &["achievements"],
        &["achievable"],
        &["achievable"],
        &["achievable"],
        &["achievable"],
        &["achieves"],
        &["achievement"],
        &["achievement"],
        &["achievements"],
        &["achieves"],
        &["achieves"],
        &["achievement"],
        &["achievements"],
        &["achilles"],
        &["achilles"],
        &["achilles"],
        &["achilles"],
        &["architecture"],
        &["architectures"],
        &["achievable"],
        &["achieve", "archive"],
        &["achievable"],
        &["achieved", "archived"],
        &["achieving"],
        &["achievement"],
        &["achievements"],
        &["achiever", "archiver"],
        &["achieves", "archives"],
        &["achieving", "archiving"],
        &["anchor"],
        &["anchored"],
        &["anchoring"],
        &["anchors"],
    ],
    range: 2..=9,
};

static WORD_ACF_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ACF_CHILDREN),
    value: None,
};

pub static WORD_ACF_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("tually")],
    values: &[&["factually"]],
    range: 6..=6,
};

static WORD_ACE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ACE_CHILDREN),
    value: None,
};

pub static WORD_ACE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cess"),
        dictgen::InsensitiveStr::Ascii("damia"),
        dictgen::InsensitiveStr::Ascii("demic"),
        dictgen::InsensitiveStr::Ascii("demically"),
        dictgen::InsensitiveStr::Ascii("ept"),
        dictgen::InsensitiveStr::Ascii("lerated"),
        dictgen::InsensitiveStr::Ascii("nd"),
        dictgen::InsensitiveStr::Ascii("ndance"),
        dictgen::InsensitiveStr::Ascii("ndancey"),
        dictgen::InsensitiveStr::Ascii("nded"),
        dictgen::InsensitiveStr::Ascii("ndence"),
        dictgen::InsensitiveStr::Ascii("ndencey"),
        dictgen::InsensitiveStr::Ascii("ndency"),
        dictgen::InsensitiveStr::Ascii("nder"),
        dictgen::InsensitiveStr::Ascii("nding"),
        dictgen::InsensitiveStr::Ascii("nt"),
        dictgen::InsensitiveStr::Ascii("ptable"),
        dictgen::InsensitiveStr::Ascii("rage"),
        dictgen::InsensitiveStr::Ascii("ss"),
        dictgen::InsensitiveStr::Ascii("ssable"),
        dictgen::InsensitiveStr::Ascii("ssed"),
        dictgen::InsensitiveStr::Ascii("sses"),
        dictgen::InsensitiveStr::Ascii("ssible"),
        dictgen::InsensitiveStr::Ascii("ssing"),
        dictgen::InsensitiveStr::Ascii("ssor"),
        dictgen::InsensitiveStr::Ascii("ssors"),
    ],
    values: &[
        &["access"],
        &["academia"],
        &["academic"],
        &["academically"],
        &["accept"],
        &["accelerated"],
        &["ascend"],
        &["ascendance"],
        &["ascendancy"],
        &["ascended"],
        &["ascendence"],
        &["ascendency"],
        &["ascendency"],
        &["ascender"],
        &["ascending"],
        &["ascent"],
        &["acceptable"],
        &["acreage"],
        &["access"],
        &["accessible"],
        &["accessed"],
        &["accesses"],
        &["accessible"],
        &["accessing"],
        &["accessor"],
        &["accessors", "accessor"],
    ],
    range: 2..=9,
};

static WORD_ACD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ACD_CHILDREN),
    value: None,
};

pub static WORD_ACD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ept"),
        dictgen::InsensitiveStr::Ascii("itionally"),
    ],
    values: &[&["accept", "adept"], &["additionally"]],
    range: 3..=9,
};

static WORD_ACC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_ACC_CHILDREN),
    value: None,
};

static WORD_ACC_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_ACCA_NODE),
    None,
    Some(&WORD_ACCC_NODE),
    Some(&WORD_ACCD_NODE),
    Some(&WORD_ACCE_NODE),
    None,
    None,
    Some(&WORD_ACCH_NODE),
    Some(&WORD_ACCI_NODE),
    None,
    None,
    Some(&WORD_ACCL_NODE),
    None,
    None,
    Some(&WORD_ACCO_NODE),
    Some(&WORD_ACCP_NODE),
    Some(&WORD_ACCQ_NODE),
    Some(&WORD_ACCR_NODE),
    Some(&WORD_ACCS_NODE),
    Some(&WORD_ACCT_NODE),
    Some(&WORD_ACCU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_ACCU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ACCU_CHILDREN),
    value: None,
};

pub static WORD_ACCU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ally"),
        dictgen::InsensitiveStr::Ascii("arcy"),
        dictgen::InsensitiveStr::Ascii("arte"),
        dictgen::InsensitiveStr::Ascii("artely"),
        dictgen::InsensitiveStr::Ascii("astion"),
        dictgen::InsensitiveStr::Ascii("lumate"),
        dictgen::InsensitiveStr::Ascii("lumated"),
        dictgen::InsensitiveStr::Ascii("lumating"),
        dictgen::InsensitiveStr::Ascii("lumation"),
        dictgen::InsensitiveStr::Ascii("malate"),
        dictgen::InsensitiveStr::Ascii("malated"),
        dictgen::InsensitiveStr::Ascii("malates"),
        dictgen::InsensitiveStr::Ascii("malation"),
        dictgen::InsensitiveStr::Ascii("malator"),
        dictgen::InsensitiveStr::Ascii("malte"),
        dictgen::InsensitiveStr::Ascii("malted"),
        dictgen::InsensitiveStr::Ascii("melate"),
        dictgen::InsensitiveStr::Ascii("melated"),
        dictgen::InsensitiveStr::Ascii("milate"),
        dictgen::InsensitiveStr::Ascii("milated"),
        dictgen::InsensitiveStr::Ascii("milation"),
        dictgen::InsensitiveStr::Ascii("mlate"),
        dictgen::InsensitiveStr::Ascii("mlated"),
        dictgen::InsensitiveStr::Ascii("mlates"),
        dictgen::InsensitiveStr::Ascii("mlating"),
        dictgen::InsensitiveStr::Ascii("mlator"),
        dictgen::InsensitiveStr::Ascii("mmulating"),
        dictgen::InsensitiveStr::Ascii("mmulators"),
        dictgen::InsensitiveStr::Ascii("mualte"),
        dictgen::InsensitiveStr::Ascii("mualtion"),
        dictgen::InsensitiveStr::Ascii("mulare"),
        dictgen::InsensitiveStr::Ascii("mulatin"),
        dictgen::InsensitiveStr::Ascii("mulato"),
        dictgen::InsensitiveStr::Ascii("mulaton"),
        dictgen::InsensitiveStr::Ascii("mule"),
        dictgen::InsensitiveStr::Ascii("mulotor"),
        dictgen::InsensitiveStr::Ascii("multed"),
        dictgen::InsensitiveStr::Ascii("pied"),
        dictgen::InsensitiveStr::Ascii("pts"),
        dictgen::InsensitiveStr::Ascii("rable"),
        dictgen::InsensitiveStr::Ascii("raccies"),
        dictgen::InsensitiveStr::Ascii("raccy"),
        dictgen::InsensitiveStr::Ascii("rancy"),
        dictgen::InsensitiveStr::Ascii("rarcy"),
        dictgen::InsensitiveStr::Ascii("rary"),
        dictgen::InsensitiveStr::Ascii("ratelly"),
        dictgen::InsensitiveStr::Ascii("ratley"),
        dictgen::InsensitiveStr::Ascii("ratly"),
        dictgen::InsensitiveStr::Ascii("ray"),
        dictgen::InsensitiveStr::Ascii("re"),
        dictgen::InsensitiveStr::Ascii("red"),
        dictgen::InsensitiveStr::Ascii("rences"),
        dictgen::InsensitiveStr::Ascii("rracy"),
        dictgen::InsensitiveStr::Ascii("rring"),
        dictgen::InsensitiveStr::Ascii("rs"),
        dictgen::InsensitiveStr::Ascii("sating"),
        dictgen::InsensitiveStr::Ascii("sato"),
        dictgen::InsensitiveStr::Ascii("sition"),
        dictgen::InsensitiveStr::Ascii("ssed"),
        dictgen::InsensitiveStr::Ascii("stommed"),
        dictgen::InsensitiveStr::Ascii("stumed"),
    ],
    values: &[
        &["actually"],
        &["accuracy"],
        &["accurate"],
        &["accurately"],
        &["accusation"],
        &["accumulate"],
        &["accumulated"],
        &["accumulating"],
        &["accumulation"],
        &["accumulate"],
        &["accumulated"],
        &["accumulates"],
        &["accumulation"],
        &["accumulator"],
        &["accumulate"],
        &["accumulated"],
        &["accumulate"],
        &["accumulated"],
        &["accumulate"],
        &["accumulated"],
        &["accumulation"],
        &["accumulate"],
        &["accumulated"],
        &["accumulates"],
        &["accumulating"],
        &["accumulator"],
        &["accumulating"],
        &["accumulators"],
        &["accumulate"],
        &["accumulation"],
        &["accumulate"],
        &["accumulation"],
        &["accumulation"],
        &["accumulation"],
        &["accumulate"],
        &["accumulator"],
        &["accumulated"],
        &["occupied"],
        &["accepts"],
        &["accurate"],
        &["accuracies"],
        &["accuracy"],
        &["accuracy"],
        &["accuracy"],
        &["accuracy", "actuary"],
        &["accurately"],
        &["accurately"],
        &["accurately"],
        &["accuracy", "actuary"],
        &["accrue", "occur", "acquire"],
        &["accrued", "occurred", "acquired"],
        &["occurrences"],
        &["accuracy"],
        &["occurring"],
        &["accurse", "occurs"],
        &["accusation"],
        &["accusation"],
        &["accusation"],
        &["accused"],
        &["accustomed"],
        &["accustomed"],
    ],
    range: 2..=9,
};

static WORD_ACCT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ACCT_CHILDREN),
    value: None,
};

pub static WORD_ACCT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ual")],
    values: &[&["actual"]],
    range: 3..=3,
};

static WORD_ACCS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ACCS_CHILDREN),
    value: None,
};

pub static WORD_ACCS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ess"),
        dictgen::InsensitiveStr::Ascii("s"),
        dictgen::InsensitiveStr::Ascii("sible"),
        dictgen::InsensitiveStr::Ascii("sor"),
    ],
    values: &[&["access"], &["access"], &["accessible"], &["accessor"]],
    range: 1..=5,
};

static WORD_ACCR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ACCR_CHILDREN),
    value: None,
};

pub static WORD_ACCR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("acy"),
        dictgen::InsensitiveStr::Ascii("ate"),
        dictgen::InsensitiveStr::Ascii("ding"),
        dictgen::InsensitiveStr::Ascii("dingly"),
        dictgen::InsensitiveStr::Ascii("ediated"),
        dictgen::InsensitiveStr::Ascii("ediation"),
        dictgen::InsensitiveStr::Ascii("edidation"),
        dictgen::InsensitiveStr::Ascii("editied"),
        dictgen::InsensitiveStr::Ascii("editted"),
        dictgen::InsensitiveStr::Ascii("ess"),
        dictgen::InsensitiveStr::Ascii("oding"),
        dictgen::InsensitiveStr::Ascii("odingly"),
        dictgen::InsensitiveStr::Ascii("onym"),
        dictgen::InsensitiveStr::Ascii("onyms"),
        dictgen::InsensitiveStr::Ascii("ording"),
        dictgen::InsensitiveStr::Ascii("os"),
        dictgen::InsensitiveStr::Ascii("ose"),
        dictgen::InsensitiveStr::Ascii("oss"),
    ],
    values: &[
        &["accuracy"],
        &["accurate"],
        &["according"],
        &["accordingly"],
        &["accredited"],
        &["accreditation"],
        &["accreditation"],
        &["accredited"],
        &["accredited"],
        &["access"],
        &["according"],
        &["accordingly"],
        &["acronym"],
        &["acronyms"],
        &["according"],
        &["across"],
        &["across"],
        &["across"],
    ],
    range: 2..=9,
};

static WORD_ACCQ_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ACCQ_CHILDREN),
    value: None,
};

pub static WORD_ACCQ_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("uainted"),
        dictgen::InsensitiveStr::Ascii("uire"),
        dictgen::InsensitiveStr::Ascii("uired"),
        dictgen::InsensitiveStr::Ascii("uires"),
        dictgen::InsensitiveStr::Ascii("uiring"),
    ],
    values: &[
        &["acquainted"],
        &["acquire"],
        &["acquired"],
        &["acquires"],
        &["acquiring"],
    ],
    range: 4..=7,
};

static WORD_ACCP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ACCP_CHILDREN),
    value: None,
};

pub static WORD_ACCP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("et"),
        dictgen::InsensitiveStr::Ascii("etable"),
        dictgen::InsensitiveStr::Ascii("etance"),
        dictgen::InsensitiveStr::Ascii("eted"),
        dictgen::InsensitiveStr::Ascii("ets"),
    ],
    values: &[
        &["accept"],
        &["acceptable"],
        &["acceptance"],
        &["accepted"],
        &["accepts"],
    ],
    range: 2..=6,
};

static WORD_ACCO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_ACCO_CHILDREN),
    value: None,
};

static WORD_ACCO_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    Some(&WORD_ACCOC_NODE),
    Some(&WORD_ACCOD_NODE),
    None,
    None,
    None,
    None,
    Some(&WORD_ACCOI_NODE),
    None,
    None,
    None,
    Some(&WORD_ACCOM_NODE),
    Some(&WORD_ACCON_NODE),
    Some(&WORD_ACCOO_NODE),
    Some(&WORD_ACCOP_NODE),
    None,
    Some(&WORD_ACCOR_NODE),
    Some(&WORD_ACCOS_NODE),
    None,
    Some(&WORD_ACCOU_NODE),
    None,
    None,
    None,
    None,
    None,
];

static WORD_ACCOU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ACCOU_CHILDREN),
    value: None,
};

pub static WORD_ACCOU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("nd"),
        dictgen::InsensitiveStr::Ascii("ned"),
        dictgen::InsensitiveStr::Ascii("ntabillity"),
        dictgen::InsensitiveStr::Ascii("ntabilty"),
        dictgen::InsensitiveStr::Ascii("ntas"),
        dictgen::InsensitiveStr::Ascii("ntat"),
        dictgen::InsensitiveStr::Ascii("ntatns"),
        dictgen::InsensitiveStr::Ascii("ntent"),
        dictgen::InsensitiveStr::Ascii("ntents"),
        dictgen::InsensitiveStr::Ascii("ntt"),
        dictgen::InsensitiveStr::Ascii("stic"),
        dictgen::InsensitiveStr::Ascii("stically"),
        dictgen::InsensitiveStr::Ascii("stics"),
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("ting"),
        dictgen::InsensitiveStr::Ascii("tn"),
    ],
    values: &[
        &["account"],
        &["accounted"],
        &["accountability"],
        &["accountability"],
        &["accountants"],
        &["accountants"],
        &["accountants"],
        &["accountant"],
        &["accountants"],
        &["accountant"],
        &["acoustic"],
        &["acoustically"],
        &["acoustics"],
        &["account"],
        &["accounting"],
        &["account"],
    ],
    range: 1..=10,
};

static WORD_ACCOS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ACCOS_CHILDREN),
    value: None,
};

pub static WORD_ACCOS_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("tumed")],
    values: &[&["accustomed"]],
    range: 5..=5,
};

static WORD_ACCOR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ACCOR_CHILDREN),
    value: None,
};

pub static WORD_ACCOR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("dding"),
        dictgen::InsensitiveStr::Ascii("deon"),
        dictgen::InsensitiveStr::Ascii("dian"),
        dictgen::InsensitiveStr::Ascii("dign"),
        dictgen::InsensitiveStr::Ascii("diingly"),
        dictgen::InsensitiveStr::Ascii("din"),
        dictgen::InsensitiveStr::Ascii("dinag"),
        dictgen::InsensitiveStr::Ascii("dind"),
        dictgen::InsensitiveStr::Ascii("dinly"),
        dictgen::InsensitiveStr::Ascii("dint"),
        dictgen::InsensitiveStr::Ascii("dintly"),
        dictgen::InsensitiveStr::Ascii("dling"),
        dictgen::InsensitiveStr::Ascii("dlingly"),
        dictgen::InsensitiveStr::Ascii("dng"),
        dictgen::InsensitiveStr::Ascii("dngly"),
        dictgen::InsensitiveStr::Ascii("iding"),
        dictgen::InsensitiveStr::Ascii("idng"),
        dictgen::InsensitiveStr::Ascii("idngly"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("ingly"),
        dictgen::InsensitiveStr::Ascii("ndingly"),
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("tance"),
        dictgen::InsensitiveStr::Ascii("ted"),
        dictgen::InsensitiveStr::Ascii("tind"),
        dictgen::InsensitiveStr::Ascii("ting"),
    ],
    values: &[
        &["according"],
        &["accordion"],
        &["accordion"],
        &["according"],
        &["accordingly"],
        &["according"],
        &["according"],
        &["according"],
        &["accordingly"],
        &["according"],
        &["accordingly"],
        &["according"],
        &["accordingly"],
        &["according"],
        &["accordingly"],
        &["according"],
        &["according"],
        &["accordingly"],
        &["according", "occurring"],
        &["accordingly"],
        &["accordingly"],
        &["accord"],
        &["accordance"],
        &["accorded"],
        &["according"],
        &["according"],
    ],
    range: 1..=7,
};

static WORD_ACCOP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ACCOP_CHILDREN),
    value: None,
};

pub static WORD_ACCOP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("unt")],
    values: &[&["account"]],
    range: 3..=3,
};

static WORD_ACCOO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ACCOO_CHILDREN),
    value: None,
};

pub static WORD_ACCOO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("rding"),
        dictgen::InsensitiveStr::Ascii("rdingly"),
        dictgen::InsensitiveStr::Ascii("unt"),
    ],
    values: &[&["according"], &["accordingly"], &["account"]],
    range: 3..=7,
};

static WORD_ACCON_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ACCON_CHILDREN),
    value: None,
};

pub static WORD_ACCON_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ding"),
        dictgen::InsensitiveStr::Ascii("plishment"),
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("tant"),
        dictgen::InsensitiveStr::Ascii("ted"),
        dictgen::InsensitiveStr::Ascii("ting"),
    ],
    values: &[
        &["according"],
        &["accomplishment"],
        &["account"],
        &["accountant"],
        &["accounted"],
        &["accounting"],
    ],
    range: 1..=9,
};

static WORD_ACCOM_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ACCOM_CHILDREN),
    value: None,
};

pub static WORD_ACCOM_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("adate"),
        dictgen::InsensitiveStr::Ascii("adated"),
        dictgen::InsensitiveStr::Ascii("adates"),
        dictgen::InsensitiveStr::Ascii("adating"),
        dictgen::InsensitiveStr::Ascii("adation"),
        dictgen::InsensitiveStr::Ascii("adations"),
        dictgen::InsensitiveStr::Ascii("date"),
        dictgen::InsensitiveStr::Ascii("idate"),
        dictgen::InsensitiveStr::Ascii("madate"),
        dictgen::InsensitiveStr::Ascii("madates"),
        dictgen::InsensitiveStr::Ascii("madating"),
        dictgen::InsensitiveStr::Ascii("madation"),
        dictgen::InsensitiveStr::Ascii("mdated"),
        dictgen::InsensitiveStr::Ascii("midate"),
        dictgen::InsensitiveStr::Ascii("midation"),
        dictgen::InsensitiveStr::Ascii("odata"),
        dictgen::InsensitiveStr::Ascii("odate"),
        dictgen::InsensitiveStr::Ascii("odated"),
        dictgen::InsensitiveStr::Ascii("odates"),
        dictgen::InsensitiveStr::Ascii("odating"),
        dictgen::InsensitiveStr::Ascii("odation"),
        dictgen::InsensitiveStr::Ascii("odations"),
        dictgen::InsensitiveStr::Ascii("ondate"),
        dictgen::InsensitiveStr::Ascii("ondating"),
        dictgen::InsensitiveStr::Ascii("ondation"),
        dictgen::InsensitiveStr::Ascii("pagned"),
        dictgen::InsensitiveStr::Ascii("pagnied"),
        dictgen::InsensitiveStr::Ascii("pagnies"),
        dictgen::InsensitiveStr::Ascii("pagniment"),
        dictgen::InsensitiveStr::Ascii("pagning"),
        dictgen::InsensitiveStr::Ascii("pagny"),
        dictgen::InsensitiveStr::Ascii("pagnying"),
        dictgen::InsensitiveStr::Ascii("pained"),
        dictgen::InsensitiveStr::Ascii("panyed"),
        dictgen::InsensitiveStr::Ascii("pianed"),
        dictgen::InsensitiveStr::Ascii("pined"),
        dictgen::InsensitiveStr::Ascii("pinied"),
        dictgen::InsensitiveStr::Ascii("plise"),
        dictgen::InsensitiveStr::Ascii("plises"),
        dictgen::InsensitiveStr::Ascii("plishements"),
        dictgen::InsensitiveStr::Ascii("plishemnt"),
        dictgen::InsensitiveStr::Ascii("plishemnts"),
        dictgen::InsensitiveStr::Ascii("plishent"),
        dictgen::InsensitiveStr::Ascii("plishents"),
        dictgen::InsensitiveStr::Ascii("plishs"),
        dictgen::InsensitiveStr::Ascii("pliss"),
        dictgen::InsensitiveStr::Ascii("ponied"),
        dictgen::InsensitiveStr::Ascii("ponies"),
        dictgen::InsensitiveStr::Ascii("pony"),
        dictgen::InsensitiveStr::Ascii("ponying"),
        dictgen::InsensitiveStr::Ascii("pt"),
    ],
    values: &[
        &["accommodate"],
        &["accommodated"],
        &["accommodates"],
        &["accommodating"],
        &["accommodation"],
        &["accommodations"],
        &["accommodate"],
        &["accommodate"],
        &["accommodate"],
        &["accommodates"],
        &["accommodating"],
        &["accommodation"],
        &["accommodated"],
        &["accommodate"],
        &["accommodation"],
        &["accommodate"],
        &["accommodate"],
        &["accommodated"],
        &["accommodates"],
        &["accommodating"],
        &["accommodation"],
        &["accommodations"],
        &["accommodate"],
        &["accommodating"],
        &["accommodation"],
        &["accompanied"],
        &["accompanied"],
        &["accompanies"],
        &["accompaniment"],
        &["accompanying"],
        &["accompany"],
        &["accompanying"],
        &["accompanied"],
        &["accompanied"],
        &["accompanied"],
        &["accompanied"],
        &["accompanied"],
        &["accomplishes"],
        &["accomplishes"],
        &["accomplishments"],
        &["accomplishment"],
        &["accomplishments"],
        &["accomplishment"],
        &["accomplishes"],
        &["accomplishes"],
        &["accomplishes"],
        &["accompanied"],
        &["accompanies"],
        &["accompany"],
        &["accompanying"],
        &["account"],
    ],
    range: 2..=11,
};

static WORD_ACCOI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ACCOI_CHILDREN),
    value: None,
};

pub static WORD_ACCOI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("nting"),
        dictgen::InsensitiveStr::Ascii("rd"),
        dictgen::InsensitiveStr::Ascii("rding"),
    ],
    values: &[&["accounting"], &["accord"], &["according"]],
    range: 2..=5,
};

static WORD_ACCOD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ACCOD_CHILDREN),
    value: None,
};

pub static WORD_ACCOD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("ingly"),
        dictgen::InsensitiveStr::Ascii("r"),
        dictgen::InsensitiveStr::Ascii("rance"),
        dictgen::InsensitiveStr::Ascii("red"),
        dictgen::InsensitiveStr::Ascii("ring"),
        dictgen::InsensitiveStr::Ascii("ringly"),
        dictgen::InsensitiveStr::Ascii("rs"),
    ],
    values: &[
        &["according"],
        &["accordingly"],
        &["accord"],
        &["accordance"],
        &["accorded"],
        &["according"],
        &["accordingly"],
        &["accords"],
    ],
    range: 1..=6,
};

static WORD_ACCOC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ACCOC_CHILDREN),
    value: None,
};

pub static WORD_ACCOC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("iate"),
        dictgen::InsensitiveStr::Ascii("iated"),
        dictgen::InsensitiveStr::Ascii("iates"),
        dictgen::InsensitiveStr::Ascii("iating"),
        dictgen::InsensitiveStr::Ascii("iation"),
        dictgen::InsensitiveStr::Ascii("iations"),
    ],
    values: &[
        &["associate"],
        &["associated"],
        &["associates"],
        &["associating"],
        &["association"],
        &["associations"],
    ],
    range: 4..=7,
};

static WORD_ACCL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ACCL_CHILDREN),
    value: None,
};

pub static WORD_ACCL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("amied"),
        dictgen::InsensitiveStr::Ascii("erated"),
        dictgen::InsensitiveStr::Ascii("erates"),
        dictgen::InsensitiveStr::Ascii("eration"),
        dictgen::InsensitiveStr::Ascii("erometers"),
        dictgen::InsensitiveStr::Ascii("iamed"),
        dictgen::InsensitiveStr::Ascii("imitization"),
    ],
    values: &[
        &["acclaimed"],
        &["accelerated"],
        &["accelerates"],
        &["acceleration"],
        &["accelerometers"],
        &["acclaimed"],
        &["acclimatization"],
    ],
    range: 5..=11,
};

static WORD_ACCI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ACCI_CHILDREN),
    value: None,
};

pub static WORD_ACCI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("cently"),
        dictgen::InsensitiveStr::Ascii("dant"),
        dictgen::InsensitiveStr::Ascii("dantely"),
        dictgen::InsensitiveStr::Ascii("dantly"),
        dictgen::InsensitiveStr::Ascii("ddently"),
        dictgen::InsensitiveStr::Ascii("debtly"),
        dictgen::InsensitiveStr::Ascii("denlty"),
        dictgen::InsensitiveStr::Ascii("dens"),
        dictgen::InsensitiveStr::Ascii("dentaly"),
        dictgen::InsensitiveStr::Ascii("dentely"),
        dictgen::InsensitiveStr::Ascii("dentes"),
        dictgen::InsensitiveStr::Ascii("dential"),
        dictgen::InsensitiveStr::Ascii("dentially"),
        dictgen::InsensitiveStr::Ascii("dentically"),
        dictgen::InsensitiveStr::Ascii("dentilly"),
        dictgen::InsensitiveStr::Ascii("dentily"),
        dictgen::InsensitiveStr::Ascii("dentky"),
        dictgen::InsensitiveStr::Ascii("dentlaly"),
        dictgen::InsensitiveStr::Ascii("dentlay"),
        dictgen::InsensitiveStr::Ascii("dentley"),
        dictgen::InsensitiveStr::Ascii("dentlly"),
        dictgen::InsensitiveStr::Ascii("dentually"),
        dictgen::InsensitiveStr::Ascii("denty"),
        dictgen::InsensitiveStr::Ascii("deny"),
        dictgen::InsensitiveStr::Ascii("detly"),
        dictgen::InsensitiveStr::Ascii("dnetly"),
        dictgen::InsensitiveStr::Ascii("edential"),
        dictgen::InsensitiveStr::Ascii("ednetally"),
        dictgen::InsensitiveStr::Ascii("ent"),
        dictgen::InsensitiveStr::Ascii("ental"),
        dictgen::InsensitiveStr::Ascii("ssible"),
    ],
    values: &[
        &["accidentally"],
        &["accident"],
        &["accidentally"],
        &["accidentally"],
        &["accidentally"],
        &["accidentally"],
        &["accidentally"],
        &["accidents"],
        &["accidentally"],
        &["accidentally"],
        &["accidents"],
        &["accidental"],
        &["accidentally"],
        &["accidentally"],
        &["accidentally"],
        &["accidentally"],
        &["accidentally"],
        &["accidentally"],
        &["accidentally"],
        &["accidentally"],
        &["accidentally"],
        &["accidentally"],
        &["accidentally"],
        &["accidentally"],
        &["accidentally"],
        &["accidentally"],
        &["accidental"],
        &["accidentally"],
        &["accident"],
        &["accidental"],
        &["accessible"],
    ],
    range: 3..=10,
};

static WORD_ACCH_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ACCH_CHILDREN),
    value: None,
};

pub static WORD_ACCH_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("iev"),
        dictgen::InsensitiveStr::Ascii("ievable"),
        dictgen::InsensitiveStr::Ascii("ieve"),
        dictgen::InsensitiveStr::Ascii("ieveable"),
        dictgen::InsensitiveStr::Ascii("ieved"),
        dictgen::InsensitiveStr::Ascii("ievement"),
        dictgen::InsensitiveStr::Ascii("ievements"),
        dictgen::InsensitiveStr::Ascii("iever"),
        dictgen::InsensitiveStr::Ascii("ieves"),
    ],
    values: &[
        &["achieve"],
        &["achievable"],
        &["achieve"],
        &["achievable"],
        &["achieved"],
        &["achievement"],
        &["achievements"],
        &["achiever"],
        &["achieves"],
    ],
    range: 3..=9,
};

static WORD_ACCE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_ACCE_CHILDREN),
    value: None,
};

static WORD_ACCE_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    Some(&WORD_ACCEC_NODE),
    Some(&WORD_ACCED_NODE),
    Some(&WORD_ACCEE_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_ACCEL_NODE),
    None,
    Some(&WORD_ACCEN_NODE),
    Some(&WORD_ACCEO_NODE),
    Some(&WORD_ACCEP_NODE),
    None,
    Some(&WORD_ACCER_NODE),
    Some(&WORD_ACCES_NODE),
    Some(&WORD_ACCET_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
];

static WORD_ACCET_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ACCET_CHILDREN),
    value: Some(&["accept"]),
};

pub static WORD_ACCET_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("able"),
        dictgen::InsensitiveStr::Ascii("s"),
    ],
    values: &[&["acceptable"], &["accepts"]],
    range: 1..=4,
};

static WORD_ACCES_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ACCES_CHILDREN),
    value: Some(&["access"]),
};

pub static WORD_ACCES_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("able"),
        dictgen::InsensitiveStr::Ascii("ed"),
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("ibility"),
        dictgen::InsensitiveStr::Ascii("ible"),
        dictgen::InsensitiveStr::Ascii("iblity"),
        dictgen::InsensitiveStr::Ascii("iibility"),
        dictgen::InsensitiveStr::Ascii("iiblity"),
        dictgen::InsensitiveStr::Ascii("ing"),
        dictgen::InsensitiveStr::Ascii("nt"),
        dictgen::InsensitiveStr::Ascii("or"),
        dictgen::InsensitiveStr::Ascii("ories"),
        dictgen::InsensitiveStr::Ascii("ors"),
        dictgen::InsensitiveStr::Ascii("ory"),
        dictgen::InsensitiveStr::Ascii("sability"),
        dictgen::InsensitiveStr::Ascii("sable"),
        dictgen::InsensitiveStr::Ascii("sbile"),
        dictgen::InsensitiveStr::Ascii("series"),
        dictgen::InsensitiveStr::Ascii("siable"),
        dictgen::InsensitiveStr::Ascii("sibile"),
        dictgen::InsensitiveStr::Ascii("sibiliity"),
        dictgen::InsensitiveStr::Ascii("sibilitiy"),
        dictgen::InsensitiveStr::Ascii("sibiliy"),
        dictgen::InsensitiveStr::Ascii("sibiltiy"),
        dictgen::InsensitiveStr::Ascii("sibilty"),
        dictgen::InsensitiveStr::Ascii("sibily"),
        dictgen::InsensitiveStr::Ascii("siblilty"),
        dictgen::InsensitiveStr::Ascii("siblity"),
        dictgen::InsensitiveStr::Ascii("siibility"),
        dictgen::InsensitiveStr::Ascii("siiblity"),
        dictgen::InsensitiveStr::Ascii("sile"),
        dictgen::InsensitiveStr::Ascii("sintg"),
        dictgen::InsensitiveStr::Ascii("sisble"),
        dictgen::InsensitiveStr::Ascii("sment"),
        dictgen::InsensitiveStr::Ascii("sments"),
        dictgen::InsensitiveStr::Ascii("soire"),
        dictgen::InsensitiveStr::Ascii("soires"),
        dictgen::InsensitiveStr::Ascii("soirez"),
        dictgen::InsensitiveStr::Ascii("soirs"),
        dictgen::InsensitiveStr::Ascii("sort"),
        dictgen::InsensitiveStr::Ascii("ss"),
        dictgen::InsensitiveStr::Ascii("ssibility"),
        dictgen::InsensitiveStr::Ascii("ssible"),
        dictgen::InsensitiveStr::Ascii("ssiblity"),
        dictgen::InsensitiveStr::Ascii("ssiiblity"),
        dictgen::InsensitiveStr::Ascii("ssing"),
        dictgen::InsensitiveStr::Ascii("ssor"),
        dictgen::InsensitiveStr::Ascii("ssors"),
        dictgen::InsensitiveStr::Ascii("tor"),
        dictgen::InsensitiveStr::Ascii("tors"),
    ],
    values: &[
        &["accessible"],
        &["accessed"],
        &["accesses"],
        &["accessibility"],
        &["accessible"],
        &["accessibility"],
        &["accessibility"],
        &["accessibility"],
        &["accessing"],
        &["accent"],
        &["accessor"],
        &["accessories"],
        &["accessors"],
        &["accessory"],
        &["accessibility"],
        &["accessible"],
        &["accessible"],
        &["accessories"],
        &["accessible"],
        &["accessible"],
        &["accessibility"],
        &["accessibility"],
        &["accessibility", "accessible"],
        &["accessibility"],
        &["accessibility"],
        &["accessibility"],
        &["accessibility"],
        &["accessibility"],
        &["accessibility"],
        &["accessibility"],
        &["accessible"],
        &["accessing"],
        &["accessible"],
        &["assessment"],
        &["assessments"],
        &["accessories", "accessory"],
        &["accessories", "accessorise"],
        &["accessorize", "accessories"],
        &["accessories"],
        &["accessor"],
        &["access"],
        &["accessibility"],
        &["accessible"],
        &["accessibility"],
        &["accessibility"],
        &["accessing"],
        &["accessor"],
        &["accessors"],
        &["accessor", "ancestor"],
        &["accessors", "ancestors"],
    ],
    range: 2..=9,
};

static WORD_ACCER_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ACCER_CHILDREN),
    value: None,
};

pub static WORD_ACCER_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("elate")],
    values: &[&["accelerated"]],
    range: 5..=5,
};

static WORD_ACCEP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ACCEP_CHILDREN),
    value: None,
};

pub static WORD_ACCEP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("atble"),
        dictgen::InsensitiveStr::Ascii("ect"),
        dictgen::InsensitiveStr::Ascii("ected"),
        dictgen::InsensitiveStr::Ascii("eted"),
        dictgen::InsensitiveStr::Ascii("pt"),
        dictgen::InsensitiveStr::Ascii("tabel"),
        dictgen::InsensitiveStr::Ascii("tabelt"),
        dictgen::InsensitiveStr::Ascii("tabil"),
        dictgen::InsensitiveStr::Ascii("tence"),
        dictgen::InsensitiveStr::Ascii("terad"),
        dictgen::InsensitiveStr::Ascii("tes"),
        dictgen::InsensitiveStr::Ascii("tible"),
        dictgen::InsensitiveStr::Ascii("tibly"),
        dictgen::InsensitiveStr::Ascii("tted"),
    ],
    values: &[
        &["acceptable"],
        &["accept"],
        &["accepted"],
        &["accepted"],
        &["accept"],
        &["acceptable"],
        &["acceptable"],
        &["acceptable"],
        &["acceptance"],
        &["accepted"],
        &["accepts"],
        &["acceptable"],
        &["acceptably"],
        &["accepted"],
    ],
    range: 2..=6,
};

static WORD_ACCEO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ACCEO_CHILDREN),
    value: None,
};

pub static WORD_ACCEO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("t")],
    values: &[&["accept"]],
    range: 1..=1,
};

static WORD_ACCEN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ACCEN_CHILDREN),
    value: None,
};

pub static WORD_ACCEN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ding"),
        dictgen::InsensitiveStr::Ascii("sion"),
    ],
    values: &[&["ascending"], &["accession", "ascension"]],
    range: 4..=4,
};

static WORD_ACCEL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ACCEL_CHILDREN),
    value: None,
};

pub static WORD_ACCEL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("arate"),
        dictgen::InsensitiveStr::Ascii("arated"),
        dictgen::InsensitiveStr::Ascii("arating"),
        dictgen::InsensitiveStr::Ascii("aration"),
        dictgen::InsensitiveStr::Ascii("arator"),
        dictgen::InsensitiveStr::Ascii("arete"),
        dictgen::InsensitiveStr::Ascii("earion"),
        dictgen::InsensitiveStr::Ascii("earte"),
        dictgen::InsensitiveStr::Ascii("earted"),
        dictgen::InsensitiveStr::Ascii("eartes"),
        dictgen::InsensitiveStr::Ascii("eartion"),
        dictgen::InsensitiveStr::Ascii("eartor"),
        dictgen::InsensitiveStr::Ascii("eated"),
        dictgen::InsensitiveStr::Ascii("erade"),
        dictgen::InsensitiveStr::Ascii("eraptor"),
        dictgen::InsensitiveStr::Ascii("erar"),
        dictgen::InsensitiveStr::Ascii("erare"),
        dictgen::InsensitiveStr::Ascii("erater"),
        dictgen::InsensitiveStr::Ascii("eratie"),
        dictgen::InsensitiveStr::Ascii("eratio"),
        dictgen::InsensitiveStr::Ascii("erato"),
        dictgen::InsensitiveStr::Ascii("eratoin"),
        dictgen::InsensitiveStr::Ascii("eraton"),
        dictgen::InsensitiveStr::Ascii("eratrion"),
        dictgen::InsensitiveStr::Ascii("eread"),
        dictgen::InsensitiveStr::Ascii("erte"),
        dictgen::InsensitiveStr::Ascii("ertion"),
        dictgen::InsensitiveStr::Ascii("ertor"),
        dictgen::InsensitiveStr::Ascii("lerate"),
        dictgen::InsensitiveStr::Ascii("lerated"),
        dictgen::InsensitiveStr::Ascii("lerating"),
        dictgen::InsensitiveStr::Ascii("leration"),
        dictgen::InsensitiveStr::Ascii("lerator"),
        dictgen::InsensitiveStr::Ascii("orate"),
        dictgen::InsensitiveStr::Ascii("orated"),
        dictgen::InsensitiveStr::Ascii("orating"),
        dictgen::InsensitiveStr::Ascii("orator"),
    ],
    values: &[
        &["accelerate"],
        &["accelerated"],
        &["accelerating"],
        &["acceleration"],
        &["accelerator"],
        &["accelerate"],
        &["acceleration"],
        &["accelerate"],
        &["accelerated"],
        &["accelerates"],
        &["acceleration"],
        &["accelerator"],
        &["accelerated"],
        &["accelerated"],
        &["accelerator"],
        &["accelerator"],
        &["accelerate"],
        &["accelerator"],
        &["accelerate"],
        &["accelerator"],
        &["acceleration"],
        &["acceleration"],
        &["acceleration"],
        &["acceleration"],
        &["accelerated"],
        &["accelerate"],
        &["acceleration"],
        &["accelerator"],
        &["accelerate"],
        &["accelerated"],
        &["accelerating"],
        &["acceleration"],
        &["accelerator"],
        &["accelerate"],
        &["accelerated"],
        &["accelerating"],
        &["accelerator"],
    ],
    range: 4..=8,
};

static WORD_ACCEE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ACCEE_CHILDREN),
    value: None,
};

pub static WORD_ACCEE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("s"),
        dictgen::InsensitiveStr::Ascii("ss"),
    ],
    values: &[&["access"], &["access"]],
    range: 1..=2,
};

static WORD_ACCED_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ACCED_CHILDREN),
    value: None,
};

pub static WORD_ACCED_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("entally")],
    values: &[&["accidentally"]],
    range: 7..=7,
};

static WORD_ACCEC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ACCEC_CHILDREN),
    value: None,
};

pub static WORD_ACCEC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("pt"),
        dictgen::InsensitiveStr::Ascii("pted"),
    ],
    values: &[&["accept"], &["accepted"]],
    range: 2..=4,
};

static WORD_ACCD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ACCD_CHILDREN),
    value: None,
};

pub static WORD_ACCD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("iently")],
    values: &[&["accidently"]],
    range: 6..=6,
};

static WORD_ACCC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ACCC_CHILDREN),
    value: None,
};

pub static WORD_ACCC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ept"),
        dictgen::InsensitiveStr::Ascii("eptable"),
        dictgen::InsensitiveStr::Ascii("epted"),
        dictgen::InsensitiveStr::Ascii("epting"),
        dictgen::InsensitiveStr::Ascii("epts"),
        dictgen::InsensitiveStr::Ascii("es"),
        dictgen::InsensitiveStr::Ascii("ess"),
        dictgen::InsensitiveStr::Ascii("essd"),
        dictgen::InsensitiveStr::Ascii("essed"),
        dictgen::InsensitiveStr::Ascii("esses"),
        dictgen::InsensitiveStr::Ascii("essibility"),
        dictgen::InsensitiveStr::Ascii("essible"),
        dictgen::InsensitiveStr::Ascii("essing"),
        dictgen::InsensitiveStr::Ascii("ession"),
        dictgen::InsensitiveStr::Ascii("essor"),
        dictgen::InsensitiveStr::Ascii("essors"),
        dictgen::InsensitiveStr::Ascii("ord"),
        dictgen::InsensitiveStr::Ascii("ordance"),
        dictgen::InsensitiveStr::Ascii("ordances"),
        dictgen::InsensitiveStr::Ascii("orded"),
        dictgen::InsensitiveStr::Ascii("ording"),
        dictgen::InsensitiveStr::Ascii("ordingly"),
        dictgen::InsensitiveStr::Ascii("ords"),
        dictgen::InsensitiveStr::Ascii("ount"),
        dictgen::InsensitiveStr::Ascii("umulate"),
        dictgen::InsensitiveStr::Ascii("uracy"),
        dictgen::InsensitiveStr::Ascii("urate"),
        dictgen::InsensitiveStr::Ascii("urately"),
        dictgen::InsensitiveStr::Ascii("used"),
    ],
    values: &[
        &["accept"],
        &["acceptable"],
        &["accepted"],
        &["accepting"],
        &["accepts"],
        &["access"],
        &["access"],
        &["accessed"],
        &["accessed"],
        &["accesses"],
        &["accessibility"],
        &["accessible"],
        &["accessing"],
        &["accession"],
        &["accessor"],
        &["accessors"],
        &["accord"],
        &["accordance"],
        &["accordances"],
        &["accorded"],
        &["according"],
        &["accordingly"],
        &["accords"],
        &["account"],
        &["accumulate"],
        &["accuracy"],
        &["accurate"],
        &["accurately"],
        &["accused"],
    ],
    range: 2..=10,
};

static WORD_ACCA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ACCA_CHILDREN),
    value: None,
};

pub static WORD_ACCA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("demic"),
        dictgen::InsensitiveStr::Ascii("demy"),
        dictgen::InsensitiveStr::Ascii("limed"),
        dictgen::InsensitiveStr::Ascii("pt"),
        dictgen::InsensitiveStr::Ascii("pted"),
        dictgen::InsensitiveStr::Ascii("pts"),
    ],
    values: &[
        &["academic"],
        &["academy"],
        &["acclaimed"],
        &["accept"],
        &["accepted"],
        &["accepts"],
    ],
    range: 2..=5,
};

static WORD_ACA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ACA_CHILDREN),
    value: None,
};

pub static WORD_ACA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("damy"),
        dictgen::InsensitiveStr::Ascii("demcially"),
        dictgen::InsensitiveStr::Ascii("demica"),
        dictgen::InsensitiveStr::Ascii("demicaly"),
        dictgen::InsensitiveStr::Ascii("demicas"),
        dictgen::InsensitiveStr::Ascii("demicese"),
        dictgen::InsensitiveStr::Ascii("demicos"),
        dictgen::InsensitiveStr::Ascii("demicus"),
        dictgen::InsensitiveStr::Ascii("demis"),
        dictgen::InsensitiveStr::Ascii("dimy"),
        dictgen::InsensitiveStr::Ascii("dmic"),
        dictgen::InsensitiveStr::Ascii("le"),
        dictgen::InsensitiveStr::Ascii("temy"),
    ],
    values: &[
        &["academy"],
        &["academically"],
        &["academia"],
        &["academically"],
        &["academics"],
        &["academics"],
        &["academics"],
        &["academics"],
        &["academics"],
        &["academy"],
        &["academic"],
        &["scale"],
        &["academy"],
    ],
    range: 2..=9,
};

static WORD_AB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_AB_CHILDREN),
    value: None,
};

static WORD_AB_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_ABA_NODE),
    Some(&WORD_ABB_NODE),
    None,
    Some(&WORD_ABD_NODE),
    Some(&WORD_ABE_NODE),
    None,
    None,
    None,
    Some(&WORD_ABI_NODE),
    None,
    None,
    Some(&WORD_ABL_NODE),
    None,
    Some(&WORD_ABN_NODE),
    Some(&WORD_ABO_NODE),
    None,
    None,
    Some(&WORD_ABR_NODE),
    Some(&WORD_ABS_NODE),
    Some(&WORD_ABT_NODE),
    Some(&WORD_ABU_NODE),
    Some(&WORD_ABV_NODE),
    None,
    None,
    Some(&WORD_ABY_NODE),
    None,
];

static WORD_ABY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ABY_CHILDREN),
    value: None,
};

pub static WORD_ABY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("msal")],
    values: &[&["abysmal"]],
    range: 4..=4,
};

static WORD_ABV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ABV_CHILDREN),
    value: None,
};

pub static WORD_ABV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ailable"),
        dictgen::InsensitiveStr::Ascii("ious"),
    ],
    values: &[&["available"], &["obvious"]],
    range: 4..=7,
};

static WORD_ABU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ABU_CHILDREN),
    value: None,
};

pub static WORD_ABU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("dance"),
        dictgen::InsensitiveStr::Ascii("dances"),
        dictgen::InsensitiveStr::Ascii("dcted"),
        dictgen::InsensitiveStr::Ascii("ndace"),
        dictgen::InsensitiveStr::Ascii("ndaces"),
        dictgen::InsensitiveStr::Ascii("ndacies"),
        dictgen::InsensitiveStr::Ascii("ndancies"),
        dictgen::InsensitiveStr::Ascii("ndand"),
        dictgen::InsensitiveStr::Ascii("ndence"),
        dictgen::InsensitiveStr::Ascii("ndent"),
        dictgen::InsensitiveStr::Ascii("ndunt"),
        dictgen::InsensitiveStr::Ascii("rptly"),
        dictgen::InsensitiveStr::Ascii("seres"),
        dictgen::InsensitiveStr::Ascii("srdity"),
        dictgen::InsensitiveStr::Ascii("srdly"),
        dictgen::InsensitiveStr::Ascii("tts"),
    ],
    values: &[
        &["abundance"],
        &["abundances"],
        &["abducted"],
        &["abundance"],
        &["abundances"],
        &["abundances"],
        &["abundances"],
        &["abundant"],
        &["abundance"],
        &["abundant"],
        &["abundant"],
        &["abruptly"],
        &["abusers"],
        &["absurdity"],
        &["absurdly"],
        &["abuts"],
    ],
    range: 3..=8,
};

static WORD_ABT_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ABT_CHILDREN),
    value: None,
};

pub static WORD_ABT_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ract"),
        dictgen::InsensitiveStr::Ascii("racted"),
        dictgen::InsensitiveStr::Ascii("racter"),
        dictgen::InsensitiveStr::Ascii("racting"),
        dictgen::InsensitiveStr::Ascii("raction"),
        dictgen::InsensitiveStr::Ascii("ractions"),
        dictgen::InsensitiveStr::Ascii("ractly"),
        dictgen::InsensitiveStr::Ascii("ractness"),
        dictgen::InsensitiveStr::Ascii("ractor"),
        dictgen::InsensitiveStr::Ascii("racts"),
    ],
    values: &[
        &["abstract"],
        &["abstracted"],
        &["abstracter"],
        &["abstracting"],
        &["abstraction"],
        &["abstractions"],
        &["abstractly"],
        &["abstractness"],
        &["abstractor"],
        &["abstracts"],
    ],
    range: 4..=8,
};

static WORD_ABS_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_ABS_CHILDREN),
    value: None,
};

static WORD_ABS_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    Some(&WORD_ABSA_NODE),
    None,
    Some(&WORD_ABSC_NODE),
    None,
    Some(&WORD_ABSE_NODE),
    None,
    None,
    None,
    Some(&WORD_ABSI_NODE),
    None,
    None,
    Some(&WORD_ABSL_NODE),
    None,
    None,
    Some(&WORD_ABSO_NODE),
    None,
    None,
    Some(&WORD_ABSR_NODE),
    None,
    Some(&WORD_ABST_NODE),
    Some(&WORD_ABSU_NODE),
    None,
    None,
    None,
    Some(&WORD_ABSY_NODE),
    None,
];

static WORD_ABSY_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ABSY_CHILDREN),
    value: None,
};

pub static WORD_ABSY_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("mal")],
    values: &[&["abysmal"]],
    range: 3..=3,
};

static WORD_ABSU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ABSU_CHILDREN),
    value: None,
};

pub static WORD_ABSU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ers"),
        dictgen::InsensitiveStr::Ascii("lute"),
        dictgen::InsensitiveStr::Ascii("rditiy"),
        dictgen::InsensitiveStr::Ascii("rdley"),
        dictgen::InsensitiveStr::Ascii("rdy"),
        dictgen::InsensitiveStr::Ascii("ridty"),
    ],
    values: &[
        &["abusers"],
        &["absolute"],
        &["absurdity"],
        &["absurdly"],
        &["absurdly"],
        &["absurdity"],
    ],
    range: 3..=6,
};

static WORD_ABST_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ABST_CHILDREN),
    value: None,
};

pub static WORD_ABST_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("act"),
        dictgen::InsensitiveStr::Ascii("acted"),
        dictgen::InsensitiveStr::Ascii("acter"),
        dictgen::InsensitiveStr::Ascii("acting"),
        dictgen::InsensitiveStr::Ascii("action"),
        dictgen::InsensitiveStr::Ascii("actions"),
        dictgen::InsensitiveStr::Ascii("actly"),
        dictgen::InsensitiveStr::Ascii("actness"),
        dictgen::InsensitiveStr::Ascii("actor"),
        dictgen::InsensitiveStr::Ascii("acts"),
        dictgen::InsensitiveStr::Ascii("anence"),
        dictgen::InsensitiveStr::Ascii("ante"),
        dictgen::InsensitiveStr::Ascii("enance"),
        dictgen::InsensitiveStr::Ascii("enince"),
        dictgen::InsensitiveStr::Ascii("inense"),
        dictgen::InsensitiveStr::Ascii("inince"),
        dictgen::InsensitiveStr::Ascii("rac"),
        dictgen::InsensitiveStr::Ascii("raccion"),
        dictgen::InsensitiveStr::Ascii("raced"),
        dictgen::InsensitiveStr::Ascii("racer"),
        dictgen::InsensitiveStr::Ascii("racing"),
        dictgen::InsensitiveStr::Ascii("racion"),
        dictgen::InsensitiveStr::Ascii("racions"),
        dictgen::InsensitiveStr::Ascii("racly"),
        dictgen::InsensitiveStr::Ascii("racness"),
        dictgen::InsensitiveStr::Ascii("racor"),
        dictgen::InsensitiveStr::Ascii("racs"),
        dictgen::InsensitiveStr::Ascii("racto"),
        dictgen::InsensitiveStr::Ascii("raktion"),
        dictgen::InsensitiveStr::Ascii("rat"),
        dictgen::InsensitiveStr::Ascii("rated"),
        dictgen::InsensitiveStr::Ascii("rater"),
        dictgen::InsensitiveStr::Ascii("rating"),
        dictgen::InsensitiveStr::Ascii("ration"),
        dictgen::InsensitiveStr::Ascii("rations"),
        dictgen::InsensitiveStr::Ascii("ratly"),
        dictgen::InsensitiveStr::Ascii("ratness"),
        dictgen::InsensitiveStr::Ascii("rator"),
        dictgen::InsensitiveStr::Ascii("rats"),
        dictgen::InsensitiveStr::Ascii("rct"),
        dictgen::InsensitiveStr::Ascii("rcted"),
        dictgen::InsensitiveStr::Ascii("rcter"),
        dictgen::InsensitiveStr::Ascii("rcting"),
        dictgen::InsensitiveStr::Ascii("rction"),
        dictgen::InsensitiveStr::Ascii("rctions"),
        dictgen::InsensitiveStr::Ascii("rctly"),
        dictgen::InsensitiveStr::Ascii("rctness"),
        dictgen::InsensitiveStr::Ascii("rctor"),
        dictgen::InsensitiveStr::Ascii("rcts"),
        dictgen::InsensitiveStr::Ascii("ruction"),
    ],
    values: &[
        &["abstract"],
        &["abstracted"],
        &["abstracter"],
        &["abstracting"],
        &["abstraction"],
        &["abstractions"],
        &["abstractly"],
        &["abstractness"],
        &["abstractor"],
        &["abstracts"],
        &["abstinence"],
        &["bastante"],
        &["abstinence"],
        &["abstinence"],
        &["abstinence"],
        &["abstinence"],
        &["abstract"],
        &["abstraction"],
        &["abstracted"],
        &["abstracter"],
        &["abstracting"],
        &["abstraction"],
        &["abstractions"],
        &["abstractly"],
        &["abstractness"],
        &["abstractor"],
        &["abstracts"],
        &["abstraction"],
        &["abstraction"],
        &["abstract"],
        &["abstracted"],
        &["abstracter"],
        &["abstracting"],
        &["abstraction"],
        &["abstractions"],
        &["abstractly"],
        &["abstractness"],
        &["abstractor"],
        &["abstracts"],
        &["abstract"],
        &["abstracted"],
        &["abstracter"],
        &["abstracting"],
        &["abstraction"],
        &["abstractions"],
        &["abstractly"],
        &["abstractness"],
        &["abstractor"],
        &["abstracts"],
        &["abstraction"],
    ],
    range: 3..=7,
};

static WORD_ABSR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ABSR_CHILDREN),
    value: None,
};

pub static WORD_ABSR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("obs")],
    values: &[&["absorbs"]],
    range: 3..=3,
};

static WORD_ABSO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Nested(&WORD_ABSO_CHILDREN),
    value: None,
};

static WORD_ABSO_CHILDREN: [Option<&dictgen::DictTrieNode<&'static [&'static str]>>; 26] = [
    None,
    None,
    None,
    Some(&WORD_ABSOD_NODE),
    None,
    None,
    None,
    None,
    None,
    None,
    None,
    Some(&WORD_ABSOL_NODE),
    None,
    None,
    Some(&WORD_ABSOO_NODE),
    Some(&WORD_ABSOP_NODE),
    None,
    Some(&WORD_ABSOR_NODE),
    None,
    None,
    Some(&WORD_ABSOU_NODE),
    Some(&WORD_ABSOV_NODE),
    None,
    None,
    None,
    None,
];

static WORD_ABSOV_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ABSOV_CHILDREN),
    value: None,
};

pub static WORD_ABSOV_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("le")],
    values: &[&["absolve"]],
    range: 2..=2,
};

static WORD_ABSOU_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ABSOU_CHILDREN),
    value: None,
};

pub static WORD_ABSOU_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ld"),
        dictgen::InsensitiveStr::Ascii("ldly"),
        dictgen::InsensitiveStr::Ascii("le"),
        dictgen::InsensitiveStr::Ascii("lely"),
        dictgen::InsensitiveStr::Ascii("lete"),
        dictgen::InsensitiveStr::Ascii("letely"),
        dictgen::InsensitiveStr::Ascii("lt"),
        dictgen::InsensitiveStr::Ascii("lte"),
        dictgen::InsensitiveStr::Ascii("ltely"),
        dictgen::InsensitiveStr::Ascii("ltes"),
        dictgen::InsensitiveStr::Ascii("ltly"),
        dictgen::InsensitiveStr::Ascii("lute"),
        dictgen::InsensitiveStr::Ascii("lutely"),
        dictgen::InsensitiveStr::Ascii("t"),
        dictgen::InsensitiveStr::Ascii("te"),
        dictgen::InsensitiveStr::Ascii("tely"),
        dictgen::InsensitiveStr::Ascii("tly"),
    ],
    values: &[
        &["absolute"],
        &["absolutely"],
        &["absolute"],
        &["absolutely"],
        &["absolute", "obsolete"],
        &["absolutely"],
        &["absolute"],
        &["absolute"],
        &["absolutely"],
        &["absolutes"],
        &["absolutely"],
        &["absolute"],
        &["absolutely"],
        &["absolute"],
        &["absolute"],
        &["absolutely"],
        &["absolutely"],
    ],
    range: 1..=6,
};

static WORD_ABSOR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ABSOR_CHILDREN),
    value: None,
};

pub static WORD_ABSOR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("bant"),
        dictgen::InsensitiveStr::Ascii("bes"),
        dictgen::InsensitiveStr::Ascii("bsion"),
        dictgen::InsensitiveStr::Ascii("btion"),
        dictgen::InsensitiveStr::Ascii("psion"),
        dictgen::InsensitiveStr::Ascii("ve"),
    ],
    values: &[
        &["absorbent"],
        &["absorbs"],
        &["absorption"],
        &["absorption"],
        &["absorption"],
        &["absorb"],
    ],
    range: 2..=5,
};

static WORD_ABSOP_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ABSOP_CHILDREN),
    value: None,
};

pub static WORD_ABSOP_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("rtion")],
    values: &[&["absorption"]],
    range: 5..=5,
};

static WORD_ABSOO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ABSOO_CHILDREN),
    value: None,
};

pub static WORD_ABSOO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("lute"),
        dictgen::InsensitiveStr::Ascii("lutely"),
    ],
    values: &[&["absolute"], &["absolutely"]],
    range: 4..=6,
};

static WORD_ABSOL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ABSOL_CHILDREN),
    value: None,
};

pub static WORD_ABSOL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ate"),
        dictgen::InsensitiveStr::Ascii("ately"),
        dictgen::InsensitiveStr::Ascii("aute"),
        dictgen::InsensitiveStr::Ascii("autely"),
        dictgen::InsensitiveStr::Ascii("ete"),
        dictgen::InsensitiveStr::Ascii("eted"),
        dictgen::InsensitiveStr::Ascii("etely"),
        dictgen::InsensitiveStr::Ascii("iute"),
        dictgen::InsensitiveStr::Ascii("iutely"),
        dictgen::InsensitiveStr::Ascii("oute"),
        dictgen::InsensitiveStr::Ascii("outely"),
        dictgen::InsensitiveStr::Ascii("te"),
        dictgen::InsensitiveStr::Ascii("tely"),
        dictgen::InsensitiveStr::Ascii("tue"),
        dictgen::InsensitiveStr::Ascii("tuely"),
        dictgen::InsensitiveStr::Ascii("uate"),
        dictgen::InsensitiveStr::Ascii("uately"),
        dictgen::InsensitiveStr::Ascii("ue"),
        dictgen::InsensitiveStr::Ascii("uely"),
        dictgen::InsensitiveStr::Ascii("uet"),
        dictgen::InsensitiveStr::Ascii("uetly"),
        dictgen::InsensitiveStr::Ascii("ule"),
        dictgen::InsensitiveStr::Ascii("ulte"),
        dictgen::InsensitiveStr::Ascii("ultely"),
        dictgen::InsensitiveStr::Ascii("ument"),
        dictgen::InsensitiveStr::Ascii("une"),
        dictgen::InsensitiveStr::Ascii("unely"),
        dictgen::InsensitiveStr::Ascii("ure"),
        dictgen::InsensitiveStr::Ascii("urely"),
        dictgen::InsensitiveStr::Ascii("ut"),
        dictgen::InsensitiveStr::Ascii("utelly"),
        dictgen::InsensitiveStr::Ascii("utelys"),
        dictgen::InsensitiveStr::Ascii("utey"),
        dictgen::InsensitiveStr::Ascii("uth"),
        dictgen::InsensitiveStr::Ascii("uthe"),
        dictgen::InsensitiveStr::Ascii("uthely"),
        dictgen::InsensitiveStr::Ascii("uthly"),
        dictgen::InsensitiveStr::Ascii("utisme"),
        dictgen::InsensitiveStr::Ascii("utiste"),
        dictgen::InsensitiveStr::Ascii("utley"),
        dictgen::InsensitiveStr::Ascii("utly"),
        dictgen::InsensitiveStr::Ascii("utlye"),
        dictgen::InsensitiveStr::Ascii("uts"),
        dictgen::InsensitiveStr::Ascii("uute"),
        dictgen::InsensitiveStr::Ascii("uutely"),
        dictgen::InsensitiveStr::Ascii("uve"),
        dictgen::InsensitiveStr::Ascii("uvely"),
        dictgen::InsensitiveStr::Ascii("vte"),
    ],
    values: &[
        &["absolute"],
        &["absolutely"],
        &["absolute"],
        &["absolutely"],
        &["absolute", "obsolete"],
        &["obsoleted"],
        &["absolutely"],
        &["absolute"],
        &["absolutely"],
        &["absolute"],
        &["absolutely"],
        &["absolute"],
        &["absolutely"],
        &["absolute"],
        &["absolutely"],
        &["absolute"],
        &["absolutely"],
        &["absolute"],
        &["absolutely"],
        &["absolute"],
        &["absolutely"],
        &["absolute"],
        &["absolute"],
        &["absolutely"],
        &["absolute"],
        &["absolute"],
        &["absolutely"],
        &["absolute"],
        &["absolutely"],
        &["absolute"],
        &["absolutely"],
        &["absolutes"],
        &["absolutely", "absolute"],
        &["absolute"],
        &["absolute"],
        &["absolutely"],
        &["absolutely"],
        &["absolutes"],
        &["absolutes"],
        &["absolutely"],
        &["absolutely"],
        &["absolutely"],
        &["absolutes"],
        &["absolute"],
        &["absolutely"],
        &["absolute"],
        &["absolutely"],
        &["absolve"],
    ],
    range: 2..=6,
};

static WORD_ABSOD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ABSOD_CHILDREN),
    value: None,
};

pub static WORD_ABSOD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("efly"),
        dictgen::InsensitiveStr::Ascii("eflyly"),
    ],
    values: &[&["absolute"], &["absolutely"]],
    range: 4..=6,
};

static WORD_ABSL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ABSL_CHILDREN),
    value: None,
};

pub static WORD_ABSL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("outes")],
    values: &[&["absolutes"]],
    range: 5..=5,
};

static WORD_ABSI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ABSI_CHILDREN),
    value: None,
};

pub static WORD_ABSI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ntence"),
        dictgen::InsensitiveStr::Ascii("tnence"),
    ],
    values: &[&["abstinence"], &["abstinence"]],
    range: 6..=6,
};

static WORD_ABSE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ABSE_CHILDREN),
    value: None,
};

pub static WORD_ABSE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("d"),
        dictgen::InsensitiveStr::Ascii("lutely"),
        dictgen::InsensitiveStr::Ascii("lutly"),
        dictgen::InsensitiveStr::Ascii("nse"),
        dictgen::InsensitiveStr::Ascii("stos"),
    ],
    values: &[
        &["abased", "based"],
        &["absolutely"],
        &["absolutely"],
        &["absence"],
        &["asbestos"],
    ],
    range: 1..=6,
};

static WORD_ABSC_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ABSC_CHILDREN),
    value: None,
};

pub static WORD_ABSC_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ence"),
        dictgen::InsensitiveStr::Ascii("ound"),
    ],
    values: &[&["absence"], &["abscond"]],
    range: 4..=4,
};

static WORD_ABSA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ABSA_CHILDREN),
    value: None,
};

pub static WORD_ABSA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("il"),
        dictgen::InsensitiveStr::Ascii("iling"),
        dictgen::InsensitiveStr::Ascii("nce"),
    ],
    values: &[&["abseil"], &["abseiling"], &["absence"]],
    range: 2..=5,
};

static WORD_ABR_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ABR_CHILDREN),
    value: None,
};

pub static WORD_ABR_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("eviate"),
        dictgen::InsensitiveStr::Ascii("eviated"),
        dictgen::InsensitiveStr::Ascii("eviates"),
        dictgen::InsensitiveStr::Ascii("eviating"),
        dictgen::InsensitiveStr::Ascii("eviation"),
        dictgen::InsensitiveStr::Ascii("eviations"),
        dictgen::InsensitiveStr::Ascii("iter"),
        dictgen::InsensitiveStr::Ascii("itrarily"),
        dictgen::InsensitiveStr::Ascii("itrary"),
        dictgen::InsensitiveStr::Ascii("itration"),
        dictgen::InsensitiveStr::Ascii("iviate"),
        dictgen::InsensitiveStr::Ascii("reviation"),
        dictgen::InsensitiveStr::Ascii("uplty"),
        dictgen::InsensitiveStr::Ascii("uptley"),
        dictgen::InsensitiveStr::Ascii("upty"),
        dictgen::InsensitiveStr::Ascii("utply"),
    ],
    values: &[
        &["abbreviate"],
        &["abbreviated"],
        &["abbreviates"],
        &["abbreviating"],
        &["abbreviation"],
        &["abbreviations"],
        &["arbiter"],
        &["arbitrarily"],
        &["arbitrary"],
        &["arbitration"],
        &["abbreviate"],
        &["abbreviation"],
        &["abruptly"],
        &["abruptly"],
        &["abruptly"],
        &["abruptly"],
    ],
    range: 4..=9,
};

static WORD_ABO_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ABO_CHILDREN),
    value: None,
};

pub static WORD_ABO_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ce"),
        dictgen::InsensitiveStr::Ascii("dmen"),
        dictgen::InsensitiveStr::Ascii("dminal"),
        dictgen::InsensitiveStr::Ascii("luste"),
        dictgen::InsensitiveStr::Ascii("lustely"),
        dictgen::InsensitiveStr::Ascii("lute"),
        dictgen::InsensitiveStr::Ascii("manation"),
        dictgen::InsensitiveStr::Ascii("minacion"),
        dictgen::InsensitiveStr::Ascii("minaton"),
        dictgen::InsensitiveStr::Ascii("monation"),
        dictgen::InsensitiveStr::Ascii("ndon"),
        dictgen::InsensitiveStr::Ascii("ndoned"),
        dictgen::InsensitiveStr::Ascii("ndoning"),
        dictgen::InsensitiveStr::Ascii("ndons"),
        dictgen::InsensitiveStr::Ascii("nimation"),
        dictgen::InsensitiveStr::Ascii("out"),
        dictgen::InsensitiveStr::Ascii("rd"),
        dictgen::InsensitiveStr::Ascii("rginial"),
        dictgen::InsensitiveStr::Ascii("riganal"),
        dictgen::InsensitiveStr::Ascii("rigenal"),
        dictgen::InsensitiveStr::Ascii("rigene"),
        dictgen::InsensitiveStr::Ascii("riginial"),
        dictgen::InsensitiveStr::Ascii("rigional"),
        dictgen::InsensitiveStr::Ascii("rignial"),
        dictgen::InsensitiveStr::Ascii("rigonal"),
        dictgen::InsensitiveStr::Ascii("roginal"),
        dictgen::InsensitiveStr::Ascii("rte"),
        dictgen::InsensitiveStr::Ascii("rtificant"),
        dictgen::InsensitiveStr::Ascii("slute"),
        dictgen::InsensitiveStr::Ascii("slutely"),
        dictgen::InsensitiveStr::Ascii("slutes"),
        dictgen::InsensitiveStr::Ascii("slve"),
        dictgen::InsensitiveStr::Ascii("srbed"),
        dictgen::InsensitiveStr::Ascii("srbing"),
        dictgen::InsensitiveStr::Ascii("srbs"),
        dictgen::InsensitiveStr::Ascii("srption"),
        dictgen::InsensitiveStr::Ascii("sulte"),
        dictgen::InsensitiveStr::Ascii("sultely"),
        dictgen::InsensitiveStr::Ascii("sulute"),
        dictgen::InsensitiveStr::Ascii("sulutely"),
        dictgen::InsensitiveStr::Ascii("tu"),
        dictgen::InsensitiveStr::Ascii("u"),
        dictgen::InsensitiveStr::Ascii("unt"),
        dictgen::InsensitiveStr::Ascii("urt"),
        dictgen::InsensitiveStr::Ascii("uta"),
        dictgen::InsensitiveStr::Ascii("uve"),
        dictgen::InsensitiveStr::Ascii("v"),
        dictgen::InsensitiveStr::Ascii("ved"),
        dictgen::InsensitiveStr::Ascii("vemtioned"),
        dictgen::InsensitiveStr::Ascii("ves"),
        dictgen::InsensitiveStr::Ascii("vmentioned"),
    ],
    values: &[
        &["above", "abode"],
        &["abdomen"],
        &["abdominal"],
        &["absolute"],
        &["absolutely"],
        &["absolute"],
        &["abomination"],
        &["abomination"],
        &["abomination"],
        &["abomination"],
        &["abandon"],
        &["abandoned"],
        &["abandoning"],
        &["abandons"],
        &["abomination"],
        &["about"],
        &["abort", "aboard"],
        &["aboriginal"],
        &["aboriginal"],
        &["aboriginal"],
        &["aborigine"],
        &["aboriginal"],
        &["aboriginal"],
        &["aboriginal"],
        &["aboriginal"],
        &["aboriginal"],
        &["aborted", "abort", "aborts"],
        &["abortifacient"],
        &["absolute"],
        &["absolutely"],
        &["absolutes"],
        &["absolve"],
        &["absorbed"],
        &["absorbing"],
        &["absorbs"],
        &["absorption"],
        &["absolute"],
        &["absolutely"],
        &["absolute"],
        &["absolutely"],
        &["about"],
        &["about", "abound"],
        &["about"],
        &["abort", "about"],
        &["about"],
        &["above"],
        &["above"],
        &["above"],
        &["abovementioned"],
        &["above"],
        &["abovementioned"],
    ],
    range: 1..=10,
};

static WORD_ABN_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ABN_CHILDREN),
    value: None,
};

pub static WORD_ABN_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("oramlly"),
        dictgen::InsensitiveStr::Ascii("ormalty"),
        dictgen::InsensitiveStr::Ascii("ormaly"),
        dictgen::InsensitiveStr::Ascii("ornally"),
        dictgen::InsensitiveStr::Ascii("ove"),
        dictgen::InsensitiveStr::Ascii("rormal"),
    ],
    values: &[
        &["abnormally"],
        &["abnormally"],
        &["abnormally"],
        &["abnormally"],
        &["above"],
        &["abnormal"],
    ],
    range: 3..=7,
};

static WORD_ABL_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ABL_CHILDREN),
    value: None,
};

pub static WORD_ABL_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("iity")],
    values: &[&["ability"]],
    range: 4..=4,
};

static WORD_ABI_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ABI_CHILDREN),
    value: None,
};

pub static WORD_ABI_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("gious"),
        dictgen::InsensitiveStr::Ascii("guity"),
        dictgen::InsensitiveStr::Ascii("litiy"),
        dictgen::InsensitiveStr::Ascii("lityes"),
        dictgen::InsensitiveStr::Ascii("lties"),
        dictgen::InsensitiveStr::Ascii("ltiy"),
        dictgen::InsensitiveStr::Ascii("lty"),
        dictgen::InsensitiveStr::Ascii("ove"),
        dictgen::InsensitiveStr::Ascii("ss"),
        dictgen::InsensitiveStr::Ascii("trarily"),
        dictgen::InsensitiveStr::Ascii("trary"),
        dictgen::InsensitiveStr::Ascii("trate"),
        dictgen::InsensitiveStr::Ascii("tration"),
        dictgen::InsensitiveStr::Ascii("zmal"),
    ],
    values: &[
        &["ambiguous"],
        &["ambiguity"],
        &["ability"],
        &["abilities"],
        &["abilities"],
        &["ability"],
        &["ability"],
        &["above"],
        &["abyss"],
        &["arbitrarily"],
        &["arbitrary"],
        &["arbitrate"],
        &["arbitration"],
        &["abysmal"],
    ],
    range: 2..=7,
};

static WORD_ABE_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ABE_CHILDREN),
    value: None,
};

pub static WORD_ABE_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[dictgen::InsensitiveStr::Ascii("ration")],
    values: &[&["aberration"]],
    range: 6..=6,
};

static WORD_ABD_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ABD_CHILDREN),
    value: None,
};

pub static WORD_ABD_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ominable"),
        dictgen::InsensitiveStr::Ascii("omine"),
        dictgen::InsensitiveStr::Ascii("omnial"),
        dictgen::InsensitiveStr::Ascii("onimal"),
    ],
    values: &[&["abdominal"], &["abdomen"], &["abdominal"], &["abdominal"]],
    range: 5..=8,
};

static WORD_ABB_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ABB_CHILDREN),
    value: None,
};

pub static WORD_ABB_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("breviated"),
        dictgen::InsensitiveStr::Ascii("eration"),
        dictgen::InsensitiveStr::Ascii("erations"),
        dictgen::InsensitiveStr::Ascii("erivates"),
        dictgen::InsensitiveStr::Ascii("erivation"),
        dictgen::InsensitiveStr::Ascii("erration"),
        dictgen::InsensitiveStr::Ascii("erviation"),
        dictgen::InsensitiveStr::Ascii("ort"),
        dictgen::InsensitiveStr::Ascii("orted"),
        dictgen::InsensitiveStr::Ascii("orting"),
        dictgen::InsensitiveStr::Ascii("orts"),
        dictgen::InsensitiveStr::Ascii("out"),
        dictgen::InsensitiveStr::Ascii("reivation"),
        dictgen::InsensitiveStr::Ascii("revate"),
        dictgen::InsensitiveStr::Ascii("revated"),
        dictgen::InsensitiveStr::Ascii("revation"),
        dictgen::InsensitiveStr::Ascii("revations"),
        dictgen::InsensitiveStr::Ascii("reveation"),
        dictgen::InsensitiveStr::Ascii("reviatin"),
        dictgen::InsensitiveStr::Ascii("reviato"),
        dictgen::InsensitiveStr::Ascii("reviaton"),
        dictgen::InsensitiveStr::Ascii("reviatons"),
        dictgen::InsensitiveStr::Ascii("rievation"),
        dictgen::InsensitiveStr::Ascii("rievations"),
        dictgen::InsensitiveStr::Ascii("riviate"),
        dictgen::InsensitiveStr::Ascii("riviation"),
        dictgen::InsensitiveStr::Ascii("riviations"),
    ],
    values: &[
        &["abbreviated"],
        &["aberration"],
        &["aberrations"],
        &["abbreviates"],
        &["abbreviation"],
        &["aberration"],
        &["abbreviation"],
        &["abort", "abbot"],
        &["aborted"],
        &["aborting"],
        &["aborts", "abbots"],
        &["about", "abbot"],
        &["abbreviation"],
        &["abbreviate"],
        &["abbreviated"],
        &["abbreviation"],
        &["abbreviations"],
        &["abbreviation"],
        &["abbreviation"],
        &["abbreviation"],
        &["abbreviation"],
        &["abbreviations"],
        &["abbreviation"],
        &["abbreviation"],
        &["abbreviate"],
        &["abbreviation"],
        &["abbreviations"],
    ],
    range: 3..=10,
};

static WORD_ABA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_ABA_CHILDREN),
    value: None,
};

pub static WORD_ABA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ilable"),
        dictgen::InsensitiveStr::Ascii("nden"),
        dictgen::InsensitiveStr::Ascii("ndenment"),
        dictgen::InsensitiveStr::Ascii("ndining"),
        dictgen::InsensitiveStr::Ascii("ndomnent"),
        dictgen::InsensitiveStr::Ascii("ndond"),
        dictgen::InsensitiveStr::Ascii("ndonded"),
        dictgen::InsensitiveStr::Ascii("ndonding"),
        dictgen::InsensitiveStr::Ascii("ndone"),
        dictgen::InsensitiveStr::Ascii("ndonig"),
        dictgen::InsensitiveStr::Ascii("ndonne"),
        dictgen::InsensitiveStr::Ascii("ndonned"),
        dictgen::InsensitiveStr::Ascii("ndonnent"),
        dictgen::InsensitiveStr::Ascii("ndonning"),
        dictgen::InsensitiveStr::Ascii("nonded"),
    ],
    values: &[
        &["available"],
        &["abandon"],
        &["abandonment"],
        &["abandoning"],
        &["abandonment"],
        &["abandoned"],
        &["abandoned"],
        &["abandoning"],
        &["abandon"],
        &["abandoning"],
        &["abandonment"],
        &["abandoned"],
        &["abandonment"],
        &["abandoning"],
        &["abandoned"],
    ],
    range: 4..=8,
};

static WORD_AA_NODE: dictgen::DictTrieNode<&'static [&'static str]> = dictgen::DictTrieNode {
    children: dictgen::DictTrieChild::Flat(&WORD_AA_CHILDREN),
    value: None,
};

pub static WORD_AA_CHILDREN: dictgen::DictTable<&'static [&'static str]> = dictgen::DictTable {
    keys: &[
        dictgen::InsensitiveStr::Ascii("ccess"),
        dictgen::InsensitiveStr::Ascii("ccessibility"),
        dictgen::InsensitiveStr::Ascii("ccession"),
        dictgen::InsensitiveStr::Ascii("che"),
        dictgen::InsensitiveStr::Ascii("ck"),
        dictgen::InsensitiveStr::Ascii("ctual"),
        dictgen::InsensitiveStr::Ascii("ctually"),
        dictgen::InsensitiveStr::Ascii("dd"),
        dictgen::InsensitiveStr::Ascii("dded"),
        dictgen::InsensitiveStr::Ascii("dding"),
        dictgen::InsensitiveStr::Ascii("gain"),
        dictgen::InsensitiveStr::Ascii("ggregation"),
        dictgen::InsensitiveStr::Ascii("nd"),
        dictgen::InsensitiveStr::Ascii("nother"),
        dictgen::InsensitiveStr::Ascii("pply"),
        dictgen::InsensitiveStr::Ascii("proximate"),
        dictgen::InsensitiveStr::Ascii("proximated"),
        dictgen::InsensitiveStr::Ascii("proximately"),
        dictgen::InsensitiveStr::Ascii("proximates"),
        dictgen::InsensitiveStr::Ascii("proximating"),
        dictgen::InsensitiveStr::Ascii("re"),
        dictgen::InsensitiveStr::Ascii("s"),
        dictgen::InsensitiveStr::Ascii("ssign"),
        dictgen::InsensitiveStr::Ascii("ssignment"),
        dictgen::InsensitiveStr::Ascii("ssignments"),
        dictgen::InsensitiveStr::Ascii("ssociated"),
        dictgen::InsensitiveStr::Ascii("ssumed"),
        dictgen::InsensitiveStr::Ascii("utomatic"),
        dictgen::InsensitiveStr::Ascii("utomatically"),
    ],
    values: &[
        &["access"],
        &["accessibility"],
        &["accession"],
        &["ache", "cache"],
        &["ack"],
        &["actual"],
        &["actually"],
        &["add"],
        &["added"],
        &["adding"],
        &["again"],
        &["aggregation"],
        &["and"],
        &["another"],
        &["apply"],
        &["approximate"],
        &["approximated"],
        &["approximately"],
        &["approximates"],
        &["approximating"],
        &["are"],
        &["as", "ass"],
        &["assign"],
        &["assignment"],
        &["assignments"],
        &["associated"],
        &["assumed"],
        &["automatic"],
        &["automatically"],
    ],
    range: 1..=12,
};
